fix(compiler): no error when trying to reassign to a let variable

examples/tests/invalid/reassing_to_nonreassignable.w

@@ -0,0 +1,2 @@
+let x = 9;
+x = 10;

examples/tests/valid/anon_function.w

@@ -1,5 +1,5 @@
 // Define a function and assign it to a variable
-let myfunc = (x: num) => {
+let myfunc = (var x: num) => {
   print("${x}");
   x = x + 1;
   if (x > 3.14) {

libs/tree-sitter-wing/grammar.js

@@ -157,7 +157,7 @@ module.exports = grammar({
     class_member: ($) =>
       seq(
         optional(field("access_modifier", $.access_modifier)),
-        optional($.reassignable),
+        optional(field("reassignable", $.reassignable)),
         field("name", $.identifier),
         $._type_annotation,
         ";"
@@ -373,7 +373,11 @@ module.exports = grammar({
     access_modifier: ($) => choice("public", "private", "protected"),
 
     parameter_definition: ($) =>
-      seq(field("name", $.identifier), $._type_annotation),
+      seq(
+        optional(field("reassignable", $.reassignable)),
+        field("name", $.identifier), 
+        $._type_annotation
+      ),
 
     parameter_list: ($) => seq("(", commaSep($.parameter_definition), ")"),
 

libs/tree-sitter-wing/test/corpus/statements.txt

@@ -76,7 +76,7 @@ return 1;
 Inflight closure
 ====================
 
-inflight (a: num, b: str?, c: bool) => {};
+inflight (a: num, b: str?, var c: bool) => {};
 
 ---
 
@@ -95,6 +95,7 @@ inflight (a: num, b: str?, c: bool) => {};
                     )
                 )
                 (parameter_definition
+                    reassignable: (reassignable)
                     name: (identifier)
                     type: (builtin_type)
                 )

libs/wingc/src/ast.rs

@@ -134,7 +134,7 @@ pub struct FunctionSignature {
 #[derive(Derivative)]
 #[derivative(Debug)]
 pub struct FunctionDefinition {
-	pub parameter_names: Vec<Symbol>, // TODO: move into FunctionSignature and make optional
+	pub parameters: Vec<(Symbol, VariableKind)>, // TODO: move into FunctionSignature and make optional
 	pub statements: Scope,
 	pub signature: FunctionSignature,
 	#[derivative(Debug = "ignore")]
@@ -143,7 +143,7 @@ pub struct FunctionDefinition {
 
 #[derive(Debug)]
 pub struct Constructor {
-	pub parameters: Vec<Symbol>,
+	pub parameters: Vec<(Symbol, VariableKind)>,
 	pub statements: Scope,
 	pub signature: FunctionSignature,
 }

libs/wingc/src/capture.rs

@@ -195,7 +195,8 @@ fn scan_captures_in_call(
 				Ok((prop_type, phase)) => (
 					prop_type
 						.as_variable()
-						.expect("Expected resource property to be a variable"),
+						.expect("Expected resource property to be a variable")
+						._type,
 					phase,
 				),
 				Err(type_error) => {
@@ -263,7 +264,7 @@ fn scan_captures_in_expression(
 							span: Some(symbol.span.clone()),
 						});
 					} else {
-						let t = var.as_variable().unwrap();
+						let t = var.as_variable().unwrap()._type;
 
 						// if the identifier represents a preflight value, then capture it
 						if f == Phase::Preflight {

libs/wingc/src/jsify.rs

@@ -438,7 +438,7 @@ impl JSifier {
 			ExprKind::FunctionClosure(func_def) => match func_def.signature.flight {
 				Phase::Inflight => self.jsify_inflight_function(func_def),
 				Phase::Independent => unimplemented!(),
-				Phase::Preflight => self.jsify_function(None, &func_def.parameter_names, &func_def.statements, phase),
+				Phase::Preflight => self.jsify_function(None, &func_def.parameters, &func_def.statements, phase),
 			},
 		}
 	}
@@ -567,7 +567,7 @@ impl JSifier {
 						.map(|(n, m)| format!(
 							"{} = {}",
 							n.name,
-							self.jsify_function(None, &m.parameter_names, &m.statements, phase)
+							self.jsify_function(None, &m.parameters, &m.statements, phase)
 						))
 						.collect::<Vec<String>>()
 						.join("\n")
@@ -623,8 +623,8 @@ impl JSifier {
 
 	fn jsify_inflight_function(&self, func_def: &FunctionDefinition) -> String {
 		let mut parameter_list = vec![];
-		for p in func_def.parameter_names.iter() {
-			parameter_list.push(p.name.clone());
+		for p in func_def.parameters.iter() {
+			parameter_list.push(p.0.name.clone());
 		}
 		let block = self.jsify_scope(&func_def.statements, Phase::Inflight);
 		let procid = base16ct::lower::encode_string(&Sha256::new().chain_update(&block).finalize());
@@ -696,10 +696,16 @@ impl JSifier {
 		)
 	}
 
-	fn jsify_function(&self, name: Option<&str>, parameters: &[Symbol], body: &Scope, phase: Phase) -> String {
+	fn jsify_function(
+		&self,
+		name: Option<&str>,
+		parameters: &[(Symbol, VariableKind)],
+		body: &Scope,
+		phase: Phase,
+	) -> String {
 		let mut parameter_list = vec![];
 		for p in parameters.iter() {
-			parameter_list.push(self.jsify_symbol(p));
+			parameter_list.push(self.jsify_symbol(&p.0));
 		}
 
 		let (name, arrow) = match name {

libs/wingc/src/lib.rs

@@ -5,7 +5,7 @@ use ast::{Scope, Stmt, Symbol, UtilityFunctions, VariableKind};
 use diagnostic::{print_diagnostics, Diagnostic, DiagnosticLevel, Diagnostics, WingSpan};
 use jsify::JSifier;
 use type_check::symbol_env::StatementIdx;
-use type_check::{FunctionSignature, SymbolKind, Type};
+use type_check::{FunctionSignature, SymbolKind, Type, VariableInfo};
 
 use crate::parser::Parser;
 use std::cell::RefCell;
@@ -158,7 +158,10 @@ fn add_builtin(name: &str, typ: Type, scope: &mut Scope, types: &mut Types) {
 		.unwrap()
 		.define(
 			&sym,
-			SymbolKind::Variable(types.add_type(typ), VariableKind::Let),
+			SymbolKind::Variable(VariableInfo {
+				_type: types.add_type(typ),
+				kind: VariableKind::Let,
+			}),
 			StatementIdx::Top,
 		)
 		.expect("Failed to add builtin");

libs/wingc/src/parser.rs

@@ -334,7 +334,7 @@ impl Parser<'_> {
 					}
 					let parameters = self.build_parameter_list(&class_element.child_by_field_name("parameter_list").unwrap())?;
 					constructor = Some(Constructor {
-						parameters: parameters.iter().map(|p| p.0.clone()).collect(),
+						parameters: parameters.iter().map(|p| (p.0.clone(), p.2)).collect(),
 						statements: self.build_scope(&class_element.child_by_field_name("block").unwrap()),
 						signature: FunctionSignature {
 							parameters: parameters.iter().map(|p| p.1.clone()).collect(),
@@ -394,7 +394,7 @@ impl Parser<'_> {
 	fn build_function_definition(&self, func_def_node: &Node, flight: Phase) -> DiagnosticResult<FunctionDefinition> {
 		let parameters = self.build_parameter_list(&func_def_node.child_by_field_name("parameter_list").unwrap())?;
 		Ok(FunctionDefinition {
-			parameter_names: parameters.iter().map(|p| p.0.clone()).collect(),
+			parameters: parameters.iter().map(|p| (p.0.clone(), p.2)).collect(),
 			statements: self.build_scope(&func_def_node.child_by_field_name("block").unwrap()),
 			signature: FunctionSignature {
 				parameters: parameters.iter().map(|p| p.1.clone()).collect(),
@@ -409,16 +409,24 @@ impl Parser<'_> {
 		})
 	}
 
-	fn build_parameter_list(&self, parameter_list_node: &Node) -> DiagnosticResult<Vec<(Symbol, Type)>> {
+	fn build_parameter_list(&self, parameter_list_node: &Node) -> DiagnosticResult<Vec<(Symbol, Type, VariableKind)>> {
 		let mut res = vec![];
 		let mut cursor = parameter_list_node.walk();
 		for parameter_definition_node in parameter_list_node.named_children(&mut cursor) {
 			if parameter_definition_node.is_extra() {
 				continue;
 			}
+
+			let kind = if let Some(_) = parameter_definition_node.child_by_field_name("reassignable") {
+				VariableKind::Var
+			} else {
+				VariableKind::Let
+			};
+
 			res.push((
 				self.node_symbol(&parameter_definition_node.child_by_field_name("name").unwrap())?,
 				self.build_type(&parameter_definition_node.child_by_field_name("type").unwrap())?,
+				kind,
 			))
 		}