New semantic analyzer: fix type promotions special cases (#6609)

Set up type promotions after the main semantic analyzer pass to
avoid the need to defer. This fixes an issue with test stubs,
but the existing approach probably worked with typeshed.
Another benefit of this approach is that things are easier to
reason about, as the main semantic analysis pass is a bit
simpler.

This fixes the testDivmod type checker test case.

Author: JukkaL

mypy/checkexpr.py

@@ -2260,7 +2260,7 @@ def check_op(self, method: str, base_type: Type,
 
             # Step 1: We first try leaving the right arguments alone and destructure
             # just the left ones. (Mypy can sometimes perform some more precise inference
-            # if we leave the right operands a union -- see testOperatorWithEmptyListAndSum.
+            # if we leave the right operands a union -- see testOperatorWithEmptyListAndSum.)
             msg = self.msg.clean_copy()
             msg.disable_count = 0
             all_results = []

mypy/newsemanal/semanal.py

@@ -127,36 +127,6 @@
     'typing.typevar': 'typing.TypeVar',
 }  # type: Final
 
-# Hard coded type promotions (shared between all Python versions).
-# These add extra ad-hoc edges to the subtyping relation. For example,
-# int is considered a subtype of float, even though there is no
-# subclass relationship.
-TYPE_PROMOTIONS = {
-    'builtins.int': 'builtins.float',
-    'builtins.float': 'builtins.complex',
-}  # type: Final
-
-# Hard coded type promotions for Python 3.
-#
-# Note that the bytearray -> bytes promotion is a little unsafe
-# as some functions only accept bytes objects. Here convenience
-# trumps safety.
-TYPE_PROMOTIONS_PYTHON3 = TYPE_PROMOTIONS.copy()  # type: Final
-TYPE_PROMOTIONS_PYTHON3.update({
-    'builtins.bytearray': 'builtins.bytes',
-})
-
-# Hard coded type promotions for Python 2.
-#
-# These promotions are unsafe, but we are doing them anyway
-# for convenience and also for Python 3 compatibility
-# (bytearray -> str).
-TYPE_PROMOTIONS_PYTHON2 = TYPE_PROMOTIONS.copy()  # type: Final
-TYPE_PROMOTIONS_PYTHON2.update({
-    'builtins.str': 'builtins.unicode',
-    'builtins.bytearray': 'builtins.str',
-})
-
 # Map from the full name of a missing definition to the test fixture (under
 # test-data/unit/fixtures/) that provides the definition. This is used for
 # generating better error messages when running mypy tests only.
@@ -918,7 +888,6 @@ def analyze_class(self, defn: ClassDef) -> None:
             for decorator in defn.decorators:
                 self.analyze_class_decorator(defn, decorator)
             self.analyze_class_body_common(defn)
-            self.setup_type_promotion(defn)
 
     def is_core_builtin_class(self, defn: ClassDef) -> bool:
         return self.cur_mod_id == 'builtins' and defn.name in CORE_BUILTIN_CLASSES
@@ -1017,25 +986,6 @@ def analyze_class_decorator(self, defn: ClassDef, decorator: Expression) -> None
                                         'typing_extensions.final'):
                 defn.info.is_final = True
 
-    def setup_type_promotion(self, defn: ClassDef) -> None:
-        """Setup extra, ad-hoc subtyping relationships between classes (promotion).
-
-        This includes things like 'int' being compatible with 'float'.
-        """
-        promote_target = None  # type: Optional[Type]
-        for decorator in defn.decorators:
-            if isinstance(decorator, CallExpr):
-                analyzed = decorator.analyzed
-                if isinstance(analyzed, PromoteExpr):
-                    # _promote class decorator (undocumented feature).
-                    promote_target = analyzed.type
-        if not promote_target:
-            promotions = (TYPE_PROMOTIONS_PYTHON3 if self.options.python_version[0] >= 3
-                          else TYPE_PROMOTIONS_PYTHON2)
-            if defn.fullname in promotions:
-                promote_target = self.named_type_or_none(promotions[defn.fullname])
-        defn.info._promote = promote_target
-
     def clean_up_bases_and_infer_type_variables(
             self,
             defn: ClassDef,

mypy/newsemanal/semanal_classprop.py

@@ -5,9 +5,47 @@
 
 from typing import List, Set, Optional
 
-from mypy.nodes import Node, TypeInfo, Var, Decorator, OverloadedFuncDef
-from mypy.types import Instance
+from mypy.nodes import (
+    Node, TypeInfo, Var, Decorator, OverloadedFuncDef, SymbolTable, CallExpr, PromoteExpr,
+)
+from mypy.types import Instance, Type
 from mypy.errors import Errors
+from mypy.options import Options
+
+MYPY = False
+if MYPY:
+    from typing_extensions import Final
+
+
+# Hard coded type promotions (shared between all Python versions).
+# These add extra ad-hoc edges to the subtyping relation. For example,
+# int is considered a subtype of float, even though there is no
+# subclass relationship.
+TYPE_PROMOTIONS = {
+    'builtins.int': 'float',
+    'builtins.float': 'complex',
+}  # type: Final
+
+# Hard coded type promotions for Python 3.
+#
+# Note that the bytearray -> bytes promotion is a little unsafe
+# as some functions only accept bytes objects. Here convenience
+# trumps safety.
+TYPE_PROMOTIONS_PYTHON3 = TYPE_PROMOTIONS.copy()  # type: Final
+TYPE_PROMOTIONS_PYTHON3.update({
+    'builtins.bytearray': 'bytes',
+})
+
+# Hard coded type promotions for Python 2.
+#
+# These promotions are unsafe, but we are doing them anyway
+# for convenience and also for Python 3 compatibility
+# (bytearray -> str).
+TYPE_PROMOTIONS_PYTHON2 = TYPE_PROMOTIONS.copy()  # type: Final
+TYPE_PROMOTIONS_PYTHON2.update({
+    'builtins.str': 'unicode',
+    'builtins.bytearray': 'str',
+})
 
 
 def calculate_class_abstract_status(typ: TypeInfo, is_stub_file: bool, errors: Errors) -> None:
@@ -94,3 +132,29 @@ def calculate_class_vars(info: TypeInfo) -> None:
                         and isinstance(member.node, Var)
                         and member.node.is_classvar):
                     node.is_classvar = True
+
+
+def add_type_promotion(info: TypeInfo, module_names: SymbolTable, options: Options) -> None:
+    """Setup extra, ad-hoc subtyping relationships between classes (promotion).
+
+    This includes things like 'int' being compatible with 'float'.
+    """
+    defn = info.defn
+    promote_target = None  # type: Optional[Type]
+    for decorator in defn.decorators:
+        if isinstance(decorator, CallExpr):
+            analyzed = decorator.analyzed
+            if isinstance(analyzed, PromoteExpr):
+                # _promote class decorator (undocumented feature).
+                promote_target = analyzed.type
+    if not promote_target:
+        promotions = (TYPE_PROMOTIONS_PYTHON3 if options.python_version[0] >= 3
+                      else TYPE_PROMOTIONS_PYTHON2)
+        if defn.fullname in promotions:
+            target_sym = module_names.get(promotions[defn.fullname])
+            # With test stubs, the target may not exist.
+            if target_sym:
+                target_info = target_sym.node
+                assert isinstance(target_info, TypeInfo)
+                promote_target = Instance(target_info, [])
+    defn.info._promote = promote_target

mypy/newsemanal/semanal_main.py

@@ -36,7 +36,8 @@
     NewSemanticAnalyzer, apply_semantic_analyzer_patches, remove_imported_names_from_symtable
 )
 from mypy.newsemanal.semanal_classprop import (
-    calculate_class_abstract_status, calculate_class_vars, check_protocol_status
+    calculate_class_abstract_status, calculate_class_vars, check_protocol_status,
+    add_type_promotion
 )
 from mypy.errors import Errors
 from mypy.newsemanal.semanal_infer import infer_decorator_signature_if_simple
@@ -327,6 +328,7 @@ def calculate_class_properties(graph: 'Graph', scc: List[str], errors: Errors) -
                     calculate_class_abstract_status(node.node, tree.is_stub, errors)
                     check_protocol_status(node.node, errors)
                     calculate_class_vars(node.node)
+                    add_type_promotion(node.node, tree.names, graph[module].options)
 
 
 def check_blockers(graph: 'Graph', scc: List[str]) -> None:

mypy/test/hacks.py

@@ -8,7 +8,6 @@
 # Files to not run with new semantic analyzer.
 new_semanal_blacklist = [
     'check-async-await.test',
-    'check-expressions.test',
     'check-flags.test',
     'check-incremental.test',
     'check-literal.test',