Improve error handling in "+=" and similar operators

self_hosted/typecheck.jou

@@ -60,6 +60,8 @@ def can_cast_explicitly(from: Type*, to: Type*) -> bool:
 # of types. We cannot use printf() style functions because the arguments can be in
 # any order.
 def fail_with_implicit_cast_error(location: Location, template: byte*, from: Type*, to: Type*) -> void:
+    assert template != NULL
+
     n = 0
     for i = 0; template[i] != '\0'; i++:
         if template[i] == '<':
@@ -1167,13 +1169,19 @@ class Stage3TypeChecker:
     ) -> void:
         ensure_can_take_address(target, "cannot assign to %s")
         target_types = self->do_expression(target)
+        value_types = self->do_expression(value)
+
+        t = check_binop(op_expr_kind, location, target_types, value_types)
+        temp_value_types = ExpressionTypes{ expression = target, original_type = t }
 
         error_template: byte[200]
         strcpy(error_template, op_description)
         strcat(error_template, " produced a value of type <from> which cannot be assigned back to <to>")
+        temp_value_types.do_implicit_cast(target_types->original_type, location, error_template)
 
-        # TODO: this logic doesn't make much sense
-        self->do_expression_and_implicit_cast(value, target_types->original_type, error_template)
+        # I think it is currently impossible to cast target.
+        # If this assert fails, we probably need a new error message.
+        assert target_types->implicit_cast_type == NULL
 
     def do_statement(self, statement: AstStatement*) -> void:
         if statement->kind == AstStatementKind::ExpressionStatement:

src/typecheck.c

@@ -465,6 +465,8 @@ any order.
 static noreturn void fail_with_implicit_cast_error(
     Location location, const char *template, const Type *from, const Type *to)
 {
+    assert(template);
+
     List(char) msg = {0};
     while(*template){
         if (!strncmp(template, "FROM", 4)) {
@@ -1203,23 +1205,32 @@ static void typecheck_statement(FileTypes *ft, const AstStatement *stmt)
         const AstExpression *targetexpr = &stmt->data.assignment.target;
         const AstExpression *valueexpr = &stmt->data.assignment.value;
 
-        ensure_can_take_address(targetexpr, "cannot assign to %s");
-
+        enum AstExpressionKind op;
         const char *opname;
+
         switch(stmt->kind) {
-            case AST_STMT_INPLACE_ADD: opname = "addition"; break;
-            case AST_STMT_INPLACE_SUB: opname = "subtraction"; break;
-            case AST_STMT_INPLACE_MUL: opname = "multiplication"; break;
-            case AST_STMT_INPLACE_DIV: opname = "division"; break;
-            case AST_STMT_INPLACE_MOD: opname = "modulo"; break;
+            case AST_STMT_INPLACE_ADD: op = AST_EXPR_ADD; opname = "addition"; break;
+            case AST_STMT_INPLACE_SUB: op = AST_EXPR_SUB; opname = "subtraction"; break;
+            case AST_STMT_INPLACE_MUL: op = AST_EXPR_MUL; opname = "multiplication"; break;
+            case AST_STMT_INPLACE_DIV: op = AST_EXPR_DIV; opname = "division"; break;
+            case AST_STMT_INPLACE_MOD: op = AST_EXPR_MOD; opname = "modulo"; break;
             default: assert(0);
         }
 
-        char errmsg[500];
-        sprintf(errmsg, "%s produced a value of type FROM which cannot be assigned back to TO", opname);
+        ensure_can_take_address(targetexpr, "cannot assign to %s");
+        ExpressionTypes *targettypes = typecheck_expression_not_void(ft, targetexpr);
+        ExpressionTypes *valuetypes = typecheck_expression_not_void(ft, valueexpr);
+
+        const Type *t = check_binop(op, stmt->location, targettypes, valuetypes);
+        ExpressionTypes tempvalue_types = { .expr = targetexpr, .type = t };
+
+        char msg[500];
+        snprintf(msg, sizeof msg, "%s produced a value of type FROM which cannot be assigned back to TO", opname);
+        do_implicit_cast(&tempvalue_types, targettypes->type, stmt->location, msg);
 
-        const ExpressionTypes *targettypes = typecheck_expression_not_void(ft, targetexpr);
-        typecheck_expression_with_implicit_cast(ft, valueexpr, targettypes->type, errmsg);
+        // I think it is currently impossible to cast target.
+        // If this assert fails, we probably need to add another error message for it.
+        assert(!targettypes->implicit_cast_type);
         break;
     }
 

tests/wrong_type/inplace_add_str_int.jou

@@ -0,0 +1,3 @@
+def foo(s: byte*) -> void:
+    # The "Jou way" would be:  s = &s[5]
+    s += 5  # Error: wrong types: cannot add byte* and int

tests/wrong_type/inplace_mul_str_str.jou

@@ -0,0 +1,3 @@
+def foo() -> void:
+    x = "hello"
+    x *= "world"  # Error: wrong types: cannot multiply byte* and byte*