feat: struct destructuring

sway-core/src/constants.rs

@@ -21,6 +21,9 @@ pub const DEFAULT_ENTRY_POINT_FN_NAME: &str = "main";
 /// The default prefix for the compiler generated names of tuples
 pub const TUPLE_NAME_PREFIX: &str = "__tuple_";
 
+// The default prefix for the compiler generated names of struct fields
+pub const DESTRUCTURE_PREFIX: &str = "__destructure_";
+
 /// The default prefix for the compiler generated names of match
 pub const MATCH_RETURN_VAR_NAME_PREFIX: &str = "__match_return_var_name_";
 

sway-core/src/convert_parse_tree.rs

@@ -2531,25 +2531,112 @@ fn statement_let_to_ast_nodes(
                 let error = ConvertParseTreeError::ConstructorPatternsNotSupportedHere { span };
                 return Err(ec.error(error));
             }
-            Pattern::Struct { .. } => {
-                let error = ConvertParseTreeError::StructPatternsNotSupportedHere { span };
-                return Err(ec.error(error));
+            Pattern::Struct { fields, .. } => {
+                let mut ast_nodes = Vec::new();
+
+                // Generate a deterministic name for the destructured struct
+                // Because the parser is single threaded, the name generated below will be stable.
+                static COUNTER: AtomicUsize = AtomicUsize::new(0);
+                let destructured_name = format!(
+                    "{}{}",
+                    crate::constants::DESTRUCTURE_PREFIX,
+                    COUNTER.load(Ordering::SeqCst)
+                );
+                COUNTER.fetch_add(1, Ordering::SeqCst);
+                let destructure_name = Ident::new_with_override(
+                    Box::leak(destructured_name.into_boxed_str()),
+                    span.clone(),
+                );
+
+                // Parse the type ascription and the type ascription span.
+                // In the event that the user did not provide a type ascription,
+                // it is set to TypeInfo::Unknown and the span to None.
+                let (type_ascription, type_ascription_span) = match &ty_opt {
+                    Some(ty) => {
+                        let type_ascription_span = ty.span();
+                        let type_ascription = ty_to_type_info(ec, ty.clone())?;
+                        (type_ascription, Some(type_ascription_span))
+                    }
+                    None => (TypeInfo::Unknown, None),
+                };
+
+                // Save the destructure to the new name as a new variable declaration
+                let save_body_first = VariableDeclaration {
+                    name: destructure_name.clone(),
+                    type_ascription,
+                    type_ascription_span,
+                    body: expression,
+                    is_mutable: false,
+                };
+                ast_nodes.push(AstNode {
+                    content: AstNodeContent::Declaration(Declaration::VariableDeclaration(
+                        save_body_first,
+                    )),
+                    span: span.clone(),
+                });
+
+                // create a new variable expression that points to the new destructured struct name that we just created
+                let new_expr = Expression::VariableExpression {
+                    name: destructure_name,
+                    span: span.clone(),
+                };
+
+                // for all of the fields of the struct destructuring on the LHS,
+                // recursively create variable declarations
+                for pattern_struct_field in fields.into_inner().into_iter() {
+                    let (field, recursive_pattern) = match pattern_struct_field {
+                        PatternStructField::Field {
+                            field_name,
+                            pattern_opt,
+                        } => {
+                            let recursive_pattern = match pattern_opt {
+                                Some((_colon_token, box_pattern)) => *box_pattern,
+                                None => Pattern::Var {
+                                    mutable: None,
+                                    name: field_name.clone(),
+                                },
+                            };
+                            (field_name, recursive_pattern)
+                        }
+                        PatternStructField::Rest { .. } => {
+                            continue;
+                        }
+                    };
+
+                    // recursively create variable declarations for the subpatterns on the LHS
+                    // and add them to the ast nodes
+                    ast_nodes.extend(unfold(
+                        ec,
+                        recursive_pattern,
+                        None,
+                        Expression::SubfieldExpression {
+                            prefix: Box::new(new_expr.clone()),
+                            span: span.clone(),
+                            field_to_access: field,
+                        },
+                        span.clone(),
+                    )?);
+                }
+                ast_nodes
             }
             Pattern::Tuple(pat_tuple) => {
                 let mut ast_nodes = Vec::new();
 
-                // Generate a deterministic name for the tuple. Because the parser is single
-                // threaded, the name generated below will be stable.
+                // Generate a deterministic name for the tuple.
+                // Because the parser is single threaded, the name generated below will be stable.
                 static COUNTER: AtomicUsize = AtomicUsize::new(0);
                 let tuple_name = format!(
                     "{}{}",
                     crate::constants::TUPLE_NAME_PREFIX,
                     COUNTER.load(Ordering::SeqCst)
                 );
                 COUNTER.fetch_add(1, Ordering::SeqCst);
-                let name =
+                let tuple_name =
                     Ident::new_with_override(Box::leak(tuple_name.into_boxed_str()), span.clone());
 
+                // Parse the type ascription and the type ascription span.
+                // In the event that the user did not provide a type ascription,
+                // it is set to TypeInfo::Unknown and the span to None.
                 let (type_ascription, type_ascription_span) = match &ty_opt {
                     Some(ty) => {
                         let type_ascription_span = ty.span();
@@ -2558,8 +2645,10 @@ fn statement_let_to_ast_nodes(
                     }
                     None => (TypeInfo::Unknown, None),
                 };
+
+                // Save the tuple to the new name as a new variable declaration.
                 let save_body_first = VariableDeclaration {
-                    name: name.clone(),
+                    name: tuple_name.clone(),
                     type_ascription,
                     type_ascription_span,
                     body: expression,
@@ -2571,19 +2660,31 @@ fn statement_let_to_ast_nodes(
                     )),
                     span: span.clone(),
                 });
+
+                // create a variable expression that points to the new tuple name that we just created
                 let new_expr = Expression::VariableExpression {
-                    name,
+                    name: tuple_name,
                     span: span.clone(),
                 };
+
+                // from the possible type annotation, if the annotation was a tuple annotation,
+                // extract the internal types of the annotation
                 let tuple_tys_opt = match ty_opt {
                     Some(Ty::Tuple(tys)) => Some(tys.into_inner().to_tys()),
                     _ => None,
                 };
+
+                // for all of the elements in the tuple destructuring on the LHS,
+                // recursively create variable declarations
                 for (index, pattern) in pat_tuple.into_inner().into_iter().enumerate() {
+                    // from the possible type annotation, grab the type at the index of the current element
+                    // we are processing
                     let ty_opt = match &tuple_tys_opt {
                         Some(tys) => tys.get(index).cloned(),
                         None => None,
                     };
+                    // recursively create variable declarations for the subpatterns on the LHS
+                    // and add them to the ast nodes
                     ast_nodes.extend(unfold(
                         ec,
                         pattern,

sway-parse/src/item/mod.rs

@@ -296,7 +296,6 @@ mod tests {
         match Item::parse(&mut parser) {
             Ok(item) => item,
             Err(_) => {
-                //println!("Tokens: {:?}", token_stream);
                 panic!("Parse error: {:?}", errors);
             }
         }

test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/Forc.lock

@@ -0,0 +1,9 @@
+[[package]]
+name = 'core'
+source = 'path+from-root-F93ECA3248F311E3'
+dependencies = []
+
+[[package]]
+name = 'struct_destructuring'
+source = 'root'
+dependencies = ['core']

test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "struct_destructuring"
+
+[dependencies]
+core = { path = "../../../../../../../sway-lib-core" }

test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/json_abi_oracle.json

@@ -0,0 +1,15 @@
+[
+  {
+    "inputs": [],
+    "name": "main",
+    "outputs": [
+      {
+        "components": null,
+        "name": "",
+        "type": "u64",
+        "typeArguments": null
+      }
+    ],
+    "type": "function"
+  }
+]

test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/src/main.sw

@@ -0,0 +1,21 @@
+script;
+
+// Tests nested struct destructuring
+
+fn main() -> u64 {
+    let point1 = Point { x: 0, y: 0 };
+    let point2 = Point { x: 1, y: 1 };
+    let line = Line { p1: point1, p2: point2 };
+    let Line { p1: Point { x: x0, y: y0 }, p2: Point { x: x1, y: y1} } = line;
+    x0
+}
+
+struct Point {
+    x: u64,
+    y: u64,
+}
+
+struct Line {
+    p1: Point,
+    p2: Point,
+}

test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/test.toml

@@ -0,0 +1,3 @@
+category = "run"
+expected_result = { action = "return", value = 0 }
+validate_abi = true

test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/Forc.lock

@@ -0,0 +1,9 @@
+[[package]]
+name = 'core'
+source = 'path+from-root-F93ECA3248F311E3'
+dependencies = []
+
+[[package]]
+name = 'struct_destructuring'
+source = 'root'
+dependencies = ['core']

test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "struct_destructuring"
+
+[dependencies]
+core = { path = "../../../../../../../sway-lib-core" }

test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/json_abi_oracle.json

@@ -0,0 +1,15 @@
+[
+  {
+    "inputs": [],
+    "name": "main",
+    "outputs": [
+      {
+        "components": null,
+        "name": "",
+        "type": "u64",
+        "typeArguments": null
+      }
+    ],
+    "type": "function"
+  }
+]

test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/src/main.sw

@@ -0,0 +1,26 @@
+script;
+
+// Tests struct destructuring
+
+fn gimme_a_struct() -> Dummy {
+    Dummy { value1: 1, value2: true }
+}
+
+fn main() -> u64 {
+    let Dummy { value1, value2 } = gimme_a_struct();
+    let Dummy { value1, value2 }: Dummy = gimme_a_struct();
+    let data = Data {
+        value: 42,
+    };
+    let Data { value }: Data = data;
+    return value;
+}
+
+struct Data { 
+    value: u64,
+}
+
+struct Dummy {
+    value1: u64,
+    value2: bool,
+}

test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/test.toml

@@ -0,0 +1,3 @@
+category = "run"
+expected_result = { action = "return", value = 42 }
+validate_abi = true