more coverage

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

src/codegen/expression.rs

@@ -1156,12 +1156,9 @@ pub fn expression(
                 ty,
             }
         }
-        // Stray type operator which is unused, can return anything here
-        ast::Expression::TypeOperator { loc, .. } => Expression::BoolLiteral {
-            loc: *loc,
-            value: false,
-        },
-        ast::Expression::List { .. } => unreachable!("List shall not appear in the CFG"),
+        ast::Expression::TypeOperator { .. } | ast::Expression::List { .. } => {
+            unreachable!("List shall not appear in the CFG")
+        }
     }
 }
 

src/codegen/statements/mod.rs

@@ -170,37 +170,45 @@ pub(crate) fn statement(
             }
         }
         Statement::Expression(_, _, expr) => {
-            if let ast::Expression::Assign { left, right, .. } = &expr {
-                if should_remove_assignment(left, func, opt, ns) {
-                    let mut params = SideEffectsCheckParameters {
-                        cfg,
-                        contract_no,
-                        func: Some(func),
-                        ns,
-                        vartab,
-                        opt,
-                    };
-                    right.recurse(&mut params, process_side_effects_expressions);
-
-                    return;
+            match expr {
+                ast::Expression::Assign { left, right, .. } => {
+                    if should_remove_assignment(left, func, opt, ns) {
+                        let mut params = SideEffectsCheckParameters {
+                            cfg,
+                            contract_no,
+                            func: Some(func),
+                            ns,
+                            vartab,
+                            opt,
+                        };
+                        right.recurse(&mut params, process_side_effects_expressions);
+
+                        return;
+                    }
                 }
-            } else if let ast::Expression::Builtin { args, .. } = expr {
-                // When array pop and push are top-level expressions, they can be removed
-                if should_remove_assignment(expr, func, opt, ns) {
-                    let mut params = SideEffectsCheckParameters {
-                        cfg,
-                        contract_no,
-                        func: Some(func),
-                        ns,
-                        vartab,
-                        opt,
-                    };
-                    for arg in args {
-                        arg.recurse(&mut params, process_side_effects_expressions);
+                ast::Expression::Builtin { args, .. } => {
+                    // When array pop and push are top-level expressions, they can be removed
+                    if should_remove_assignment(expr, func, opt, ns) {
+                        let mut params = SideEffectsCheckParameters {
+                            cfg,
+                            contract_no,
+                            func: Some(func),
+                            ns,
+                            vartab,
+                            opt,
+                        };
+                        for arg in args {
+                            arg.recurse(&mut params, process_side_effects_expressions);
+                        }
+
+                        return;
                     }
-
+                }
+                ast::Expression::TypeOperator { .. } => {
+                    // just a stray type(int), no code to generate
                     return;
                 }
+                _ => (),
             }
 
             let _ = expression(expr, cfg, contract_no, Some(func), ns, vartab, opt);

src/sema/external_functions.rs

@@ -150,6 +150,8 @@ fn check_statement(stmt: &Statement, call_list: &mut CallList) -> bool {
             cond.recurse(call_list, check_expression);
         }
         Statement::Expression(_, _, expr) => {
+            // if expression is a singular Expression::InternalFunction, then does nothing
+            // and it's never called.
             if !matches!(expr, Expression::InternalFunction { .. }) {
                 expr.recurse(call_list, check_expression);
             }

tests/polkadot_tests/enums.rs

@@ -38,6 +38,12 @@ fn weekdays() {
 
                 x = Weekday(2);
                 assert(x == Weekday.Wednesday);
+
+                assert(type(Weekday).max == 6);
+                assert(type(Weekday).min == 0);
+
+                // stray type() does not do anything.
+                type(Weekday);
             }
         }",
     );