Fix some errors, cargo +nightly test passes.

Author: jon-chuang

ff/src/fields/arithmetic.rs

@@ -209,16 +209,14 @@ macro_rules! result_body {
         paste::paste! {
             let mut result = $self;
             result.[<$name _assign>](&$($deref)?$other);
-            result
+            return result;
         }
     }
 }
 
 macro_rules! assign_body {
     ($name:ident, $self:ident, $other:ident, $($deref:tt)?) => {
-        paste::paste! {
-            $self.[<$name _assign>](&$($deref)?$other);
-        }
+        $self.$name(&$($deref)?$other)
     }
 }
 
@@ -237,7 +235,8 @@ macro_rules! impl_ops_from_ref {
                     (
                         $name:ident,
                         $body:ident
-                        $d(, {$d output:ident})?
+                        $d(, {$d output:ident $d self_return:ident})?
+                        $d(, [$d self_mut:tt])?
                         $d(, <$d lifetime:tt $d mut:tt $d deref:tt>)?
                     ) => {
                         paste::paste! {
@@ -254,7 +253,7 @@ macro_rules! impl_ops_from_ref {
                                 $d(type $d output = Self;)?
 
                                 #[inline]
-                                fn $name(self, other: Self) -> Self {
+                                fn $name($d(&$d self_mut)?self, other: $d(&$d lifetime )?$d($d mut )?Self) $d(-> $d self_return)? {
                                     $body!($name, self, other, $d($d deref)?);
                                 }
                             }
@@ -292,25 +291,25 @@ macro_rules! impl_ops_from_ref {
 
         instantiate!($);
 
-        ops!(add, result_body, {Output});
-        ops!(add, result_body, {Output}, <'a mut *>);
-        ops!(sub, result_body, {Output});
-        ops!(sub, result_body, {Output}, <'a mut *>);
+        ops!(add, result_body, {Output Self});
+        ops!(add, result_body, {Output Self}, <'a mut *>);
+        ops!(sub, result_body, {Output Self});
+        ops!(sub, result_body, {Output Self}, <'a mut *>);
 
-        ops!(mul, result_body, {Output});
-        ops!(mul, result_body, {Output}, <'a mut *>);
-        ops!(div, result_body, {Output});
-        ops!(div, result_body, {Output}, <'a mut *>);
+        ops!(mul, result_body, {Output Self});
+        ops!(mul, result_body, {Output Self}, <'a mut *>);
+        ops!(div, result_body, {Output Self});
+        ops!(div, result_body, {Output Self}, <'a mut *>);
 
-        ops!(add_assign, assign_body);
-        ops!(add_assign, assign_body, <'a mut *>);
-        ops!(sub_assign, assign_body);
-        ops!(sub_assign, assign_body, <'a mut *>);
+        ops!(add_assign, assign_body, [mut]);
+        ops!(add_assign, assign_body, [mut], <'a mut *>);
+        ops!(sub_assign, assign_body, [mut]);
+        ops!(sub_assign, assign_body, [mut], <'a mut *>);
 
-        ops!(mul_assign, assign_body);
-        ops!(mul_assign, assign_body, <'a mut *>);
-        ops!(div_assign, assign_body);
-        ops!(div_assign, assign_body, <'a mut *>);
+        ops!(mul_assign, assign_body, [mut]);
+        ops!(mul_assign, assign_body, [mut], <'a mut *>);
+        ops!(div_assign, assign_body, [mut]);
+        ops!(div_assign, assign_body, [mut], <'a mut *>);
 
         use core::iter::{Sum, Product};