fix(compiler): process arg declarations within cell scopes (#143)

Author: rahulk29

.gitignore

@@ -57,6 +57,7 @@ Temporary Items
 # will have compiled files and executables
 debug/
 target/
+target
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html

core/compiler/src/compile.rs

@@ -1116,12 +1116,38 @@ impl<'a> AstTransformer for VarIdTyPass<'a> {
                 kind: StaticErrorKind::RedeclarationOfBuiltin,
             });
         }
+        self.enter_scope(&input.scope);
+        // TODO: this code is mostly duplicated from `transform_scope`.
         let args: Vec<_> = input
             .args
             .iter()
             .map(|arg| self.transform_arg_decl(arg))
             .collect();
-        let scope = self.transform_scope(&input.scope);
+        let scope_annotation = input
+            .scope
+            .scope_annotation
+            .as_ref()
+            .map(|ident| self.transform_ident(ident));
+        let stmts = input
+            .scope
+            .stmts
+            .iter()
+            .map(|stmt| self.transform_statement(stmt))
+            .collect_vec();
+        let tail = input
+            .scope
+            .tail
+            .as_ref()
+            .map(|stmt| self.transform_expr(stmt));
+        let metadata = self.dispatch_scope(&input.scope, &stmts, &tail);
+        let scope = Scope {
+            scope_annotation,
+            span: input.span,
+            stmts,
+            tail,
+            metadata,
+        };
+        self.exit_scope(&input.scope, &scope);
         if let Some(tail) = scope.tail.as_ref() {
             self.errors.push(StaticError {
                 span: self.span(tail.span()),

core/compiler/src/lib.rs

@@ -12,7 +12,7 @@ mod tests {
     use std::path::PathBuf;
 
     use crate::{
-        compile::{ExecErrorKind, SolvedValue},
+        compile::{ExecErrorKind, SolvedValue, StaticErrorKind},
         gds::GdsMap,
         parse::parse_workspace_with_std,
     };
@@ -59,6 +59,8 @@ mod tests {
     const ARGON_ANY_TYPE: &str = concatcp!(EXAMPLES_DIR, "/any_type/lib.ar");
     const ARGON_SEQ_INDEX: &str = concatcp!(EXAMPLES_DIR, "/seq_index/lib.ar");
     const ARGON_SEQ_CONSTRUCTOR: &str = concatcp!(EXAMPLES_DIR, "/seq_constructor/lib.ar");
+    const ARGON_FUNC_BAD_ARG_REUSE: &str = concatcp!(EXAMPLES_DIR, "/func_bad_arg_reuse/lib.ar");
+    const ARGON_CELL_BAD_ARG_REUSE: &str = concatcp!(EXAMPLES_DIR, "/cell_bad_arg_reuse/lib.ar");
 
     #[test]
     fn argon_scopes() {
@@ -781,4 +783,52 @@ mod tests {
         assert_relative_eq!(r.x1.0, 300., epsilon = EPSILON);
         assert_relative_eq!(r.y1.0, 500., epsilon = EPSILON);
     }
+
+    #[test]
+    fn argon_func_bad_arg_reuse() {
+        let o = parse_workspace_with_std(ARGON_FUNC_BAD_ARG_REUSE);
+        assert!(o.static_errors().is_empty());
+        let ast = o.ast();
+        let cells = compile(
+            &ast,
+            CompileInput {
+                cell: &["top"],
+                args: Vec::new(),
+                lyp_file: &PathBuf::from(BASIC_LYP),
+            },
+        );
+        println!("{cells:#?}");
+
+        let errors = cells.unwrap_static_errors();
+        assert!(
+            errors
+                .errors
+                .iter()
+                .any(|e| matches!(e.kind, StaticErrorKind::UndeclaredVar))
+        );
+    }
+
+    #[test]
+    fn argon_cell_bad_arg_reuse() {
+        let o = parse_workspace_with_std(ARGON_CELL_BAD_ARG_REUSE);
+        assert!(o.static_errors().is_empty());
+        let ast = o.ast();
+        let cells = compile(
+            &ast,
+            CompileInput {
+                cell: &["top"],
+                args: Vec::new(),
+                lyp_file: &PathBuf::from(BASIC_LYP),
+            },
+        );
+        println!("{cells:#?}");
+
+        let errors = cells.unwrap_static_errors();
+        assert!(
+            errors
+                .errors
+                .iter()
+                .any(|e| matches!(e.kind, StaticErrorKind::UndeclaredVar))
+        );
+    }
 }

examples/cell_bad_arg_reuse/lib.ar

@@ -0,0 +1,8 @@
+cell square(size: Float) {
+    let shape = rect("met1", x0=0., y0=0., x1=size, y1=size);
+}
+
+cell top() {
+    let sq = inst(square(100.));
+    let shape = rect("met2", x0=0., y0=0., x1=200., y1=size);
+}

examples/func_bad_arg_reuse/lib.ar

@@ -0,0 +1,16 @@
+fn double(argument: Float) -> Float {
+    if argument > 0.0 {
+        let argument = argument;
+    } else {
+        let argument = -argument;
+    };
+    2. * argument
+}
+
+cell top() {
+    let shape = rect("met1");
+    eq(shape.x0, 0.);
+    eq(shape.y0, 0.);
+    eq(shape.x1, double(100.));
+    eq(shape.y1, argument);
+}