compound assignment

compiler/parser/parser.odin

@@ -663,8 +663,10 @@ infix_binding_power :: proc(kind: token.Kind) -> (left, right: int, ok: bool) {
 		return 6, 7, true
 	case .Equal_Equal, .Bang_Equal, .Less, .Less_Equal, .Greater, .Greater_Equal:
 		return 8, 9, true
-	case .Plus:
+	case .Plus, .Minus:
 		return 10, 11, true
+	case .Star, .Slash:
+		return 12, 13, true
 	}
 	return 0, 0, false
 }
@@ -681,10 +683,24 @@ infix_expr_kind :: proc(kind: token.Kind) -> ast.Expr_Kind {
 	case .Less_Equal:      return .Le
 	case .Greater:         return .Gt
 	case .Greater_Equal:   return .Ge
+	case .Plus:            return .Add
+	case .Minus:           return .Sub
+	case .Star:            return .Mul
+	case .Slash:           return .Div
 	case:                  return .Add
 	}
 }
 
+compound_assignment_op :: proc(kind: token.Kind) -> (ast.Assignment_Op, bool) {
+	#partial switch kind {
+	case .Plus_Equal:  return .Add, true
+	case .Minus_Equal: return .Sub, true
+	case .Star_Equal:  return .Mul, true
+	case .Slash_Equal: return .Div, true
+	}
+	return .Set, false
+}
+
 is_simple_range_bound :: proc(expr: ast.Expr) -> bool {
 	if expr.parenthesized {
 		return true
@@ -1029,6 +1045,22 @@ parse_statement :: proc(parser: ^Parser) -> ast.Stmt_Id {
 		})
 		return id
 	}
+	if assignment_op, is_compound := compound_assignment_op(current(parser).kind); is_compound {
+		advance(parser)
+		skip_newlines(parser)
+		value := parse_expression(parser)
+		span := span_from(parser.module.exprs[expr].span, parser.module.exprs[value].span)
+		id := ast.stmt_id(len(parser.module.statements))
+		append(&parser.module.statements, ast.Stmt{
+			kind=.Assignment,
+			span=span,
+			assignment_op=assignment_op,
+			target=expr,
+			expr=value,
+			diagnostic=source.INVALID_DIAGNOSTIC,
+		})
+		return id
+	}
 	id := ast.stmt_id(len(parser.module.statements))
 	append(&parser.module.statements, ast.Stmt{
 		kind=.Expression,