Feedback.

FuelLabs · Mar 8, 2022 · 2651a63 · 2651a63
1 parent 1a0056c
commit 2651a63
Show file tree

Hide file tree

Showing 15 changed files with 265 additions and 424 deletions.
diff --git a/sway-core/src/asm_generation/from_ir.rs b/sway-core/src/asm_generation/from_ir.rs
@@ -1874,7 +1874,7 @@ mod tests {
                 Some("asm") | Some("disabled") => (),
                 _ => panic!(
                     "File with invalid extension in tests dir: {:?}",
-                    path.file_name().unwrap_or(path.as_os_str())
+                    path.file_name().unwrap_or_else(|| path.as_os_str())
                 ),
             }
         }

diff --git a/sway-core/src/error.rs b/sway-core/src/error.rs
@@ -70,12 +70,25 @@ pub(crate) fn ok<T>(
     }
 }
 
+/// Acts as the result of parsing `Declaration`s, `Expression`s, etc.
+/// Some `Expression`s need to be able to create `VariableDeclaration`s,
+/// so this struct is used to "bubble up" those declarations to a viable
+/// place in the AST.
 #[derive(Debug, Clone)]
-pub struct ParseResult<T> {
+pub struct ParserLifter<T> {
     pub var_decls: Vec<VariableDeclaration>,
     pub value: T,
 }
 
+impl<T> ParserLifter<T> {
+    pub(crate) fn empty(value: T) -> Self {
+        ParserLifter {
+            var_decls: vec![],
+            value,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct CompileResult<T> {
     pub value: Option<T>,

diff --git a/sway-core/src/optimize.rs b/sway-core/src/optimize.rs
@@ -1735,7 +1735,7 @@ mod tests {
                 Some("ir") | Some("disabled") => (),
                 _ => panic!(
                     "File with invalid extension in tests dir: {:?}",
-                    path.file_name().unwrap_or(path.as_os_str())
+                    path.file_name().unwrap_or_else(|| path.as_os_str())
                 ),
             }
         }
@@ -1788,7 +1788,7 @@ mod tests {
                 Some("sw") | Some("disabled") => (),
                 _ => panic!(
                     "File with invalid extension in tests dir: {:?}",
-                    path.file_name().unwrap_or(path.as_os_str())
+                    path.file_name().unwrap_or_else(|| path.as_os_str())
                 ),
             }
         }

diff --git a/sway-core/src/parse_tree/code_block.rs b/sway-core/src/parse_tree/code_block.rs
@@ -4,17 +4,17 @@ use crate::{
     error::*,
     parse_tree::{Expression, ReturnStatement},
     parser::Rule,
-    AstNode, AstNodeContent, Declaration,
+    AstNode, AstNodeContent, Declaration, VariableDeclaration,
 };
 
-use sway_types::span;
+use sway_types::span::Span;
 
 use pest::iterators::Pair;
 
 #[derive(Debug, Clone)]
 pub struct CodeBlock {
     pub contents: Vec<AstNode>,
-    pub(crate) whole_block_span: span::Span,
+    pub(crate) whole_block_span: Span,
 }
 
 impl CodeBlock {
@@ -25,13 +25,17 @@ impl CodeBlock {
         let path = config.map(|c| c.path());
         let mut warnings = Vec::new();
         let mut errors = Vec::new();
-        let whole_block_span = span::Span {
+        let whole_block_span = Span {
             span: block.as_span(),
             path: path.clone(),
         };
         let block_inner = block.into_inner();
         let mut contents = Vec::new();
         for pair in block_inner {
+            let span = Span {
+                span: pair.as_span(),
+                path: path.clone(),
+            };
             let mut ast_nodes = match pair.as_rule() {
                 Rule::declaration => check!(
                     Declaration::parse_from_pair(pair.clone(), config),
@@ -42,14 +46,14 @@ impl CodeBlock {
                 .into_iter()
                 .map(|content| AstNode {
                     content: AstNodeContent::Declaration(content),
-                    span: span::Span {
+                    span: Span {
                         span: pair.as_span(),
                         path: path.clone(),
                     },
                 })
                 .collect::<Vec<_>>(),
                 Rule::expr_statement => {
-                    let evaluated_node_result = check!(
+                    let ParserLifter { value, var_decls } = check!(
                         Expression::parse_from_pair(
                             pair.clone().into_inner().next().unwrap().clone(),
                             config
@@ -58,117 +62,61 @@ impl CodeBlock {
                         warnings,
                         errors
                     );
-                    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<_>>();
+                    let mut ast_node_contents = collect_var_decls(var_decls, span.clone());
                     ast_node_contents.push(AstNode {
-                        content: AstNodeContent::Expression(evaluated_node_result.value),
-                        span: span::Span {
-                            span: pair.as_span(),
-                            path: path.clone(),
-                        },
+                        content: AstNodeContent::Expression(value),
+                        span,
                     });
                     ast_node_contents
                 }
                 Rule::return_statement => {
-                    let res_result = check!(
+                    let ParserLifter { value, var_decls } = check!(
                         ReturnStatement::parse_from_pair(pair.clone(), config),
                         continue,
                         warnings,
                         errors
                     );
-                    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<_>>();
+                    let mut ast_node_contents = collect_var_decls(var_decls, span.clone());
                     ast_node_contents.push(AstNode {
-                        content: AstNodeContent::ReturnStatement(res_result.value),
-                        span: span::Span {
-                            span: pair.as_span(),
-                            path: path.clone(),
-                        },
+                        content: AstNodeContent::ReturnStatement(value),
+                        span,
                     });
                     ast_node_contents
                 }
                 Rule::expr => {
-                    let res_result = check!(
+                    let ParserLifter { value, var_decls } = check!(
                         Expression::parse_from_pair(pair.clone(), config),
                         continue,
                         warnings,
                         errors
                     );
-                    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<_>>();
+                    let mut ast_node_contents = collect_var_decls(var_decls, span.clone());
+                    let expr_span = value.span();
                     ast_node_contents.push(AstNode {
-                        content: AstNodeContent::ImplicitReturnExpression(res_result.value.clone()),
-                        span: res_result.value.span(),
+                        content: AstNodeContent::ImplicitReturnExpression(value),
+                        span: expr_span,
                     });
                     ast_node_contents
                 }
                 Rule::while_loop => {
-                    let res_result = check!(
+                    let ParserLifter { value, var_decls } = check!(
                         WhileLoop::parse_from_pair(pair.clone(), config),
                         continue,
                         warnings,
                         errors
                     );
-                    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<_>>();
+                    let mut ast_node_contents = collect_var_decls(var_decls, span.clone());
                     ast_node_contents.push(AstNode {
-                        content: AstNodeContent::WhileLoop(res_result.value),
-                        span: span::Span {
-                            span: pair.as_span(),
-                            path: path.clone(),
-                        },
+                        content: AstNodeContent::WhileLoop(value),
+                        span,
                     });
                     ast_node_contents
                 }
                 a => {
                     println!("In code block parsing: {:?} {:?}", a, pair.as_str());
                     errors.push(CompileError::UnimplementedRule(
                         a,
-                        span::Span {
+                        Span {
                             span: pair.as_span(),
                             path: path.clone(),
                         },
@@ -189,3 +137,13 @@ impl CodeBlock {
         )
     }
 }
+
+fn collect_var_decls(var_decls: Vec<VariableDeclaration>, span: Span) -> Vec<AstNode> {
+    var_decls
+        .into_iter()
+        .map(|x| AstNode {
+            content: AstNodeContent::Declaration(Declaration::VariableDeclaration(x)),
+            span: span.clone(),
+        })
+        .collect::<Vec<_>>()
+}
diff --git a/sway-core/src/parse_tree/declaration/constant.rs b/sway-core/src/parse_tree/declaration/constant.rs
@@ -1,6 +1,6 @@
 use crate::{
     build_config::BuildConfig,
-    error::{err, ok, CompileResult, ParseResult, Warning},
+    error::{err, ok, CompileResult, ParserLifter, Warning},
     parse_tree::{ident, Expression, Visibility},
     parser::Rule,
     style::is_screaming_snake_case,
@@ -23,7 +23,7 @@ impl ConstantDeclaration {
     pub(crate) fn parse_from_pair(
         pair: Pair<Rule>,
         config: Option<&BuildConfig>,
-    ) -> CompileResult<ParseResult<ConstantDeclaration>> {
+    ) -> CompileResult<ParserLifter<ConstantDeclaration>> {
         let path = config.map(|c| c.path());
         let mut warnings = Vec::new();
         let mut errors = Vec::new();
@@ -85,7 +85,7 @@ impl ConstantDeclaration {
             visibility,
         };
         ok(
-            ParseResult {
+            ParserLifter {
                 var_decls: vec![],
                 value: decl,
             },