Treat non-inplace augmented assignment as a simple assignment

mypy/checker.py

@@ -1909,8 +1909,14 @@ def visit_operator_assignment_stmt(self,
         """Type check an operator assignment statement, e.g. x += 1."""
         lvalue_type = self.expr_checker.accept(s.lvalue)
         inplace, method = infer_operator_assignment_method(lvalue_type, s.op)
-        rvalue_type, method_type = self.expr_checker.check_op(
-            method, lvalue_type, s.rvalue, s)
+        if inplace:
+            rvalue_type, method_type = self.expr_checker.check_op(
+                method, lvalue_type, s.rvalue, s)
+        else:
+            lvalue_type, index_lvalue, inferred = self.check_lvalue(s.lvalue)
+            expr = OpExpr(s.op, s.lvalue, s.rvalue)
+            expr.set_line(s)
+            rvalue_type = self.expr_checker.accept(expr, lvalue_type)
 
         if isinstance(s.lvalue, IndexExpr) and not inplace:
             self.check_indexed_assignment(s.lvalue, s.rvalue, s.rvalue)

test-data/unit/check-statements.test

@@ -1514,3 +1514,10 @@ class A(): pass
 class B(): pass
 [out]
 main:8: error: Incompatible types in assignment (expression has type "A", variable has type "B")
+
+[case testAugmentedAssignmentIntFloat]
+weight0 = 65.5
+weight0 = 65
+weight0 *= 0.5
+
+[builtins fixtures/float.pyi]

test-data/unit/fixtures/float.pyi

@@ -0,0 +1,30 @@
+Any = 0
+
+class object:
+    def __init__(self) -> None: pass
+
+class type:
+    def __init__(self, x: Any) -> None: pass
+
+class str:
+    def __add__(self, other: 'str') -> 'str': pass
+class bytes: pass
+
+class tuple: pass
+class function: pass
+
+class ellipsis: pass
+
+
+class int:
+    def __float__(self) -> float: ...
+    def __int__(self) -> int: ...
+    def __mul__(self, x: int) -> int: ...
+    def __rmul__(self, x: int) -> int: ...
+
+class float:
+    def __float__(self) -> float: ...
+    def __int__(self) -> int: ...
+    def __mul__(self, x: float) -> float: ...
+    def __rmul__(self, x: float) -> float: ...
+