No need for signed/unsigned modulo/divide

Signed-off-by: Sean Young <sean@mess.org>

src/codegen/cfg.rs

@@ -330,12 +330,12 @@ impl ControlFlowGraph {
                 self.expr_to_string(contract, ns, l),
                 self.expr_to_string(contract, ns, r)
             ),
-            Expression::UDivide(_, _, l, r) | Expression::SDivide(_, _, l, r) => format!(
+            Expression::Divide(_, _, l, r) => format!(
                 "({} / {})",
                 self.expr_to_string(contract, ns, l),
                 self.expr_to_string(contract, ns, r)
             ),
-            Expression::UModulo(_, _, l, r) | Expression::SModulo(_, _, l, r) => format!(
+            Expression::Modulo(_, _, l, r) => format!(
                 "({} % {})",
                 self.expr_to_string(contract, ns, l),
                 self.expr_to_string(contract, ns, r)

src/codegen/expression.rs

@@ -48,25 +48,13 @@ pub fn expression(
             Box::new(expression(left, cfg, contract_no, ns, vartab)),
             Box::new(expression(right, cfg, contract_no, ns, vartab)),
         ),
-        Expression::SDivide(loc, ty, left, right) => Expression::SDivide(
+        Expression::Divide(loc, ty, left, right) => Expression::Divide(
             *loc,
             ty.clone(),
             Box::new(expression(left, cfg, contract_no, ns, vartab)),
             Box::new(expression(right, cfg, contract_no, ns, vartab)),
         ),
-        Expression::UDivide(loc, ty, left, right) => Expression::UDivide(
-            *loc,
-            ty.clone(),
-            Box::new(expression(left, cfg, contract_no, ns, vartab)),
-            Box::new(expression(right, cfg, contract_no, ns, vartab)),
-        ),
-        Expression::SModulo(loc, ty, left, right) => Expression::SModulo(
-            *loc,
-            ty.clone(),
-            Box::new(expression(left, cfg, contract_no, ns, vartab)),
-            Box::new(expression(right, cfg, contract_no, ns, vartab)),
-        ),
-        Expression::UModulo(loc, ty, left, right) => Expression::UModulo(
+        Expression::Modulo(loc, ty, left, right) => Expression::Modulo(
             *loc,
             ty.clone(),
             Box::new(expression(left, cfg, contract_no, ns, vartab)),

src/emit/mod.rs

@@ -1165,7 +1165,7 @@ pub trait TargetRuntime<'a> {
                     contract.builder.build_int_mul(left, right, "").into()
                 }
             }
-            Expression::UDivide(_, _, l, r) => {
+            Expression::Divide(_, _, l, r) if !l.ty().is_signed_int() => {
                 let left = self.expression(contract, l, vartab, function);
                 let right = self.expression(contract, r, vartab, function);
 
@@ -1214,7 +1214,7 @@ pub trait TargetRuntime<'a> {
                         .into()
                 }
             }
-            Expression::SDivide(_, _, l, r) => {
+            Expression::Divide(_, _, l, r) => {
                 let left = self.expression(contract, l, vartab, function);
                 let right = self.expression(contract, r, vartab, function);
 
@@ -1259,7 +1259,7 @@ pub trait TargetRuntime<'a> {
                         .into()
                 }
             }
-            Expression::UModulo(_, _, l, r) => {
+            Expression::Modulo(_, _, l, r) if !l.ty().is_signed_int() => {
                 let left = self.expression(contract, l, vartab, function);
                 let right = self.expression(contract, r, vartab, function);
 
@@ -1308,7 +1308,7 @@ pub trait TargetRuntime<'a> {
                         .into()
                 }
             }
-            Expression::SModulo(_, _, l, r) => {
+            Expression::Modulo(_, _, l, r) => {
                 let left = self.expression(contract, l, vartab, function);
                 let right = self.expression(contract, r, vartab, function);
 

src/sema/ast.rs

@@ -430,10 +430,8 @@ pub enum Expression {
     Add(pt::Loc, Type, Box<Expression>, Box<Expression>),
     Subtract(pt::Loc, Type, Box<Expression>, Box<Expression>),
     Multiply(pt::Loc, Type, Box<Expression>, Box<Expression>),
-    UDivide(pt::Loc, Type, Box<Expression>, Box<Expression>),
-    SDivide(pt::Loc, Type, Box<Expression>, Box<Expression>),
-    UModulo(pt::Loc, Type, Box<Expression>, Box<Expression>),
-    SModulo(pt::Loc, Type, Box<Expression>, Box<Expression>),
+    Divide(pt::Loc, Type, Box<Expression>, Box<Expression>),
+    Modulo(pt::Loc, Type, Box<Expression>, Box<Expression>),
     Power(pt::Loc, Type, Box<Expression>, Box<Expression>),
     BitwiseOr(pt::Loc, Type, Box<Expression>, Box<Expression>),
     BitwiseAnd(pt::Loc, Type, Box<Expression>, Box<Expression>),
@@ -561,10 +559,8 @@ impl Expression {
                 Expression::Add(_, _, left, right)
                 | Expression::Subtract(_, _, left, right)
                 | Expression::Multiply(_, _, left, right)
-                | Expression::UDivide(_, _, left, right)
-                | Expression::SDivide(_, _, left, right)
-                | Expression::UModulo(_, _, left, right)
-                | Expression::SModulo(_, _, left, right)
+                | Expression::Divide(_, _, left, right)
+                | Expression::Modulo(_, _, left, right)
                 | Expression::Power(_, _, left, right)
                 | Expression::BitwiseOr(_, _, left, right)
                 | Expression::BitwiseAnd(_, _, left, right)

src/sema/eval.rs

@@ -26,7 +26,7 @@ pub fn eval_const_number(
             *loc,
             eval_const_number(l, contract_no, ns)?.1 * eval_const_number(r, contract_no, ns)?.1,
         )),
-        Expression::UDivide(loc, _, l, r) | Expression::SDivide(loc, _, l, r) => {
+        Expression::Divide(loc, _, l, r) => {
             let divisor = eval_const_number(r, contract_no, ns)?.1;
 
             if divisor.is_zero() {
@@ -35,7 +35,7 @@ pub fn eval_const_number(
                 Ok((*loc, eval_const_number(l, contract_no, ns)?.1 / divisor))
             }
         }
-        Expression::UModulo(loc, _, l, r) | Expression::SModulo(loc, _, l, r) => {
+        Expression::Modulo(loc, _, l, r) => {
             let divisor = eval_const_number(r, contract_no, ns)?.1;
 
             if divisor.is_zero() {

src/sema/expression.rs

@@ -40,10 +40,8 @@ impl Expression {
             | Expression::Add(loc, _, _, _)
             | Expression::Subtract(loc, _, _, _)
             | Expression::Multiply(loc, _, _, _)
-            | Expression::UDivide(loc, _, _, _)
-            | Expression::SDivide(loc, _, _, _)
-            | Expression::UModulo(loc, _, _, _)
-            | Expression::SModulo(loc, _, _, _)
+            | Expression::Divide(loc, _, _, _)
+            | Expression::Modulo(loc, _, _, _)
             | Expression::Power(loc, _, _, _)
             | Expression::BitwiseOr(loc, _, _, _)
             | Expression::BitwiseAnd(loc, _, _, _)
@@ -130,10 +128,8 @@ impl Expression {
             | Expression::Add(_, ty, _, _)
             | Expression::Subtract(_, ty, _, _)
             | Expression::Multiply(_, ty, _, _)
-            | Expression::UDivide(_, ty, _, _)
-            | Expression::SDivide(_, ty, _, _)
-            | Expression::UModulo(_, ty, _, _)
-            | Expression::SModulo(_, ty, _, _)
+            | Expression::Divide(_, ty, _, _)
+            | Expression::Modulo(_, ty, _, _)
             | Expression::Power(_, ty, _, _)
             | Expression::BitwiseOr(_, ty, _, _)
             | Expression::BitwiseAnd(_, ty, _, _)
@@ -1482,21 +1478,12 @@ pub fn expression(
 
             let ty = coerce_int(&left.ty(), &l.loc(), &right.ty(), &r.loc(), false, ns)?;
 
-            if ty.is_signed_int() {
-                Ok(Expression::SDivide(
-                    *loc,
-                    ty.clone(),
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            } else {
-                Ok(Expression::UDivide(
-                    *loc,
-                    ty.clone(),
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            }
+            Ok(Expression::Divide(
+                *loc,
+                ty.clone(),
+                Box::new(cast(&l.loc(), left, &ty, true, ns)?),
+                Box::new(cast(&r.loc(), right, &ty, true, ns)?),
+            ))
         }
         pt::Expression::Modulo(loc, l, r) => {
             let left = expression(l, file_no, contract_no, ns, symtable, is_constant)?;
@@ -1504,21 +1491,12 @@ pub fn expression(
 
             let ty = coerce_int(&left.ty(), &l.loc(), &right.ty(), &r.loc(), false, ns)?;
 
-            if ty.is_signed_int() {
-                Ok(Expression::SModulo(
-                    *loc,
-                    ty.clone(),
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            } else {
-                Ok(Expression::UModulo(
-                    *loc,
-                    ty.clone(),
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            }
+            Ok(Expression::Modulo(
+                *loc,
+                ty.clone(),
+                Box::new(cast(&l.loc(), left, &ty, true, ns)?),
+                Box::new(cast(&r.loc(), right, &ty, true, ns)?),
+            ))
         }
         pt::Expression::Power(loc, b, e) => {
             let base = expression(b, file_no, contract_no, ns, symtable, is_constant)?;
@@ -2851,18 +2829,10 @@ fn assign_expr(
                 ty.is_signed_int(),
             ),
             pt::Expression::AssignDivide(_, _, _) => {
-                if ty.is_signed_int() {
-                    Expression::SDivide(*loc, ty.clone(), Box::new(assign), Box::new(set))
-                } else {
-                    Expression::UDivide(*loc, ty.clone(), Box::new(assign), Box::new(set))
-                }
+                Expression::Divide(*loc, ty.clone(), Box::new(assign), Box::new(set))
             }
             pt::Expression::AssignModulo(_, _, _) => {
-                if ty.is_signed_int() {
-                    Expression::SModulo(*loc, ty.clone(), Box::new(assign), Box::new(set))
-                } else {
-                    Expression::UModulo(*loc, ty.clone(), Box::new(assign), Box::new(set))
-                }
+                Expression::Modulo(*loc, ty.clone(), Box::new(assign), Box::new(set))
             }
             _ => unreachable!(),
         })

src/sema/printer.rs

@@ -76,20 +76,12 @@ fn print_expr(e: &Expression, func: Option<&Function>, ns: &Namespace) -> Tree {
             format!("multiply {}", ty.to_string(ns)),
             vec![print_expr(left, func, ns), print_expr(right, func, ns)],
         ),
-        Expression::UDivide(_, ty, left, right) => Tree::Branch(
-            format!("unsigned divide {}", ty.to_string(ns)),
+        Expression::Divide(_, ty, left, right) => Tree::Branch(
+            format!("divide {}", ty.to_string(ns)),
             vec![print_expr(left, func, ns), print_expr(right, func, ns)],
         ),
-        Expression::SDivide(_, ty, left, right) => Tree::Branch(
-            format!("signed divide {}", ty.to_string(ns)),
-            vec![print_expr(left, func, ns), print_expr(right, func, ns)],
-        ),
-        Expression::UModulo(_, ty, left, right) => Tree::Branch(
-            format!("unsigned modulo {}", ty.to_string(ns)),
-            vec![print_expr(left, func, ns), print_expr(right, func, ns)],
-        ),
-        Expression::SModulo(_, ty, left, right) => Tree::Branch(
-            format!("signed modulo {}", ty.to_string(ns)),
+        Expression::Modulo(_, ty, left, right) => Tree::Branch(
+            format!("modulo {}", ty.to_string(ns)),
             vec![print_expr(left, func, ns), print_expr(right, func, ns)],
         ),
         Expression::Power(_, ty, left, right) => Tree::Branch(