The compiler checks for exhaustive match arms in match expressions.

sway-core/Cargo.toml

@@ -30,6 +30,7 @@ sway-ir = { version = "0.3.3", path = "../sway-ir" }
 sway-types = { version = "0.3.3", path = "../sway-types" }
 generational-arena = "0.2"
 thiserror = "1.0"
+nanoid = "0.4.0"
 
 [[bin]]
 name = "selector-debug"

sway-core/src/asm_generation/from_ir.rs

@@ -1385,6 +1385,7 @@ mod tests {
                 print_intermediate_asm: false,
                 print_finalized_asm: false,
                 print_ir: false,
+                generated_names: std::sync::Arc::new(std::sync::Mutex::new(vec![])),
             },
         );
 

sway-core/src/build_config.rs

@@ -1,4 +1,7 @@
-use std::{path::PathBuf, sync::Arc};
+use std::{
+    path::PathBuf,
+    sync::{Arc, Mutex},
+};
 
 /// Configuration for the overall build and compilation process.
 #[derive(Clone)]
@@ -10,6 +13,7 @@ pub struct BuildConfig {
     pub(crate) print_intermediate_asm: bool,
     pub(crate) print_finalized_asm: bool,
     pub(crate) print_ir: bool,
+    pub(crate) generated_names: Arc<Mutex<Vec<&'static str>>>,
 }
 
 impl BuildConfig {
@@ -29,6 +33,7 @@ impl BuildConfig {
             print_intermediate_asm: false,
             print_finalized_asm: false,
             print_ir: false,
+            generated_names: Arc::new(Mutex::new(vec![])),
         }
     }
 

sway-core/src/error.rs

@@ -4,6 +4,7 @@ use crate::{
     parser::Rule,
     style::{to_screaming_snake_case, to_snake_case, to_upper_camel_case},
     type_engine::*,
+    VariableDeclaration,
 };
 use sway_types::{ident::Ident, span::Span};
 
@@ -69,6 +70,12 @@ pub(crate) fn ok<T>(
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct ParseResult<T> {
+    pub var_decls: Vec<VariableDeclaration>,
+    pub value: T,
+}
+
 #[derive(Debug, Clone)]
 pub struct CompileResult<T> {
     pub value: Option<T>,
@@ -382,6 +389,8 @@ pub enum CompileError {
         span: Span,
         err: pest::error::Error<Rule>,
     },
+    #[error("Error parsing input: {err:?}")]
+    ParseError { span: Span, err: String },
     #[error(
         "Invalid top-level item: {0:?}. A program should consist of a contract, script, or \
          predicate at the top level."
@@ -797,6 +806,8 @@ pub enum CompileError {
          "
     )]
     MatchWrongType { expected: TypeId, span: Span },
+    #[error("Non-exhaustive match expression. Try adding a catchall arm.")]
+    MatchExpressionNonExhaustive { span: Span },
     #[error("Impure function called inside of pure function. Pure functions can only call other pure functions. Try making the surrounding function impure by prepending \"impure\" to the function declaration.")]
     PureCalledImpure { span: Span },
     #[error("Impure function inside of non-contract. Contract storage is only accessible from contracts.")]
@@ -903,6 +914,7 @@ impl CompileError {
             Unimplemented(_, span) => span,
             TypeError(err) => err.internal_span(),
             ParseFailure { span, .. } => span,
+            ParseError { span, .. } => span,
             InvalidTopLevelItem(_, span) => span,
             Internal(_, span) => span,
             InternalOwned(_, span) => span,
@@ -998,6 +1010,7 @@ impl CompileError {
             ArrayOutOfBounds { span, .. } => span,
             ShadowsOtherSymbol { span, .. } => span,
             MatchWrongType { span, .. } => span,
+            MatchExpressionNonExhaustive { span } => span,
             NotAnEnum { span, .. } => span,
             PatternMatchingAlgorithmFailure(_, span) => span,
             PureCalledImpure { span, .. } => span,

sway-core/src/lib.rs

@@ -579,19 +579,22 @@ fn parse_root_from_pairs(
         for pair in input {
             match pair.as_rule() {
                 Rule::non_var_decl => {
-                    let decl = check!(
+                    let span = span::Span {
+                        span: pair.as_span(),
+                        path: path.clone(),
+                    };
+                    let decls = check!(
                         Declaration::parse_non_var_from_pair(pair.clone(), config),
                         continue,
                         warnings,
                         errors
                     );
-                    parse_tree.push(AstNode {
-                        content: AstNodeContent::Declaration(decl),
-                        span: span::Span {
-                            span: pair.as_span(),
-                            path: path.clone(),
-                        },
-                    });
+                    for decl in decls.into_iter() {
+                        parse_tree.push(AstNode {
+                            content: AstNodeContent::Declaration(decl),
+                            span: span.clone(),
+                        });
+                    }
                 }
                 Rule::use_statement => {
                     let stmt = check!(

sway-core/src/optimize.rs

@@ -1583,6 +1583,7 @@ mod tests {
             print_intermediate_asm: false,
             print_finalized_asm: false,
             print_ir: false,
+            generated_names: std::sync::Arc::new(std::sync::Mutex::new(vec![])),
         };
         TypedParseTree::type_check(
             parse_tree.tree,

sway-core/src/parse_tree/code_block.rs

@@ -32,21 +32,27 @@ impl CodeBlock {
         let block_inner = block.into_inner();
         let mut contents = Vec::new();
         for pair in block_inner {
-            contents.push(match pair.as_rule() {
-                Rule::declaration => AstNode {
-                    content: AstNodeContent::Declaration(check!(
+            let mut pair_contents: Vec<AstNode> = match pair.as_rule() {
+                Rule::declaration => {
+                    let span = span::Span {
+                        span: pair.as_span(),
+                        path: path.clone(),
+                    };
+                    check!(
                         Declaration::parse_from_pair(pair.clone(), config),
                         continue,
                         warnings,
                         errors
-                    )),
-                    span: span::Span {
-                        span: pair.as_span(),
-                        path: path.clone(),
-                    },
-                },
+                    )
+                    .into_iter()
+                    .map(|x| AstNode {
+                        content: AstNodeContent::Declaration(x),
+                        span: span.clone(),
+                    })
+                    .collect::<Vec<_>>()
+                }
                 Rule::expr_statement => {
-                    let evaluated_node = check!(
+                    let evaluated_node_result = check!(
                         Expression::parse_from_pair(
                             pair.clone().into_inner().next().unwrap().clone(),
                             config
@@ -55,55 +61,111 @@ impl CodeBlock {
                         warnings,
                         errors
                     );
-                    AstNode {
-                        content: AstNodeContent::Expression(evaluated_node),
+                    let mut ast_node_contents = evaluated_node_result
+                        .var_decls
+                        .into_iter()
+                        .map(|x| AstNode {
+                            content: AstNodeContent::Declaration(Declaration::VariableDeclaration(
+                                x,
+                            )),
+                            span: span::Span {
+                                span: pair.as_span(),
+                                path: path.clone(),
+                            },
+                        })
+                        .collect::<Vec<_>>();
+                    ast_node_contents.push(AstNode {
+                        content: AstNodeContent::Expression(evaluated_node_result.value),
                         span: span::Span {
                             span: pair.as_span(),
                             path: path.clone(),
                         },
-                    }
+                    });
+                    ast_node_contents
                 }
                 Rule::return_statement => {
-                    let evaluated_node = check!(
+                    let res_result = check!(
                         ReturnStatement::parse_from_pair(pair.clone(), config),
                         continue,
                         warnings,
                         errors
                     );
-                    AstNode {
-                        content: AstNodeContent::ReturnStatement(evaluated_node),
+                    let mut ast_node_contents = res_result
+                        .var_decls
+                        .into_iter()
+                        .map(|x| AstNode {
+                            content: AstNodeContent::Declaration(Declaration::VariableDeclaration(
+                                x,
+                            )),
+                            span: span::Span {
+                                span: pair.as_span(),
+                                path: path.clone(),
+                            },
+                        })
+                        .collect::<Vec<_>>();
+                    ast_node_contents.push(AstNode {
+                        content: AstNodeContent::ReturnStatement(res_result.value),
                         span: span::Span {
                             span: pair.as_span(),
                             path: path.clone(),
                         },
-                    }
+                    });
+                    ast_node_contents
                 }
                 Rule::expr => {
-                    let res = check!(
+                    let res_result = check!(
                         Expression::parse_from_pair(pair.clone(), config),
                         continue,
                         warnings,
                         errors
                     );
-                    AstNode {
-                        content: AstNodeContent::ImplicitReturnExpression(res.clone()),
-                        span: res.span(),
-                    }
+                    let mut ast_node_contents = res_result
+                        .var_decls
+                        .into_iter()
+                        .map(|x| AstNode {
+                            content: AstNodeContent::Declaration(Declaration::VariableDeclaration(
+                                x,
+                            )),
+                            span: span::Span {
+                                span: pair.as_span(),
+                                path: path.clone(),
+                            },
+                        })
+                        .collect::<Vec<_>>();
+                    ast_node_contents.push(AstNode {
+                        content: AstNodeContent::ImplicitReturnExpression(res_result.value.clone()),
+                        span: res_result.value.span(),
+                    });
+                    ast_node_contents
                 }
                 Rule::while_loop => {
-                    let res = check!(
+                    let res_result = check!(
                         WhileLoop::parse_from_pair(pair.clone(), config),
                         continue,
                         warnings,
                         errors
                     );
-                    AstNode {
-                        content: AstNodeContent::WhileLoop(res),
+                    let mut ast_node_contents = res_result
+                        .var_decls
+                        .into_iter()
+                        .map(|x| AstNode {
+                            content: AstNodeContent::Declaration(Declaration::VariableDeclaration(
+                                x,
+                            )),
+                            span: span::Span {
+                                span: pair.as_span(),
+                                path: path.clone(),
+                            },
+                        })
+                        .collect::<Vec<_>>();
+                    ast_node_contents.push(AstNode {
+                        content: AstNodeContent::WhileLoop(res_result.value),
                         span: span::Span {
                             span: pair.as_span(),
                             path: path.clone(),
                         },
-                    }
+                    });
+                    ast_node_contents
                 }
                 a => {
                     println!("In code block parsing: {:?} {:?}", a, pair.as_str());
@@ -116,7 +178,8 @@ impl CodeBlock {
                     ));
                     continue;
                 }
-            })
+            };
+            contents.append(&mut pair_contents);
         }
 
         ok(