fix: allow multi-line function params, lambda params, tuples, and patterns

Added skip_newlines() calls throughout the parser so that newlines are
properly handled in parameter lists, tuple expressions, and pattern
matching constructs. Fixes Issue 5 and Issue 6 from ISSUES.md.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Cargo.lock

@@ -770,7 +770,7 @@ dependencies = [
 
 [[package]]
 name = "lux"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "lsp-server",
  "lsp-types",

src/codegen/c_backend.rs

@@ -146,6 +146,8 @@ pub struct CBackend {
     imported_modules: HashSet<String>,
     /// Variable name renames: Lux name → C variable name (for let binding name mangling)
     var_renames: HashMap<String, String>,
+    /// Inner type for Option-typed variables (variable name -> inner C type, e.g. "LuxInt")
+    var_option_inner_types: HashMap<String, String>,
 }
 
 impl CBackend {
@@ -177,6 +179,7 @@ impl CBackend {
             module_functions: HashMap::new(),
             imported_modules: HashSet::new(),
             var_renames: HashMap::new(),
+            var_option_inner_types: HashMap::new(),
         }
     }
 
@@ -279,7 +282,7 @@ impl CBackend {
                 Declaration::Let(let_decl) => {
                     // Skip run expressions - they're handled in the main wrapper
                     if !matches!(&let_decl.value, Expr::Run { .. }) {
-                        self.emit_global_let(&let_decl.name)?;
+                        self.emit_global_let(let_decl)?;
                     }
                 }
                 _ => {}
@@ -599,6 +602,18 @@ impl CBackend {
         self.writeln(&format!("{} {}({}) {{", ret_type, mangled_name, full_params));
         self.indent += 1;
 
+        // Register parameter types so match/option inference can use them
+        for p in &func.params {
+            if let Ok(c_type) = self.type_expr_to_c(&p.typ) {
+                let escaped = self.escape_c_keyword(&p.name.name);
+                self.var_types.insert(escaped.clone(), c_type);
+                // Track Option inner types for match pattern extraction
+                if let Some(inner) = self.option_inner_type_from_type_expr(&p.typ) {
+                    self.var_option_inner_types.insert(escaped, inner);
+                }
+            }
+        }
+
         let old_has_evidence = self.has_evidence;
         if is_effectful {
             self.has_evidence = true;
@@ -2145,20 +2160,6 @@ impl CBackend {
         self.writeln("static Option lux_option_none(void) { return (Option){Option_TAG_NONE}; }");
         self.writeln("static Option lux_option_some(void* value) { return (Option){Option_TAG_SOME, .data.some = {value}}; }");
         self.writeln("");
-        self.writeln("// String indexOf / lastIndexOf — return Option<Int>");
-        self.writeln("static Option lux_string_indexOf(LuxString s, LuxString needle) {");
-        self.writeln("    char* pos = strstr(s, needle);");
-        self.writeln("    if (pos) return lux_option_some((void*)(intptr_t)(pos - s));");
-        self.writeln("    return lux_option_none();");
-        self.writeln("}");
-        self.writeln("static Option lux_string_lastIndexOf(LuxString s, LuxString needle) {");
-        self.writeln("    char* last = NULL;");
-        self.writeln("    char* pos = strstr(s, needle);");
-        self.writeln("    while (pos) { last = pos; pos = strstr(pos + 1, needle); }");
-        self.writeln("    if (last) return lux_option_some((void*)(intptr_t)(last - s));");
-        self.writeln("    return lux_option_none();");
-        self.writeln("}");
-        self.writeln("");
         self.writeln("// === Boxing/Unboxing ===");
         self.writeln("// All boxed values are RC-managed.");
         self.writeln("");
@@ -2192,6 +2193,20 @@ impl CBackend {
         self.writeln("}");
         self.writeln("static LuxString lux_unbox_string(void* p) { return (LuxString)p; }");
         self.writeln("");
+        self.writeln("// String indexOf / lastIndexOf — return Option<Int>");
+        self.writeln("static Option lux_string_indexOf(LuxString s, LuxString needle) {");
+        self.writeln("    char* pos = strstr(s, needle);");
+        self.writeln("    if (pos) return lux_option_some(lux_box_int((LuxInt)(pos - s)));");
+        self.writeln("    return lux_option_none();");
+        self.writeln("}");
+        self.writeln("static Option lux_string_lastIndexOf(LuxString s, LuxString needle) {");
+        self.writeln("    char* last = NULL;");
+        self.writeln("    char* pos = strstr(s, needle);");
+        self.writeln("    while (pos) { last = pos; pos = strstr(pos + 1, needle); }");
+        self.writeln("    if (last) return lux_option_some(lux_box_int((LuxInt)(last - s)));");
+        self.writeln("    return lux_option_none();");
+        self.writeln("}");
+        self.writeln("");
         self.writeln("// === Polymorphic Drop Function ===");
         self.writeln("// Called when an object's refcount reaches zero.");
         self.writeln("// Recursively decrefs any owned references before freeing.");
@@ -2727,7 +2742,11 @@ impl CBackend {
         for param in &func.params {
             let escaped = self.escape_c_keyword(&param.name.name);
             if let Ok(c_type) = self.type_expr_to_c(&param.typ) {
-                self.var_types.insert(escaped, c_type);
+                self.var_types.insert(escaped.clone(), c_type);
+                // Track Option inner types for match pattern extraction
+                if let Some(inner) = self.option_inner_type_from_type_expr(&param.typ) {
+                    self.var_option_inner_types.insert(escaped, inner);
+                }
             }
         }
 
@@ -3088,6 +3107,13 @@ impl CBackend {
                 // Infer the type from the value expression
                 let var_type = self.infer_expr_type(value).unwrap_or_else(|| "LuxInt".to_string());
 
+                // Track Option inner type for match pattern extraction
+                if var_type == "Option" {
+                    if let Some(inner) = self.infer_option_inner_type(value) {
+                        self.var_option_inner_types.insert(var_name.clone(), inner);
+                    }
+                }
+
                 self.writeln(&format!("{} {} = {};", var_type, var_name, val));
 
                 // Register the variable rename so nested expressions can find it
@@ -3396,6 +3422,13 @@ impl CBackend {
                             // Record variable type for future inference
                             self.var_types.insert(escaped_name.clone(), typ.clone());
 
+                            // Track Option inner type for match pattern extraction
+                            if typ == "Option" {
+                                if let Some(inner) = self.infer_option_inner_type(value) {
+                                    self.var_option_inner_types.insert(escaped_name.clone(), inner);
+                                }
+                            }
+
                             // Handle ownership transfer or RC registration
                             if let Some(source_name) = source_var {
                                 // Ownership transfer: unregister source, register dest
@@ -4872,8 +4905,8 @@ impl CBackend {
                 if c_type == "void*" {
                     // Cast from void* to actual type
                     if Self::is_primitive_c_type(&actual_type) {
-                        // For primitive types stored as void*, cast via intptr_t
+                        // For primitive types stored as boxed void*, dereference
-                        self.writeln(&format!("{} {} = ({})(intptr_t)({});", actual_type, var_name, actual_type, c_expr));
+                        self.writeln(&format!("{} {} = *({}*)({});", actual_type, var_name, actual_type, c_expr));
                     } else if !actual_type.ends_with('*') && actual_type != "void" {
                         // Struct types: cast to pointer and dereference
                         self.writeln(&format!("{} {} = *({}*)({});", actual_type, var_name, actual_type, c_expr));
@@ -5414,7 +5447,13 @@ impl CBackend {
                     None
                 }
             }
-            Expr::Var(_) => None,
+            Expr::Var(ident) => {
+                let escaped = self.escape_c_keyword(&ident.name);
+                // Check renamed variables first, then original name
+                let lookup_name = self.var_renames.get(&ident.name).unwrap_or(&escaped);
+                self.var_option_inner_types.get(lookup_name).cloned()
+                    .or_else(|| self.var_option_inner_types.get(&escaped).cloned())
+            }
             _ => None,
         }
     }
@@ -5592,9 +5631,25 @@ impl CBackend {
         }
     }
 
-    fn emit_global_let(&mut self, name: &Ident) -> Result<(), CGenError> {
+    fn emit_global_let(&mut self, let_decl: &crate::ast::LetDecl) -> Result<(), CGenError> {
-        // Declare global variable without initializer (initialized in main)
+        // Infer type from the value expression (or type annotation)
-        self.writeln(&format!("static LuxInt {} = 0;", name.name));
+        let typ = if let Some(ref type_expr) = let_decl.typ {
+            self.type_expr_to_c(type_expr).unwrap_or_else(|_| "LuxInt".to_string())
+        } else {
+            self.infer_expr_type(&let_decl.value).unwrap_or_else(|| "LuxInt".to_string())
+        };
+        let default = match typ.as_str() {
+            "LuxString" => "NULL",
+            "LuxBool" => "false",
+            "LuxFloat" => "0.0",
+            "LuxList*" | "LuxClosure*" => "NULL",
+            "Option" => "{0}",
+            "Result" => "{0}",
+            _ if typ.ends_with('*') => "NULL",
+            _ => "0",
+        };
+        self.writeln(&format!("static {} {} = {};", typ, let_decl.name.name, default));
+        self.var_types.insert(let_decl.name.name.clone(), typ);
         self.writeln("");
         Ok(())
     }
@@ -5697,6 +5752,20 @@ impl CBackend {
         self.type_expr_to_c(type_expr)
     }
 
+    /// Extract the inner C type from an Option<T> type expression
+    fn option_inner_type_from_type_expr(&self, type_expr: &TypeExpr) -> Option<String> {
+        if let TypeExpr::App(base, args) = type_expr {
+            if let TypeExpr::Named(name) = base.as_ref() {
+                if name.name == "Option" {
+                    if let Some(inner) = args.first() {
+                        return self.type_expr_to_c(inner).ok();
+                    }
+                }
+            }
+        }
+        None
+    }
+
     fn type_expr_to_c(&self, type_expr: &TypeExpr) -> Result<String, CGenError> {
         match type_expr {
             TypeExpr::Named(ident) => {

src/parser.rs

@@ -846,6 +846,7 @@ impl Parser {
     /// Parse function parameters
     fn parse_params(&mut self) -> Result<Vec<Parameter>, ParseError> {
         let mut params = Vec::new();
+        self.skip_newlines();
 
         while !self.check(TokenKind::RParen) {
             let start = self.current_span();
@@ -855,9 +856,11 @@ impl Parser {
             let span = start.merge(self.previous_span());
 
             params.push(Parameter { name, typ, span });
+            self.skip_newlines();
 
             if !self.check(TokenKind::RParen) {
                 self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
             }
         }
 
@@ -1937,11 +1940,14 @@ impl Parser {
 
         if self.check(TokenKind::LParen) {
             self.advance();
+            self.skip_newlines();
             let mut fields = Vec::new();
             while !self.check(TokenKind::RParen) {
                 fields.push(self.parse_pattern()?);
+                self.skip_newlines();
                 if !self.check(TokenKind::RParen) {
                     self.expect(TokenKind::Comma)?;
+                    self.skip_newlines();
                 }
             }
             self.expect(TokenKind::RParen)?;
@@ -1960,12 +1966,15 @@ impl Parser {
     fn parse_tuple_pattern(&mut self) -> Result<Pattern, ParseError> {
         let start = self.current_span();
         self.expect(TokenKind::LParen)?;
+        self.skip_newlines();
 
         let mut elements = Vec::new();
         while !self.check(TokenKind::RParen) {
             elements.push(self.parse_pattern()?);
+            self.skip_newlines();
             if !self.check(TokenKind::RParen) {
                 self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
             }
         }
 
@@ -2095,6 +2104,7 @@ impl Parser {
 
     fn parse_lambda_params(&mut self) -> Result<Vec<Parameter>, ParseError> {
         let mut params = Vec::new();
+        self.skip_newlines();
 
         while !self.check(TokenKind::RParen) {
             let start = self.current_span();
@@ -2110,9 +2120,11 @@ impl Parser {
 
             let span = start.merge(self.previous_span());
             params.push(Parameter { name, typ, span });
+            self.skip_newlines();
 
             if !self.check(TokenKind::RParen) {
                 self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
             }
         }
 
@@ -2200,6 +2212,7 @@ impl Parser {
     fn parse_tuple_or_paren_expr(&mut self) -> Result<Expr, ParseError> {
         let start = self.current_span();
         self.expect(TokenKind::LParen)?;
+        self.skip_newlines();
 
         if self.check(TokenKind::RParen) {
             self.advance();
@@ -2210,16 +2223,19 @@ impl Parser {
         }
 
         let first = self.parse_expr()?;
+        self.skip_newlines();
 
         if self.check(TokenKind::Comma) {
             // Tuple
             let mut elements = vec![first];
             while self.check(TokenKind::Comma) {
                 self.advance();
+                self.skip_newlines();
                 if self.check(TokenKind::RParen) {
                     break;
                 }
                 elements.push(self.parse_expr()?);
+                self.skip_newlines();
             }
             self.expect(TokenKind::RParen)?;
             let span = start.merge(self.previous_span());