New semantic analyzer: fix crash on broken overload at class scope

mypy/checkexpr.py

@@ -174,6 +174,8 @@ def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
         elif isinstance(node, OverloadedFuncDef) and node.type is not None:
             # node.type is None when there are multiple definitions of a function
             # and it's decorated by something that is not typing.overload
+            # TODO: use a dummy Overloaded instead of AnyType in this case
+            # like we do in mypy.types.function_type()?
             result = node.type
         elif isinstance(node, TypeInfo):
             # Reference to a type object.

mypy/newsemanal/semanal.py

@@ -701,8 +701,6 @@ def analyze_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         self.process_final_in_overload(defn)
         self.process_static_or_class_method_in_overload(defn)
 
-        self.add_symbol(defn.name(), defn, defn)
-
     def analyze_overload_sigs_and_impl(
             self,
             defn: OverloadedFuncDef) -> Tuple[List[CallableType],

mypy/types.py

@@ -2177,9 +2177,18 @@ def function_type(func: mypy.nodes.FuncBase, fallback: Instance) -> FunctionLike
         return func.type
     else:
         # Implicit type signature with dynamic types.
-        # Overloaded functions always have a signature, so func must be an ordinary function.
-        assert isinstance(func, mypy.nodes.FuncItem), str(func)
-        return callable_type(func, fallback)
+        if isinstance(func, mypy.nodes.FuncItem):
+            return callable_type(func, fallback)
+        else:
+            # Broken overloads can have self.type set to None.
+            assert isinstance(func, mypy.nodes.OverloadedFuncDef)
+            any_type = AnyType(TypeOfAny.from_error)
+            dummy = CallableType([any_type, any_type],
+                                 [ARG_STAR, ARG_STAR2],
+                                 [None, None], any_type,
+                                 fallback,
+                                 line=func.line, is_ellipsis_args=True)
+            return Overloaded([dummy])
 
 
 def callable_type(fdef: mypy.nodes.FuncItem, fallback: Instance,

test-data/unit/check-newsemanal.test

@@ -3113,3 +3113,22 @@ class A: pass
 def f() -> None: pass
 
 [targets m, m.f, __main__]
+
+[case testNewAnalyzerNoCrashOnCustomProperty]
+# flags: --ignore-missing-imports
+from unimported import custom
+
+class User:
+    first_name: str
+
+    @custom
+    def name(self) -> str:
+        return self.first_name
+
+    @name.setter  # type: ignore
+    def name(self, value: str) -> None:
+        self.first_name = value
+
+    def __init__(self, name: str) -> None:
+        self.name = name  # E: Cannot assign to a method \
+                          # E: Incompatible types in assignment (expression has type "str", variable has type overloaded function)