v0.4.1: Destructuring Params, Circular Import Diagnostics, Otherwise Lint

src/ast.rs

@@ -377,6 +377,8 @@ pub struct Parameter {
     pub name: String,
     pub type_annotation: Option<TypeExpr>,
     pub default: Option<Expression>,
+    #[serde(default)]
+    pub pattern: Option<Pattern>,
 }
 
 /// Import item for selective imports: `import { foo as bar } from "module"`

src/interpreter.rs

@@ -6339,7 +6339,12 @@ impl Interpreter {
                 // Should not reach here due to arity check above
                 Value::Unit
             };
-            func_env.borrow_mut().define(param.name.clone(), value);
+            func_env
+                .borrow_mut()
+                .define(param.name.clone(), value.clone());
+            if let Some(ref pat) = param.pattern {
+                self.bind_pattern(pat, &value)?;
+            }
         }
 
         // Environment is already set to func_env for contract checking and body execution
@@ -12017,4 +12022,69 @@ page
             other => panic!("expected String('ab'), got {:?}", other),
         }
     }
+
+    #[test]
+    fn test_destructured_map_param() {
+        let result = eval(
+            r#"
+            fn greet({ name, email }) {
+                return name + " <" + email + ">"
+            }
+            greet(map { "name": "Alice", "email": "a@b.com" })
+        "#,
+        )
+        .unwrap();
+        match result {
+            Value::String(s) => assert_eq!(s, "Alice <a@b.com>"),
+            other => panic!("expected String, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_destructured_map_param_with_type() {
+        let result = eval(
+            r#"
+            fn greet({ name, email }: Map) -> String {
+                return name + " <" + email + ">"
+            }
+            greet(map { "name": "Bob", "email": "b@b.com" })
+        "#,
+        )
+        .unwrap();
+        match result {
+            Value::String(s) => assert_eq!(s, "Bob <b@b.com>"),
+            other => panic!("expected String, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_destructured_array_param() {
+        let result = eval(
+            r#"
+            fn first_two([a, b, ...rest]) {
+                return a + b
+            }
+            first_two([10, 20, 30])
+        "#,
+        )
+        .unwrap();
+        assert!(matches!(result, Value::Int(30)));
+    }
+
+    #[test]
+    fn test_destructured_param_with_regular_params() {
+        let result = eval(
+            r#"
+            fn process(id, { name }) {
+                return str(id) + ": " + name
+            }
+            process(42, map { "name": "Alice" })
+        "#,
+        )
+        .unwrap();
+        match result {
+            Value::String(s) => assert_eq!(s, "42: Alice"),
+            other => panic!("expected String, got {:?}", other),
+        }
+    }
 }

src/parser.rs

@@ -307,7 +307,15 @@ impl Parser {
 
         if !self.check(&TokenKind::RightParen) {
             loop {
-                let name = self.consume_identifier("Expected parameter name")?;
+                let (name, pattern) =
+                    if self.check(&TokenKind::LeftBrace) || self.check(&TokenKind::LeftBracket) {
+                        let pat = self.parse_pattern()?;
+                        let synth_name = format!("_destructure_{}", params.len());
+                        (synth_name, Some(pat))
+                    } else {
+                        let name = self.consume_identifier("Expected parameter name")?;
+                        (name, None)
+                    };
 
                 let type_annotation = if self.match_token(&[TokenKind::Colon]) {
                     Some(self.parse_type()?)
@@ -325,6 +333,7 @@ impl Parser {
                     name,
                     type_annotation,
                     default,
+                    pattern,
                 });
 
                 if !self.match_token(&[TokenKind::Comma]) {
@@ -522,6 +531,7 @@ impl Parser {
                         name: param_name,
                         type_annotation,
                         default: None,
+                        pattern: None,
                     });
                 }
 

src/typechecker.rs

@@ -744,10 +744,14 @@ impl TypeContext {
 
                 // When otherwise is present, unwrap Result<T,E> -> T or Option<T> -> T
                 let inferred = if let Some(otherwise_block) = otherwise {
-                    // Check that the otherwise block diverges
+                    // Check that the otherwise block diverges.
+                    // This is an error, not a warning: non-diverging otherwise blocks
+                    // always crash at runtime ("otherwise block must diverge"), so
+                    // catching this at lint time prevents production outages.
+                    // See Finding #76: production outage from silent runtime error.
                     if !self.block_diverges(otherwise_block) {
                         let line = self.find_line_near("otherwise");
-                        self.warning(
+                        self.error(
                             "otherwise block does not diverge — it must end with return, break, or continue".to_string(),
                             line,
                             Some("Add a return, break, or continue statement".to_string()),
@@ -838,7 +842,7 @@ impl TypeContext {
                 if self.strict_lint {
                     let fn_line = self.find_line_near(&format!("fn {}", name));
                     for param in params {
-                        if param.type_annotation.is_none() {
+                        if param.type_annotation.is_none() && param.pattern.is_none() {
                             self.emit_with_kind(
                                 Severity::Warning,
                                 DiagnosticKind::MissingParamAnnotation,
@@ -869,7 +873,10 @@ impl TypeContext {
                         .as_ref()
                         .map(|t| self.resolve_type_expr(t))
                         .unwrap_or(Type::Any);
-                    self.bind(&param.name, typ);
+                    self.bind(&param.name, typ.clone());
+                    if let Some(ref pat) = param.pattern {
+                        self.bind_pattern(pat, &typ);
+                    }
                 }
 
                 // Set expected return type
@@ -1941,7 +1948,7 @@ impl TypeContext {
                 // Strict lint: warn about untyped lambda parameters
                 if self.strict_lint {
                     for param in params {
-                        if param.type_annotation.is_none() {
+                        if param.type_annotation.is_none() && param.pattern.is_none() {
                             let line = self.find_line_near(&param.name);
                             self.emit_with_kind(
                                 Severity::Warning,
@@ -1966,6 +1973,9 @@ impl TypeContext {
                             .map(|t| self.resolve_type_expr(t))
                             .unwrap_or(Type::Any);
                         self.bind(&p.name, typ.clone());
+                        if let Some(ref pat) = p.pattern {
+                            self.bind_pattern(pat, &typ);
+                        }
                         typ
                     })
                     .collect();
@@ -5121,21 +5131,30 @@ mod tests {
 
     #[test]
     fn test_otherwise_without_return_warns() {
-        let warnings = check_warnings(
+        // Non-diverging otherwise blocks are now errors (not warnings) since they
+        // always crash at runtime — catching this at lint time prevents outages.
+        let diags = check(
             r#"
             let x = Some(42) otherwise {
                 let y = 1
             }
             "#,
         );
-        let otherwise_warnings: Vec<_> = warnings
+        let otherwise_diags: Vec<_> = diags
             .iter()
-            .filter(|w| w.message.contains("otherwise"))
+            .filter(|d| d.message.contains("otherwise"))
             .collect();
         assert!(
-            !otherwise_warnings.is_empty(),
-            "otherwise block without return should warn: {:?}",
-            warnings
+            !otherwise_diags.is_empty(),
+            "otherwise block without return should produce a diagnostic: {:?}",
+            diags
+        );
+        assert!(
+            otherwise_diags
+                .iter()
+                .any(|d| d.severity == Severity::Error),
+            "otherwise block without return should be an error: {:?}",
+            otherwise_diags
         );
     }
 
@@ -5226,17 +5245,16 @@ mod tests {
 
     #[test]
     fn test_phase2_gradual_preserved() {
+        // Gradual typing: untyped code produces no type errors.
+        // Note: a non-diverging otherwise block is now an error (not a type error),
+        // so we use a properly diverging otherwise to isolate the gradual typing check.
         let diags = check(
             r#"
-            let val = Some(42) otherwise {
-                let x = 1
-            }
             fn foo(a) {
                 let b = fn(x) { x + 1 }
             }
             "#,
         );
-        // Only the otherwise warning, no type errors
         let errors: Vec<_> = diags
             .iter()
             .filter(|d| d.severity == Severity::Error)

tests/language_features_tests.rs

@@ -1698,6 +1698,65 @@ for [num, word] in pairs {
     assert_eq!(lines[2], "3: three");
 }
 
+// ============================================================================
+// Destructuring in Function Parameters
+// ============================================================================
+
+#[test]
+fn test_destructured_map_param() {
+    let code = r#"
+fn greet({ name, email }) {
+    return name + " <" + email + ">"
+}
+print(greet(map { "name": "Alice", "email": "a@b.com" }))
+"#;
+    let (stdout, _, exit_code) = run_ntnt_code(code);
+    assert_eq!(exit_code, 0, "Destructured map param should work");
+    assert!(stdout.trim().contains("Alice <a@b.com>"));
+}
+
+#[test]
+fn test_destructured_map_param_with_type() {
+    let code = r#"
+fn greet({ name, email }: Map) -> String {
+    return name + " <" + email + ">"
+}
+print(greet(map { "name": "Bob", "email": "b@b.com" }))
+"#;
+    let (stdout, _, exit_code) = run_ntnt_code(code);
+    assert_eq!(exit_code, 0, "Destructured map param with type should work");
+    assert!(stdout.trim().contains("Bob <b@b.com>"));
+}
+
+#[test]
+fn test_destructured_array_param() {
+    let code = r#"
+fn sum_first_two([a, b, ...rest]) {
+    return a + b
+}
+print(sum_first_two([10, 20, 30]))
+"#;
+    let (stdout, _, exit_code) = run_ntnt_code(code);
+    assert_eq!(exit_code, 0, "Destructured array param should work");
+    assert!(stdout.trim().contains("30"));
+}
+
+#[test]
+fn test_destructured_param_with_regular_params() {
+    let code = r#"
+fn process(id, { name }) {
+    return str(id) + ": " + name
+}
+print(process(42, map { "name": "Alice" }))
+"#;
+    let (stdout, _, exit_code) = run_ntnt_code(code);
+    assert_eq!(
+        exit_code, 0,
+        "Destructured param mixed with regular params should work"
+    );
+    assert!(stdout.trim().contains("42: Alice"));
+}
+
 // ============================================================================
 // Higher-Order Functions: filter, transform
 // ============================================================================