Refactor so that overload decides on its impl at semanal time

Author: sixolet

mypy/checker.py

@@ -261,14 +261,18 @@ def accept_loop(self, body: Statement, else_body: Statement = None, *,
 
     def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         num_abstract = 0
-        assert defn.items
+        if not defn.items:
+            # In this case we have already complained about none of these being
+            # valid overloads.
+            return None
         if len(defn.items) == 1:
             self.fail('Single overload definition, multiple required', defn)
 
         if defn.is_property:
             # HACK: Infer the type of the property.
-            self.visit_decorator(defn.items[0])
+            self.visit_decorator(cast(Decorator, defn.items[0]))
         for fdef in defn.items:
+            assert isinstance(fdef, Decorator)
             self.check_func_item(fdef.func, name=fdef.func.name())
             if fdef.func.is_abstract:
                 num_abstract += 1
@@ -283,11 +287,14 @@ def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         return None
 
     def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
-        print("Checking overlap", defn.items)
+        # At this point we should have set the impl already, and all remaining
+        # items are decorators
         for i, item in enumerate(defn.items):
+            assert isinstance(item, Decorator)
             sig1 = self.function_type(item.func)
             for j, item2 in enumerate(defn.items[i + 1:]):
                 # TODO overloads involving decorators
+                assert isinstance(item2, Decorator)
                 sig2 = self.function_type(item2.func)
                 if is_unsafe_overlapping_signatures(sig1, sig2):
                     self.msg.overloaded_signatures_overlap(i + 1, i + j + 2,
@@ -300,11 +307,12 @@ def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
                 else:
                     assert False, "Impl isn't the right type"
                 # This can happen if we've got an overload with a different
-                # decorator too. Just try not to crash.
+                # decorator too -- we gave up on the types.
                 if impl_type is None or sig1 is None:
                     return
-                assert isinstance(impl_type, CallableType) and isinstance(sig1, CallableType), "oops {}".format(impl_type)
 
+                assert isinstance(impl_type, CallableType)
+                assert isinstance(sig1, CallableType)
                 if not is_callable_subtype(impl_type, sig1, ignore_return=True):
                     self.msg.overloaded_signatures_arg_specific(i + 1, defn.impl)
                 if not is_subtype(sig1.ret_type, impl_type.ret_type):
@@ -2097,7 +2105,8 @@ def check_incompatible_property_override(self, e: Decorator) -> None:
                     continue
                 if (isinstance(base_attr.node, OverloadedFuncDef) and
                         base_attr.node.is_property and
-                        base_attr.node.items[0].var.is_settable_property):
+                        cast(Decorator,
+                             base_attr.node.items[0]).var.is_settable_property):
                     self.fail(messages.READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE, e)
 
     def visit_with_stmt(self, s: WithStmt) -> None:

mypy/checkmember.py

@@ -75,7 +75,8 @@ def analyze_member_access(name: str,
         if method:
             if method.is_property:
                 assert isinstance(method, OverloadedFuncDef)
-                return analyze_var(name, method.items[0].var, typ, info, node, is_lvalue, msg,
+                first_item = cast(Decorator, method.items[0])
+                return analyze_var(name, first_item.var, typ, info, node, is_lvalue, msg,
                                    original_type, not_ready_callback)
             if is_lvalue:
                 msg.cant_assign_to_method(node)

mypy/fastparse.py

@@ -6,7 +6,8 @@
     special_function_elide_names, argument_elide_name, is_overload_part,
 )
 from mypy.nodes import (
-    MypyFile, Node, ImportBase, Import, ImportAll, ImportFrom, FuncDef, OverloadedFuncDef,
+    MypyFile, Node, ImportBase, Import, ImportAll, ImportFrom, FuncDef,
+    OverloadedFuncDef, OverloadPart,
     ClassDef, Decorator, Block, Var, OperatorAssignmentStmt,
     ExpressionStmt, AssignmentStmt, ReturnStmt, RaiseStmt, AssertStmt,
     DelStmt, BreakStmt, ContinueStmt, PassStmt, GlobalDecl,
@@ -213,32 +214,23 @@ def as_block(self, stmts: List[ast3.stmt], lineno: int) -> Block:
 
     def fix_function_overloads(self, stmts: List[Statement]) -> List[Statement]:
         ret = []  # type: List[Statement]
-        current_overload = []  # type: List[Decorator]
+        current_overload = []  # type: List[OverloadPart]
         current_overload_name = None
-        # mypy doesn't actually check that the decorator is literally @overload
         for stmt in stmts:
             if (isinstance(stmt, Decorator)
                     and stmt.name() == current_overload_name):
                 current_overload.append(stmt)
             elif (isinstance(stmt, FuncDef)
-                  and not self.is_stub
                   and stmt.name() == current_overload_name
                   and stmt.name() is not None):
-                ret.append(OverloadedFuncDef(current_overload, stmt))
+                ret.append(OverloadedFuncDef(current_overload + [stmt]))
                 current_overload = []
                 current_overload_name = None
             else:
                 if len(current_overload) == 1:
                     ret.append(current_overload[0])
                 elif len(current_overload) > 1:
-                    if self.is_stub:
-                        ret.append(OverloadedFuncDef(current_overload, None))
-                    else:
-                        # Outside of a stub file, the last definition of the
-                        # overload is the implementation, even if it has a
-                        # decorator.  We will check it later to make sure it
-                        # does *not* have the @overload decorator.
-                        ret.append(OverloadedFuncDef(current_overload[:-1], current_overload[-1]))
+                    ret.append(OverloadedFuncDef(current_overload))
 
                 if isinstance(stmt, Decorator):
                     current_overload = [stmt]
@@ -251,10 +243,7 @@ def fix_function_overloads(self, stmts: List[Statement]) -> List[Statement]:
         if len(current_overload) == 1:
             ret.append(current_overload[0])
         elif len(current_overload) > 1:
-            if self.is_stub:
-                ret.append(OverloadedFuncDef(current_overload, None))
-            else:
-                ret.append(OverloadedFuncDef(current_overload[:-1], current_overload[-1]))
+            ret.append(OverloadedFuncDef(current_overload))
         return ret
 
     def in_class(self) -> bool:

mypy/fastparse2.py

@@ -33,7 +33,7 @@
     UnaryExpr, FuncExpr, ComparisonExpr, DictionaryComprehension,
     SetComprehension, ComplexExpr, EllipsisExpr, YieldExpr, Argument,
     Expression, Statement, BackquoteExpr, PrintStmt, ExecStmt,
-    ARG_POS, ARG_OPT, ARG_STAR, ARG_NAMED, ARG_STAR2
+    ARG_POS, ARG_OPT, ARG_STAR, ARG_NAMED, ARG_STAR2, OverloadPart,
 )
 from mypy.types import (
     Type, CallableType, AnyType, UnboundType, EllipsisType
@@ -220,33 +220,23 @@ def as_block(self, stmts: List[ast27.stmt], lineno: int) -> Block:
 
     def fix_function_overloads(self, stmts: List[Statement]) -> List[Statement]:
         ret = []  # type: List[Statement]
-        current_overload = []  # type: List[Decorator]
+        current_overload = []  # type: List[OverloadPart]
         current_overload_name = None
-        # mypy doesn't actually check that the decorator is literally @overload
         for stmt in stmts:
             if (isinstance(stmt, Decorator)
-                    and is_overload_part(stmt)
                     and stmt.name() == current_overload_name):
                 current_overload.append(stmt)
             elif (isinstance(stmt, FuncDef)
-                  and not self.is_stub
                   and stmt.name() == current_overload_name
                   and stmt.name() is not None):
-                ret.append(OverloadedFuncDef(current_overload, stmt))
+                ret.append(OverloadedFuncDef(current_overload + [stmt]))
                 current_overload = []
                 current_overload_name = None
             else:
                 if len(current_overload) == 1:
                     ret.append(current_overload[0])
                 elif len(current_overload) > 1:
-                    if self.is_stub:
-                        ret.append(OverloadedFuncDef(current_overload, None))
-                    else:
-                        # Outside of a stub file, the last definition of the
-                        # overload is the implementation, even if it has a
-                        # decorator.  We will check it later to make sure it
-                        # does *not* have the @overload decorator.
-                        ret.append(OverloadedFuncDef(current_overload[:-1], current_overload[-1]))
+                    ret.append(OverloadedFuncDef(current_overload))
 
                 if isinstance(stmt, Decorator):
                     current_overload = [stmt]
@@ -259,11 +249,7 @@ def fix_function_overloads(self, stmts: List[Statement]) -> List[Statement]:
         if len(current_overload) == 1:
             ret.append(current_overload[0])
         elif len(current_overload) > 1:
-            if self.is_stub:
-                ret.append(OverloadedFuncDef(current_overload, None))
-            else:
-                ret.append(OverloadedFuncDef(current_overload[:-1], current_overload[-1]))
-
+            ret.append(OverloadedFuncDef(current_overload))
         return ret
 
     def in_class(self) -> bool:

mypy/nodes.py

@@ -375,16 +375,16 @@ class OverloadedFuncDef(FuncBase, SymbolNode, Statement):
     Overloaded variants must be consecutive in the source file.
     """
 
-    items = None  # type: List[Decorator]
-    impl = None  # type: Optional[FuncDef]
+    items = None  # type: List[OverloadPart]
+    impl = None  # type: Optional[OverloadPart]
 
-    def __init__(self, items: List['Decorator'], impl: Optional[Union['Decorator', 'FuncDef']] = None) -> None:
+    def __init__(self, items: List['OverloadPart']) -> None:
         self.items = items
-        self.impl = impl
+        self.impl = None
         self.set_line(items[0].line)
 
     def name(self) -> str:
-        return self.items[0].func.name()
+        return self.items[0].name()
 
     def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_overloaded_func_def(self)
@@ -401,10 +401,11 @@ def serialize(self) -> JsonDict:
     @classmethod
     def deserialize(cls, data: JsonDict) -> 'OverloadedFuncDef':
         assert data['.class'] == 'OverloadedFuncDef'
-        impl = None  # type: Optional[FuncDef]
+        res = OverloadedFuncDef([
+            cast(OverloadPart, OverloadPart.deserialize(d))
+            for d in data['items']])
         if data.get('impl') is not None:
-            impl = FuncDef.deserialize(data['impl'])
-        res = OverloadedFuncDef([Decorator.deserialize(d) for d in data['items']], impl)
+            res.impl = cast(OverloadPart, OverloadPart.deserialize(data['impl']))
         if data.get('type') is not None:
             res.type = mypy.types.Type.deserialize(data['type'])
         res._fullname = data['fullname']
@@ -511,7 +512,16 @@ def is_dynamic(self) -> bool:
         return self.type is None
 
 
-class FuncDef(FuncItem, SymbolNode, Statement):
+class OverloadPart(SymbolNode, Statement):
+    """Interface class for statments that can be part of an OverloadedFuncDef"""
+
+    is_overload = False
+
+    @abstractmethod
+    def get_body(self) -> Optional['Block']: pass
+
+
+class FuncDef(FuncItem, OverloadPart, Statement):
     """Function definition.
 
     This is a non-lambda function defined using 'def'.
@@ -541,6 +551,9 @@ def name(self) -> str:
     def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_func_def(self)
 
+    def get_body(self) -> Optional['Block']:
+        return self.body
+
     def serialize(self) -> JsonDict:
         # We're deliberating omitting arguments and storing only arg_names and
         # arg_kinds for space-saving reasons (arguments is not used in later
@@ -579,7 +592,7 @@ def deserialize(cls, data: JsonDict) -> 'FuncDef':
         return ret
 
 
-class Decorator(SymbolNode, Statement):
+class Decorator(OverloadPart, Statement):
     """A decorated function.
 
     A single Decorator object can include any number of function decorators.
@@ -588,6 +601,7 @@ class Decorator(SymbolNode, Statement):
     func = None  # type: FuncDef                # Decorated function
     decorators = None  # type: List[Expression] # Decorators, at least one  # XXX Not true
     var = None  # type: Var                     # Represents the decorated function obj
+    type = None  # type: mypy.types.Type
     is_overload = False
 
     def __init__(self, func: FuncDef, decorators: List[Expression],
@@ -600,6 +614,9 @@ def __init__(self, func: FuncDef, decorators: List[Expression],
     def name(self) -> str:
         return self.func.name()
 
+    def get_body(self) -> Optional['Block']:
+        return self.func.body
+
     def fullname(self) -> str:
         return self.func.fullname()
 

mypy/parse.py

@@ -29,7 +29,7 @@
     UnaryExpr, FuncExpr, PrintStmt, ImportBase, ComparisonExpr,
     StarExpr, YieldFromExpr, NonlocalDecl, DictionaryComprehension,
     SetComprehension, ComplexExpr, EllipsisExpr, YieldExpr, ExecStmt, Argument,
-    BackquoteExpr
+    BackquoteExpr, OverloadPart
 )
 from mypy import defaults
 from mypy import nodes
@@ -902,28 +902,15 @@ def parse_block(self, allow_type: bool = False) -> Tuple[Block, Type]:
             return node, type
 
     def try_combine_overloads(self, s: Statement, stmt: List[Statement]) -> bool:
-        if isinstance(s, Decorator) and is_overload_part(s) and stmt:
-            n = s.func.name()
-            if (isinstance(stmt[-1], Decorator)
-                    and is_overload_part(stmt[-1])
-                    and stmt[-1].func.name() == n):
-                stmt[-1] = OverloadedFuncDef([stmt[-1], s], None)
+        if isinstance(s, OverloadPart) and stmt:
+            n = s.name()
+            if (isinstance(stmt[-1], OverloadPart)
+                    and stmt[-1].name() == n):
+                stmt[-1] = OverloadedFuncDef([stmt[-1], s])
                 return True
             elif isinstance(stmt[-1], OverloadedFuncDef) and stmt[-1].name() == n:
                 stmt[-1].items.append(s)
                 return True
-        elif isinstance(s, FuncDef) and stmt:
-            n = s.name()
-            if (isinstance(stmt[-1], Decorator)
-                    and is_overload_part(stmt[-1])
-                    and stmt[-1].func.name() == n):
-                stmt[-1] = OverloadedFuncDef([stmt[-1]], s)
-                return True
-            elif (isinstance(stmt[-1], OverloadedFuncDef)
-                  and stmt[-1].impl is None
-                  and stmt[-1].name() == n):
-                stmt[-1].impl = s
-                return True
         return False
 
     def parse_statement(self) -> Tuple[Statement, bool]: