No need seperate signed/unsigned comparison expressions

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

src/codegen/cfg.rs

@@ -373,43 +373,23 @@ impl ControlFlowGraph {
                 ty.to_string(ns),
                 self.expr_to_string(contract, ns, e)
             ),
-            Expression::SMore(_, l, r) => format!(
-                "({} >(s) {})",
+            Expression::More(_, l, r) => format!(
+                "({} > {})",
                 self.expr_to_string(contract, ns, l),
                 self.expr_to_string(contract, ns, r)
             ),
-            Expression::SLess(_, l, r) => format!(
-                "({} <(s) {})",
+            Expression::Less(_, l, r) => format!(
+                "({} < {})",
                 self.expr_to_string(contract, ns, l),
                 self.expr_to_string(contract, ns, r)
             ),
-            Expression::SMoreEqual(_, l, r) => format!(
-                "({} >=(s) {})",
+            Expression::MoreEqual(_, l, r) => format!(
+                "({} >= {})",
                 self.expr_to_string(contract, ns, l),
                 self.expr_to_string(contract, ns, r)
             ),
-            Expression::SLessEqual(_, l, r) => format!(
-                "({} <=(s) {})",
-                self.expr_to_string(contract, ns, l),
-                self.expr_to_string(contract, ns, r)
-            ),
-            Expression::UMore(_, l, r) => format!(
-                "({} >(u) {})",
-                self.expr_to_string(contract, ns, l),
-                self.expr_to_string(contract, ns, r)
-            ),
-            Expression::ULess(_, l, r) => format!(
-                "({} <(u) {})",
-                self.expr_to_string(contract, ns, l),
-                self.expr_to_string(contract, ns, r)
-            ),
-            Expression::UMoreEqual(_, l, r) => format!(
-                "({} >=(u) {})",
-                self.expr_to_string(contract, ns, l),
-                self.expr_to_string(contract, ns, r)
-            ),
-            Expression::ULessEqual(_, l, r) => format!(
-                "({} <=(u) {})",
+            Expression::LessEqual(_, l, r) => format!(
+                "({} <= {})",
                 self.expr_to_string(contract, ns, l),
                 self.expr_to_string(contract, ns, r)
             ),

src/codegen/expression.rs

@@ -119,42 +119,22 @@ pub fn expression(
             Box::new(expression(left, cfg, contract_no, ns, vartab)),
             Box::new(expression(right, cfg, contract_no, ns, vartab)),
         ),
-        Expression::SMore(loc, left, right) => Expression::SMore(
+        Expression::More(loc, left, right) => Expression::More(
             *loc,
             Box::new(expression(left, cfg, contract_no, ns, vartab)),
             Box::new(expression(right, cfg, contract_no, ns, vartab)),
         ),
-        Expression::SMoreEqual(loc, left, right) => Expression::SMoreEqual(
+        Expression::MoreEqual(loc, left, right) => Expression::MoreEqual(
             *loc,
             Box::new(expression(left, cfg, contract_no, ns, vartab)),
             Box::new(expression(right, cfg, contract_no, ns, vartab)),
         ),
-        Expression::UMore(loc, left, right) => Expression::UMore(
+        Expression::Less(loc, left, right) => Expression::Less(
             *loc,
             Box::new(expression(left, cfg, contract_no, ns, vartab)),
             Box::new(expression(right, cfg, contract_no, ns, vartab)),
         ),
-        Expression::UMoreEqual(loc, left, right) => Expression::UMoreEqual(
-            *loc,
-            Box::new(expression(left, cfg, contract_no, ns, vartab)),
-            Box::new(expression(right, cfg, contract_no, ns, vartab)),
-        ),
-        Expression::SLess(loc, left, right) => Expression::SLess(
-            *loc,
-            Box::new(expression(left, cfg, contract_no, ns, vartab)),
-            Box::new(expression(right, cfg, contract_no, ns, vartab)),
-        ),
-        Expression::SLessEqual(loc, left, right) => Expression::SLessEqual(
-            *loc,
-            Box::new(expression(left, cfg, contract_no, ns, vartab)),
-            Box::new(expression(right, cfg, contract_no, ns, vartab)),
-        ),
-        Expression::ULess(loc, left, right) => Expression::ULess(
-            *loc,
-            Box::new(expression(left, cfg, contract_no, ns, vartab)),
-            Box::new(expression(right, cfg, contract_no, ns, vartab)),
-        ),
-        Expression::ULessEqual(loc, left, right) => Expression::ULessEqual(
+        Expression::LessEqual(loc, left, right) => Expression::LessEqual(
             *loc,
             Box::new(expression(left, cfg, contract_no, ns, vartab)),
             Box::new(expression(right, cfg, contract_no, ns, vartab)),
@@ -1450,7 +1430,7 @@ fn array_subscript(
     cfg.add(
         vartab,
         Instr::BranchCond {
-            cond: Expression::UMoreEqual(
+            cond: Expression::MoreEqual(
                 *loc,
                 Box::new(Expression::Variable(index_loc, coerced_ty.clone(), pos)),
                 Box::new(

src/emit/mod.rs

@@ -1393,7 +1393,7 @@ pub trait TargetRuntime<'a> {
                     .build_int_compare(IntPredicate::NE, left, right, "")
                     .into()
             }
-            Expression::SMore(_, l, r) => {
+            Expression::More(_, l, r) => {
                 let left = self
                     .expression(contract, l, vartab, function)
                     .into_int_value();
@@ -1403,62 +1403,19 @@ pub trait TargetRuntime<'a> {
 
                 contract
                     .builder
-                    .build_int_compare(IntPredicate::SGT, left, right, "")
-                    .into()
-            }
-            Expression::SMoreEqual(_, l, r) => {
-                let left = self
-                    .expression(contract, l, vartab, function)
-                    .into_int_value();
-                let right = self
-                    .expression(contract, r, vartab, function)
-                    .into_int_value();
-
-                contract
-                    .builder
-                    .build_int_compare(IntPredicate::SGE, left, right, "")
-                    .into()
-            }
-            Expression::SLess(_, l, r) => {
-                let left = self
-                    .expression(contract, l, vartab, function)
-                    .into_int_value();
-                let right = self
-                    .expression(contract, r, vartab, function)
-                    .into_int_value();
-
-                contract
-                    .builder
-                    .build_int_compare(IntPredicate::SLT, left, right, "")
-                    .into()
-            }
-            Expression::SLessEqual(_, l, r) => {
-                let left = self
-                    .expression(contract, l, vartab, function)
-                    .into_int_value();
-                let right = self
-                    .expression(contract, r, vartab, function)
-                    .into_int_value();
-
-                contract
-                    .builder
-                    .build_int_compare(IntPredicate::SLE, left, right, "")
-                    .into()
-            }
-            Expression::UMore(_, l, r) => {
-                let left = self
-                    .expression(contract, l, vartab, function)
-                    .into_int_value();
-                let right = self
-                    .expression(contract, r, vartab, function)
-                    .into_int_value();
-
-                contract
-                    .builder
-                    .build_int_compare(IntPredicate::UGT, left, right, "")
+                    .build_int_compare(
+                        if l.ty().is_signed_int() {
+                            IntPredicate::SGT
+                        } else {
+                            IntPredicate::UGT
+                        },
+                        left,
+                        right,
+                        "",
+                    )
                     .into()
             }
-            Expression::UMoreEqual(_, l, r) => {
+            Expression::MoreEqual(_, l, r) => {
                 let left = self
                     .expression(contract, l, vartab, function)
                     .into_int_value();
@@ -1468,10 +1425,19 @@ pub trait TargetRuntime<'a> {
 
                 contract
                     .builder
-                    .build_int_compare(IntPredicate::UGE, left, right, "")
+                    .build_int_compare(
+                        if l.ty().is_signed_int() {
+                            IntPredicate::SGE
+                        } else {
+                            IntPredicate::UGE
+                        },
+                        left,
+                        right,
+                        "",
+                    )
                     .into()
             }
-            Expression::ULess(_, l, r) => {
+            Expression::Less(_, l, r) => {
                 let left = self
                     .expression(contract, l, vartab, function)
                     .into_int_value();
@@ -1481,10 +1447,19 @@ pub trait TargetRuntime<'a> {
 
                 contract
                     .builder
-                    .build_int_compare(IntPredicate::ULT, left, right, "")
+                    .build_int_compare(
+                        if l.ty().is_signed_int() {
+                            IntPredicate::SLT
+                        } else {
+                            IntPredicate::ULT
+                        },
+                        left,
+                        right,
+                        "",
+                    )
                     .into()
             }
-            Expression::ULessEqual(_, l, r) => {
+            Expression::LessEqual(_, l, r) => {
                 let left = self
                     .expression(contract, l, vartab, function)
                     .into_int_value();
@@ -1494,7 +1469,16 @@ pub trait TargetRuntime<'a> {
 
                 contract
                     .builder
-                    .build_int_compare(IntPredicate::ULE, left, right, "")
+                    .build_int_compare(
+                        if l.ty().is_signed_int() {
+                            IntPredicate::SLE
+                        } else {
+                            IntPredicate::ULE
+                        },
+                        left,
+                        right,
+                        "",
+                    )
                     .into()
             }
             Expression::Variable(_, _, s) => vartab[s].value,

src/sema/ast.rs

@@ -457,14 +457,10 @@ pub enum Expression {
     PostDecrement(pt::Loc, Type, Box<Expression>),
     Assign(pt::Loc, Type, Box<Expression>, Box<Expression>),
 
-    UMore(pt::Loc, Box<Expression>, Box<Expression>),
-    ULess(pt::Loc, Box<Expression>, Box<Expression>),
-    UMoreEqual(pt::Loc, Box<Expression>, Box<Expression>),
-    ULessEqual(pt::Loc, Box<Expression>, Box<Expression>),
-    SMore(pt::Loc, Box<Expression>, Box<Expression>),
-    SLess(pt::Loc, Box<Expression>, Box<Expression>),
-    SMoreEqual(pt::Loc, Box<Expression>, Box<Expression>),
-    SLessEqual(pt::Loc, Box<Expression>, Box<Expression>),
+    More(pt::Loc, Box<Expression>, Box<Expression>),
+    Less(pt::Loc, Box<Expression>, Box<Expression>),
+    MoreEqual(pt::Loc, Box<Expression>, Box<Expression>),
+    LessEqual(pt::Loc, Box<Expression>, Box<Expression>),
     Equal(pt::Loc, Box<Expression>, Box<Expression>),
     NotEqual(pt::Loc, Box<Expression>, Box<Expression>),
 
@@ -591,14 +587,10 @@ impl Expression {
                 | Expression::PostDecrement(_, _, expr) => expr.recurse(cx, f),
 
                 Expression::Assign(_, _, left, right)
-                | Expression::UMore(_, left, right)
-                | Expression::ULess(_, left, right)
-                | Expression::UMoreEqual(_, left, right)
-                | Expression::ULessEqual(_, left, right)
-                | Expression::SMore(_, left, right)
-                | Expression::SLess(_, left, right)
-                | Expression::SMoreEqual(_, left, right)
-                | Expression::SLessEqual(_, left, right)
+                | Expression::More(_, left, right)
+                | Expression::Less(_, left, right)
+                | Expression::MoreEqual(_, left, right)
+                | Expression::LessEqual(_, left, right)
                 | Expression::Equal(_, left, right)
                 | Expression::NotEqual(_, left, right) => {
                     left.recurse(cx, f);

src/sema/expression.rs

@@ -60,14 +60,10 @@ impl Expression {
             | Expression::Trunc(loc, _, _)
             | Expression::Cast(loc, _, _)
             | Expression::BytesCast(loc, _, _, _)
-            | Expression::UMore(loc, _, _)
-            | Expression::ULess(loc, _, _)
-            | Expression::UMoreEqual(loc, _, _)
-            | Expression::ULessEqual(loc, _, _)
-            | Expression::SMore(loc, _, _)
-            | Expression::SLess(loc, _, _)
-            | Expression::SMoreEqual(loc, _, _)
-            | Expression::SLessEqual(loc, _, _)
+            | Expression::More(loc, _, _)
+            | Expression::Less(loc, _, _)
+            | Expression::MoreEqual(loc, _, _)
+            | Expression::LessEqual(loc, _, _)
             | Expression::Equal(loc, _, _)
             | Expression::NotEqual(loc, _, _)
             | Expression::Not(loc, _)
@@ -113,14 +109,10 @@ impl Expression {
     pub fn ty(&self) -> Type {
         match self {
             Expression::BoolLiteral(_, _)
-            | Expression::UMore(_, _, _)
-            | Expression::ULess(_, _, _)
-            | Expression::UMoreEqual(_, _, _)
-            | Expression::ULessEqual(_, _, _)
-            | Expression::SMore(_, _, _)
-            | Expression::SLess(_, _, _)
-            | Expression::SMoreEqual(_, _, _)
-            | Expression::SLessEqual(_, _, _)
+            | Expression::More(_, _, _)
+            | Expression::Less(_, _, _)
+            | Expression::MoreEqual(_, _, _)
+            | Expression::LessEqual(_, _, _)
             | Expression::Equal(_, _, _)
             | Expression::Or(_, _, _)
             | Expression::And(_, _, _)
@@ -1561,19 +1553,11 @@ pub fn expression(
 
             let ty = coerce_int(&left.ty(), &l.loc(), &right.ty(), &r.loc(), true, ns)?;
 
-            if ty.is_signed_int() {
-                Ok(Expression::SMore(
-                    *loc,
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            } else {
-                Ok(Expression::UMore(
-                    *loc,
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            }
+            Ok(Expression::More(
+                *loc,
+                Box::new(cast(&l.loc(), left, &ty, true, ns)?),
+                Box::new(cast(&r.loc(), right, &ty, true, ns)?),
+            ))
         }
         pt::Expression::Less(loc, l, r) => {
             let left = expression(l, file_no, contract_no, ns, symtable, is_constant)?;
@@ -1581,19 +1565,11 @@ pub fn expression(
 
             let ty = coerce_int(&left.ty(), &l.loc(), &right.ty(), &r.loc(), true, ns)?;
 
-            if ty.is_signed_int() {
-                Ok(Expression::SLess(
-                    *loc,
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            } else {
-                Ok(Expression::ULess(
-                    *loc,
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            }
+            Ok(Expression::Less(
+                *loc,
+                Box::new(cast(&l.loc(), left, &ty, true, ns)?),
+                Box::new(cast(&r.loc(), right, &ty, true, ns)?),
+            ))
         }
         pt::Expression::MoreEqual(loc, l, r) => {
             let left = expression(l, file_no, contract_no, ns, symtable, is_constant)?;
@@ -1601,19 +1577,11 @@ pub fn expression(
 
             let ty = coerce_int(&left.ty(), &l.loc(), &right.ty(), &r.loc(), true, ns)?;
 
-            if ty.is_signed_int() {
-                Ok(Expression::SMoreEqual(
-                    *loc,
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            } else {
-                Ok(Expression::UMoreEqual(
-                    *loc,
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            }
+            Ok(Expression::MoreEqual(
+                *loc,
+                Box::new(cast(&l.loc(), left, &ty, true, ns)?),
+                Box::new(cast(&r.loc(), right, &ty, true, ns)?),
+            ))
         }
         pt::Expression::LessEqual(loc, l, r) => {
             let left = expression(l, file_no, contract_no, ns, symtable, is_constant)?;
@@ -1621,19 +1589,11 @@ pub fn expression(
 
             let ty = coerce_int(&left.ty(), &l.loc(), &right.ty(), &r.loc(), true, ns)?;
 
-            if ty.is_signed_int() {
-                Ok(Expression::SLessEqual(
-                    *loc,
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            } else {
-                Ok(Expression::ULessEqual(
-                    *loc,
-                    Box::new(cast(&l.loc(), left, &ty, true, ns)?),
-                    Box::new(cast(&r.loc(), right, &ty, true, ns)?),
-                ))
-            }
+            Ok(Expression::LessEqual(
+                *loc,
+                Box::new(cast(&l.loc(), left, &ty, true, ns)?),
+                Box::new(cast(&r.loc(), right, &ty, true, ns)?),
+            ))
         }
         pt::Expression::Equal(loc, l, r) => {
             equal(loc, l, r, file_no, contract_no, ns, symtable, is_constant)

src/sema/printer.rs

@@ -179,36 +179,20 @@ fn print_expr(e: &Expression, func: Option<&Function>, ns: &Namespace) -> Tree {
             format!("assign {}", ty.to_string(ns)),
             vec![print_expr(left, func, ns), print_expr(right, func, ns)],
         ),
-        Expression::UMore(_, left, right) => Tree::Branch(
-            String::from("unsigned more"),
+        Expression::More(_, left, right) => Tree::Branch(
+            String::from("more"),
             vec![print_expr(left, func, ns), print_expr(right, func, ns)],
         ),
-        Expression::ULess(_, left, right) => Tree::Branch(
-            String::from("unsigned less"),
+        Expression::Less(_, left, right) => Tree::Branch(
+            String::from("less"),
             vec![print_expr(left, func, ns), print_expr(right, func, ns)],
         ),
-        Expression::UMoreEqual(_, left, right) => Tree::Branch(
-            String::from("unsigned more or equal"),
+        Expression::MoreEqual(_, left, right) => Tree::Branch(
+            String::from("more or equal"),
             vec![print_expr(left, func, ns), print_expr(right, func, ns)],
         ),
-        Expression::ULessEqual(_, left, right) => Tree::Branch(
-            String::from("unsigned less or equal"),
-            vec![print_expr(left, func, ns), print_expr(right, func, ns)],
-        ),
-        Expression::SMore(_, left, right) => Tree::Branch(
-            String::from("signed more"),
-            vec![print_expr(left, func, ns), print_expr(right, func, ns)],
-        ),
-        Expression::SLess(_, left, right) => Tree::Branch(
-            String::from("signed less"),
-            vec![print_expr(left, func, ns), print_expr(right, func, ns)],
-        ),
-        Expression::SMoreEqual(_, left, right) => Tree::Branch(
-            String::from("signed more or equal"),
-            vec![print_expr(left, func, ns), print_expr(right, func, ns)],
-        ),
-        Expression::SLessEqual(_, left, right) => Tree::Branch(
-            String::from("signed less or equal"),
+        Expression::LessEqual(_, left, right) => Tree::Branch(
+            String::from("less or equal"),
             vec![print_expr(left, func, ns), print_expr(right, func, ns)],
         ),
         Expression::Equal(_, left, right) => Tree::Branch(