feat(compiler): addition and subtraction assignment operators implementation

docs/docs/03-language-reference.md

@@ -2035,15 +2035,17 @@ Ternary or conditional operators are not supported.
 
 #### 6.4.3 Mathematics Operators
 
-| Operator | Description    | Example  |
-| -------- | -------------- | -------- |
-| `*`      | Multiplication | `a * b`  |
-| `/`      | Division       | `a / b`  |
-| `\`      | Floor Division | `a \ b`  |
-| `%`      | Modulus        | `a % b`  |
-| `+`      | Addition       | `a + b`  |
-| `-`      | Subtraction    | `a - b`  |
-| `**`     | Power          | `a ** b` |
+| Operator | Description            | Example  |
+| -------- | ---------------------- | -------- |
+| `*`      | Multiplication         | `a * b`  |
+| `/`      | Division               | `a / b`  |
+| `\`      | Floor Division         | `a \ b`  |
+| `%`      | Modulus                | `a % b`  |
+| `+`      | Addition               | `a + b`  |
+| `-`      | Subtraction            | `a - b`  |
+| `**`     | Power                  | `a ** b` |
+| `-=`     | Subtraction Assignment | `a -= b` |
+| `+=`     | Addition Assignment    | `a += b` |
 
 [`▲ top`][top]
 

examples/tests/valid/expressions_binary_operators.w

@@ -15,4 +15,10 @@ assert(xyznf == -5);
 let xyznfj = 501.9 \ (-99.1 - 0.91);
 assert(xyznfj == -5);
 let xynfj = -501.9 \ (-99.1 - 0.91);
-assert(xynfj == 5);
+assert(xynfj == 5);
+let xyas = 5;
+xyas += 10;
+assert(xyas == 15);
+let xyss = 5;
+xyss -= 10;
+assert(xyss == -5);

libs/tree-sitter-wing/grammar.js

@@ -8,13 +8,15 @@ const PREC = {
   RELATIONAL: 70,
   UNWRAP_OR: 80,
   SHIFT: 90,
-  ADD: 100,
-  MULTIPLY: 110,
-  UNARY: 120,
-  OPTIONAL_TEST: 130,
-  POWER: 140,
-  MEMBER: 150,
-  CALL: 160,
+  ADD_ASSIGNMENT: 100,
+  SUBTRACT_ASSIGNMENT: 110,
+  ADD: 120,
+  MULTIPLY: 130,
+  UNARY: 140,
+  OPTIONAL_TEST: 150,
+  POWER: 160,
+  MEMBER: 170,
+  CALL: 180,
 };
 
 module.exports = grammar({
@@ -607,6 +609,8 @@ module.exports = grammar({
         //['>>', PREC.SHIFT],
         //['>>>', PREC.SHIFT],
         ["??", PREC.UNWRAP_OR],
+        ["+=", PREC.ADD_ASSIGNMENT],
+        ["-=", PREC.SUBTRACT_ASSIGNMENT],
       ];
 
       return choice(

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

@@ -29,6 +29,8 @@ Binary expressions
 ================================================================================
 
 5 * 1;
+1 += 5;
+1 -= 5;
 (5+1) % 1;
 5+1 % 1;
 5 % 1 + 1;
@@ -38,6 +40,14 @@ Binary expressions
 --------------------------------------------------------------------------------
 
 (source
+  (expression_statement
+    (binary_expression
+      left: (number)
+      right: (number)))
+  (expression_statement
+    (binary_expression
+      left: (number)
+      right: (number)))
   (expression_statement
     (binary_expression
       left: (number)

libs/wingc/src/ast.rs

@@ -702,6 +702,8 @@ pub enum BinaryOperator {
 	LogicalAnd,
 	LogicalOr,
 	UnwrapOr,
+	SubtractAssignment,
+	AddAssignment,
 }
 
 #[derive(Debug)]

libs/wingc/src/jsify.rs

@@ -593,7 +593,9 @@ impl<'a> JSifier<'a> {
 						// Use JS nullish coalescing operator which treats undefined and null the same
 						// this is inline with how wing jsifies optionals
 						"??"
-					}
+					},
+					BinaryOperator::AddAssignment => "+=",
+					BinaryOperator::SubtractAssignment => "-=",
 				};
 				format!("({} {} {})", js_left, js_op, js_right)
 			}

libs/wingc/src/parser.rs

@@ -1587,6 +1587,8 @@ impl<'s> Parser<'s> {
 						"\\" => BinaryOperator::FloorDiv,
 						"**" => BinaryOperator::Power,
 						"??" => BinaryOperator::UnwrapOr,
+						"-=" => BinaryOperator::SubtractAssignment,
+						"+=" => BinaryOperator::AddAssignment,
 						"ERROR" => self.with_error::<BinaryOperator>("Expected binary operator", expression_node)?,
 						other => return self.report_unimplemented_grammar(other, "binary operator", expression_node),
 					},

libs/wingc/src/type_check.rs

@@ -1826,6 +1826,16 @@ impl<'a> TypeChecker<'a> {
 							(inner_type, ltype_phase)
 						}
 					}
+					BinaryOperator::SubtractAssignment => {
+						self.validate_type(ltype, self.types.number(), left);
+						self.validate_type(rtype, self.types.number(), right);
+						(self.types.number(), Phase::Independent)
+					}
+					BinaryOperator::AddAssignment => {
+						self.validate_type(ltype, self.types.number(), left);
+						self.validate_type(rtype, self.types.number(), right);
+						(self.types.number(), Phase::Independent)
+					}
 				}
 			}
 			ExprKind::Unary { op, exp: unary_exp } => {