Expand match expressions to encompass enums (#1642)

* Refactor namespace and enums.

* clippy

* clippy

* Improvements to namespace API and declaration ABI.

* Introduce the  trait and the  type.

* More instances.

* Introduce the CreateTypeId trait.

* Introduce the MonomorphizeHelper trait.

* Improvements to monomorphization.

* Fix bug with node dependencies.

* Combine Unit Scruntinee and Tuple Scrutinee.

* Improve the MatcherResult type.

* Add recursive catchall pattern.

* Move match expression desugaring from parsing to type checking.

* Use some of the new methods.

* clippy

* Rename function.

* Add purity check back in.

* update

* Support nested enums.

* Allow empty match arms.

* Fix case with malformed enum name.

* Confirm there are not duplicated errors.

* Fix bad test.

* Fix bad tests.

* Remove unusable tests.

* docstrings

* reviewer comments

Author: emilyaherbert

sway-core/src/asm_generation/expression/mod.rs

@@ -3,9 +3,7 @@ use crate::{
     asm_lang::*,
     parse_tree::{BuiltinProperty, CallPath, Literal},
     semantic_analysis::{
-        ast_node::{
-            TypedAsmRegisterDeclaration, TypedCodeBlock, TypedEnumVariant, TypedExpressionVariant,
-        },
+        ast_node::{TypedAsmRegisterDeclaration, TypedCodeBlock, TypedExpressionVariant},
         TypedExpression,
     },
     type_engine::*,
@@ -321,24 +319,6 @@ pub(crate) fn convert_expression_to_asm(
         }
         // ABI casts are purely compile-time constructs and generate no corresponding bytecode
         TypedExpressionVariant::AbiCast { .. } => ok(vec![], warnings, errors),
-        TypedExpressionVariant::IfLet {
-            enum_type,
-            variant,
-            then,
-            r#else,
-            variable_to_assign,
-            expr,
-        } => convert_if_let_to_asm(
-            expr,
-            *enum_type,
-            variant,
-            then,
-            r#else,
-            variable_to_assign,
-            return_register,
-            namespace,
-            register_sequencer,
-        ),
         TypedExpressionVariant::TypeProperty {
             property, type_id, ..
         } => match property {
@@ -628,130 +608,3 @@ pub(crate) fn convert_abi_fn_to_asm(
     // is done
     ok(asm_buf, warnings, errors)
 }
-
-#[allow(clippy::too_many_arguments)]
-fn convert_if_let_to_asm(
-    expr: &TypedExpression,
-    _enum_type: TypeId,
-    variant: &TypedEnumVariant,
-    then: &TypedCodeBlock,
-    r#else: &Option<Box<TypedExpression>>,
-    variable_to_assign: &Ident,
-    return_register: &VirtualRegister,
-    namespace: &mut AsmNamespace,
-    register_sequencer: &mut RegisterSequencer,
-) -> CompileResult<Vec<Op>> {
-    // 1. evaluate the expression
-    // 2. load the expected tag into a register ($rA)
-    // 3. compare the tag to the first word of the expression's returned value
-    // 4. grab a register for `variable_to_assign`, insert it into the asm namespace
-    // 5. if the tags are equal, load the returned value from byte 1..end into `variable_to_assign`
-    // 5.5 if they are not equal, jump to the label in 7
-    // 6. evaluate the then branch with that variable in scope
-    // 7. insert a jump label for the else branch
-    // 8. evaluate the else branch, if any
-    let mut warnings = vec![];
-    let mut errors = vec![];
-    let mut buf = vec![];
-    // 1.
-    let expr_return_register = register_sequencer.next();
-    let mut expr_buf = check!(
-        convert_expression_to_asm(&*expr, namespace, &expr_return_register, register_sequencer),
-        vec![],
-        warnings,
-        errors
-    );
-    buf.append(&mut expr_buf);
-    // load the tag from the evaluated value
-    // as this is an enum we know the value in the register is a pointer
-    // we can therefore read a word from the register and move it into another register
-    let received_tag_register = register_sequencer.next();
-    buf.push(Op {
-        opcode: Either::Left(VirtualOp::LW(
-            received_tag_register.clone(),
-            expr_return_register.clone(),
-            VirtualImmediate12::new_unchecked(0, "infallible"),
-        )),
-        comment: "load received enum tag".into(),
-        owning_span: Some(expr.span.clone()),
-    });
-    // 2.
-    let expected_tag_register = register_sequencer.next();
-    let expected_tag_label = namespace.insert_data_value(&Literal::U64(variant.tag as u64));
-    buf.push(Op {
-        opcode: either::Either::Left(VirtualOp::LWDataId(
-            expected_tag_register.clone(),
-            expected_tag_label,
-        )),
-        comment: "load enum tag for if let".into(),
-        owning_span: Some(expr.span.clone()),
-    });
-    let label_for_else_branch = register_sequencer.get_label();
-    // 3 - 5
-    buf.push(Op {
-        opcode: Either::Right(OrganizationalOp::JumpIfNotEq(
-            expected_tag_register,
-            received_tag_register,
-            label_for_else_branch.clone(),
-        )),
-        comment: "jump to if let's else branch".into(),
-        owning_span: Some(expr.span.clone()),
-    });
-    // 6.
-    // put the destructured variable into the namespace for the then branch, but not otherwise
-    let mut then_branch_asm_namespace = namespace.clone();
-    let variable_to_assign_register = register_sequencer.next();
-    then_branch_asm_namespace.insert_variable(
-        variable_to_assign.clone(),
-        variable_to_assign_register.clone(),
-    );
-    // load the word that is at the expr return register + 1 word
-    // + 1 word is to account for the enum tag
-    buf.push(Op {
-        opcode: Either::Left(VirtualOp::LW(
-            variable_to_assign_register,
-            expr_return_register,
-            VirtualImmediate12::new_unchecked(1, "infallible"),
-        )),
-        owning_span: Some(then.span().clone()),
-        comment: "Load destructured value into register".into(),
-    });
-
-    // 6
-    buf.append(&mut check!(
-        convert_code_block_to_asm(
-            then,
-            &mut then_branch_asm_namespace,
-            register_sequencer,
-            Some(return_register)
-        ),
-        return err(warnings, errors),
-        warnings,
-        errors
-    ));
-
-    // add the data section from the then branch back to the main one
-
-    namespace.overwrite_data_section(then_branch_asm_namespace);
-
-    let label_for_after_else_branch = register_sequencer.get_label();
-    if let Some(r#else) = r#else {
-        buf.push(Op::jump_to_label_comment(
-            label_for_after_else_branch.clone(),
-            "jump to after the else branch",
-        ));
-
-        buf.push(Op::unowned_jump_label(label_for_else_branch));
-
-        buf.append(&mut check!(
-            convert_expression_to_asm(r#else, namespace, return_register, register_sequencer),
-            return err(warnings, errors),
-            warnings,
-            errors
-        ));
-
-        buf.push(Op::unowned_jump_label(label_for_after_else_branch));
-    }
-
-    ok(buf, warnings, errors)
-}

sway-core/src/asm_generation/mod.rs

@@ -612,11 +612,6 @@ impl AsmNamespace {
             ),
         }
     }
-
-    /// In the
-    pub(crate) fn overwrite_data_section(&mut self, other: Self) {
-        self.data_section.value_pairs = other.data_section.value_pairs;
-    }
 }
 
 pub(crate) fn compile_ast_to_asm(

sway-core/src/control_flow_analysis/dead_code_analysis.rs

@@ -963,35 +963,6 @@ fn connect_expression(
             )?;
             Ok([prefix_idx, index_idx].concat())
         }
-        IfLet {
-            expr, then, r#else, ..
-        } => {
-            let leaves = connect_expression(
-                &expr.expression,
-                graph,
-                leaves,
-                exit_node,
-                "if let expr",
-                tree_type,
-                expr.span.clone(),
-            )?;
-            let then_expr = connect_code_block(then, graph, &leaves, exit_node, tree_type)?;
-
-            let else_expr = if let Some(else_expr) = r#else {
-                connect_expression(
-                    &else_expr.expression,
-                    graph,
-                    &leaves,
-                    exit_node,
-                    "if let: else branch",
-                    tree_type,
-                    (**else_expr).span.clone(),
-                )?
-            } else {
-                vec![]
-            };
-            Ok([then_expr, else_expr].concat())
-        }
         TupleElemAccess { prefix, .. } => {
             let prefix_idx = connect_expression(
                 &prefix.expression,
@@ -1050,6 +1021,24 @@ fn connect_expression(
             Ok(leaves.to_vec())
         }
         FunctionParameter => Ok(leaves.to_vec()),
+        EnumTag { exp } => connect_expression(
+            &exp.expression,
+            graph,
+            leaves,
+            exit_node,
+            "enum tag exp",
+            tree_type,
+            exp.span.clone(),
+        ),
+        UnsafeDowncast { exp, .. } => connect_expression(
+            &exp.expression,
+            graph,
+            leaves,
+            exit_node,
+            "unsafe downcast exp",
+            tree_type,
+            exp.span.clone(),
+        ),
     }
 }
 

sway-core/src/convert_parse_tree.rs

@@ -1964,8 +1964,11 @@ fn if_expr_to_expression(
         ..
     } = if_expr;
     let then_block_span = then_block.span();
-    let then_block = braced_code_block_contents_to_code_block(ec, then_block)?;
-    let else_opt = match else_opt {
+    let then_block = Expression::CodeBlock {
+        contents: braced_code_block_contents_to_code_block(ec, then_block)?,
+        span: then_block_span.clone(),
+    };
+    let else_block = match else_opt {
         None => None,
         Some((_else_token, tail)) => {
             let expression = match tail {
@@ -1974,26 +1977,52 @@ fn if_expr_to_expression(
                 }
                 ControlFlow::Continue(if_expr) => if_expr_to_expression(ec, *if_expr)?,
             };
-            Some(Box::new(expression))
+            Some(expression)
         }
     };
     let expression = match condition {
         IfCondition::Expr(condition) => Expression::IfExp {
             condition: Box::new(expr_to_expression(ec, *condition)?),
-            then: Box::new(Expression::CodeBlock {
-                contents: then_block,
-                span: then_block_span,
-            }),
-            r#else: else_opt,
-            span,
-        },
-        IfCondition::Let { lhs, rhs, .. } => Expression::IfLet {
-            scrutinee: pattern_to_scrutinee(ec, *lhs)?,
-            expr: Box::new(expr_to_expression(ec, *rhs)?),
-            then: then_block,
-            r#else: else_opt,
+            then: Box::new(then_block),
+            r#else: else_block.map(Box::new),
             span,
         },
+        IfCondition::Let { lhs, rhs, .. } => {
+            let scrutinee = pattern_to_scrutinee(ec, *lhs)?;
+            let scrutinee_span = scrutinee.span();
+            let mut branches = vec![MatchBranch {
+                scrutinee,
+                result: then_block.clone(),
+                span: Span::join(scrutinee_span, then_block_span),
+            }];
+            branches.push(match else_block {
+                Some(else_block) => {
+                    let else_block_span = else_block.span();
+                    MatchBranch {
+                        scrutinee: Scrutinee::CatchAll {
+                            span: else_block_span.clone(),
+                        },
+                        result: else_block,
+                        span: else_block_span,
+                    }
+                }
+                None => {
+                    let else_block_span = then_block.span();
+                    MatchBranch {
+                        scrutinee: Scrutinee::CatchAll {
+                            span: else_block_span.clone(),
+                        },
+                        result: then_block,
+                        span: else_block_span,
+                    }
+                }
+            });
+            Expression::MatchExp {
+                value: Box::new(expr_to_expression(ec, *rhs)?),
+                branches,
+                span,
+            }
+        }
     };
     Ok(expression)
 }
@@ -2515,35 +2544,28 @@ fn pattern_to_scrutinee(
             value: literal_to_literal(ec, literal)?,
             span,
         },
-        Pattern::Constant(path_expr) => Scrutinee::EnumScrutinee {
-            call_path: path_expr_to_call_path(ec, path_expr)?,
-            variable_to_assign: Ident::new_no_span("_"),
-            span,
-        },
+        Pattern::Constant(path_expr) => {
+            let call_path = path_expr_to_call_path(ec, path_expr)?;
+            let call_path_span = call_path.span();
+            Scrutinee::EnumScrutinee {
+                call_path,
+                value: Box::new(Scrutinee::CatchAll {
+                    span: call_path_span,
+                }),
+                span,
+            }
+        }
         Pattern::Constructor { path, args } => {
-            let arg = match iter_to_array(args.into_inner()) {
+            let value = match iter_to_array(args.into_inner()) {
                 Some([arg]) => arg,
                 None => {
                     let error = ConvertParseTreeError::ConstructorPatternOneArg { span };
                     return Err(ec.error(error));
                 }
             };
-            let variable_to_assign = match arg {
-                Pattern::Var { mutable, name } => {
-                    if mutable.is_some() {
-                        let error = ConvertParseTreeError::MutableBindingsNotSupportedHere { span };
-                        return Err(ec.error(error));
-                    }
-                    name
-                }
-                _ => {
-                    let error = ConvertParseTreeError::ConstructorPatternSubPatterns { span };
-                    return Err(ec.error(error));
-                }
-            };
             Scrutinee::EnumScrutinee {
                 call_path: path_expr_to_call_path(ec, path)?,
-                variable_to_assign,
+                value: Box::new(pattern_to_scrutinee(ec, value)?),
                 span,
             }
         }