Fix crash on overriding class level type alias

mypy/checker.py

@@ -1360,16 +1360,22 @@ def check_method_override_for_base_with_name(
             # it can be checked for compatibility.
             original_type = base_attr.type
             original_node = base_attr.node
+            if isinstance(original_node, TypeAlias):
+                # Overriding a type alias is always an error, it is static by nature.
+                self.msg.cannot_overide_alias(original_node.name(), base.name(), defn)
+                return False
             if original_type is None:
                 if self.pass_num < self.last_pass:
-                    # If there are passes left, defer this node until next pass,
-                    # otherwise try reconstructing the method type from available information.
+                    # If there are passes left, defer this node until next pass...
                     self.defer_node(defn, defn.info)
                     return True
+                # ...otherwise try reconstructing the supertype from available information.
                 elif isinstance(original_node, (FuncDef, OverloadedFuncDef)):
                     original_type = self.function_type(original_node)
                 elif isinstance(original_node, Decorator):
                     original_type = self.function_type(original_node.func)
+                elif isinstance(original_node, Var):
+                    original_type = AnyType(TypeOfAny.implementation_artifact)
                 else:
                     assert False, str(base_attr.node)
             if isinstance(original_node, (FuncDef, OverloadedFuncDef)):
@@ -1845,6 +1851,11 @@ def check_compatibility_all_supers(self, lvalue: RefExpr, lvalue_type: Optional[
 
                 base_type, base_node = self.lvalue_type_from_base(lvalue_node, base)
 
+                if isinstance(base_node, TypeAlias):
+                    # Overriding a type alias is always an error, it is static by nature.
+                    self.msg.cannot_overide_alias(base_node.name(), base.name(), lvalue)
+                    return True
+
                 if base_type:
                     assert base_node is not None
                     if not self.check_compatibility_super(lvalue,
@@ -1923,6 +1934,10 @@ def lvalue_type_from_base(self, expr_node: Var,
         if base_var:
             base_node = base_var.node
             base_type = base_var.type
+
+            if isinstance(base_node, TypeAlias):
+                return None, base_node
+
             if isinstance(base_node, Decorator):
                 base_node = base_node.func
                 base_type = base_node.type

mypy/messages.py

@@ -868,6 +868,10 @@ def alias_invalid_in_runtime_context(self, item: Type, ctx: Context) -> None:
                 ' to Union' if isinstance(item, UnionType) else '')
         self.fail('The type alias{} is invalid in runtime context'.format(kind), ctx)
 
+    def cannot_overide_alias(self, name: str, base: str, ctx: Context) -> None:
+        self.fail('Cannot override type alias "{}" defined'
+                  ' in base class "{}"'.format(name, base), ctx)
+
     def could_not_infer_type_arguments(self, callee_type: CallableType, n: int,
                                        context: Context) -> None:
         callee_name = callable_name(callee_type)

test-data/unit/check-type-aliases.test

@@ -611,3 +611,33 @@ except E as e:
     reveal_type(e)  # E: Revealed type is '__main__.E'
 [builtins fixtures/exception.pyi]
 [out]
+
+[case testNoOverrideAliasInSubclassMethod]
+from typing import Any, Callable
+
+class Parent:
+    foo = Callable[..., int]
+
+class Child(Parent):
+    def foo(self, val: int) -> int: ...  # E: Cannot override type alias "foo" defined in base class "Parent"
+[out]
+
+[case testNoOverrideAliasInSubclassVar]
+from typing import Any, Callable
+
+class Parent:
+    foo = Callable[..., int]
+
+class Child(Parent):
+    foo: Callable[..., int]  # E: Cannot override type alias "foo" defined in base class "Parent"
+[out]
+
+[case testNoOverrideAliasInSubclassAlias]
+from typing import Any, Callable
+
+class Parent:
+    foo = Callable[..., int]
+
+class Child(Parent):
+    foo = Callable[..., int]  # E: Cannot override type alias "foo" defined in base class "Parent"
+[out]