Merge branch 'master' into refine-unreachable-checks-against-with

Author: ilevkivskyi

docs/source/getting_started.rst

@@ -158,7 +158,7 @@ Arguments with default values can be annotated like so:
        # 'args' has type 'Tuple[int, ...]' (a tuple of ints)
        # 'kwargs' has type 'Dict[str, float]' (a dict of strs to floats)
        for arg in args:
-           print(name)
+           print(arg)
        for key, value in kwargs:
            print(key, value)
 

misc/proper_plugin.py

@@ -0,0 +1,70 @@
+from mypy.plugin import Plugin, FunctionContext
+from mypy.types import Type, Instance, CallableType, UnionType, get_proper_type
+
+import os.path
+from typing_extensions import Type as typing_Type
+from typing import Optional, Callable
+
+FILE_WHITELIST = [
+    'checker.py',
+    'checkexpr.py',
+    'checkmember.py',
+    'messages.py',
+    'semanal.py',
+    'typeanal.py'
+]
+
+
+class ProperTypePlugin(Plugin):
+    """
+    A plugin to ensure that every type is expanded before doing any special-casing.
+
+    This solves the problem that we have hundreds of call sites like:
+
+        if isinstance(typ, UnionType):
+            ...  # special-case union
+
+    But after introducing a new type TypeAliasType (and removing immediate expansion)
+    all these became dangerous because typ may be e.g. an alias to union.
+    """
+    def get_function_hook(self, fullname: str
+                          ) -> Optional[Callable[[FunctionContext], Type]]:
+        if fullname == 'builtins.isinstance':
+            return isinstance_proper_hook
+        return None
+
+
+def isinstance_proper_hook(ctx: FunctionContext) -> Type:
+    if os.path.split(ctx.api.path)[-1] in FILE_WHITELIST:
+        return ctx.default_return_type
+    for arg in ctx.arg_types[0]:
+        if is_improper_type(arg):
+            right = get_proper_type(ctx.arg_types[1][0])
+            if isinstance(right, CallableType) and right.is_type_obj():
+                if right.type_object().fullname() in ('mypy.types.Type',
+                                                      'mypy.types.ProperType',
+                                                      'mypy.types.TypeAliasType'):
+                    # Special case: things like assert isinstance(typ, ProperType) are always OK.
+                    return ctx.default_return_type
+                if right.type_object().fullname() in ('mypy.types.UnboundType',
+                                                      'mypy.types.TypeVarType'):
+                    # Special case: these are not valid targets for a type alias and thus safe.
+                    return ctx.default_return_type
+            ctx.api.fail('Never apply isinstance() to unexpanded types;'
+                         ' use mypy.types.get_proper_type() first', ctx.context)
+    return ctx.default_return_type
+
+
+def is_improper_type(typ: Type) -> bool:
+    """Is this a type that is not a subtype of ProperType?"""
+    typ = get_proper_type(typ)
+    if isinstance(typ, Instance):
+        info = typ.type
+        return info.has_base('mypy.types.Type') and not info.has_base('mypy.types.ProperType')
+    if isinstance(typ, UnionType):
+        return any(is_improper_type(t) for t in typ.items)
+    return False
+
+
+def plugin(version: str) -> typing_Type[ProperTypePlugin]:
+    return ProperTypePlugin

mypy/applytype.py

@@ -3,7 +3,9 @@
 import mypy.subtypes
 import mypy.sametypes
 from mypy.expandtype import expand_type
-from mypy.types import Type, TypeVarId, TypeVarType, CallableType, AnyType, PartialType
+from mypy.types import (
+    Type, TypeVarId, TypeVarType, CallableType, AnyType, PartialType, get_proper_types
+)
 from mypy.messages import MessageBuilder
 from mypy.nodes import Context
 
@@ -25,10 +27,10 @@ def apply_generic_arguments(callable: CallableType, orig_types: Sequence[Optiona
     assert len(tvars) == len(orig_types)
     # Check that inferred type variable values are compatible with allowed
     # values and bounds.  Also, promote subtype values to allowed values.
-    types = list(orig_types)
+    types = get_proper_types(orig_types)
     for i, type in enumerate(types):
         assert not isinstance(type, PartialType), "Internal error: must never apply partial type"
-        values = callable.variables[i].values
+        values = get_proper_types(callable.variables[i].values)
         if type is None:
             continue
         if values:

mypy/argmap.py

@@ -2,7 +2,9 @@
 
 from typing import List, Optional, Sequence, Callable, Set
 
-from mypy.types import Type, Instance, TupleType, AnyType, TypeOfAny, TypedDictType
+from mypy.types import (
+    Type, Instance, TupleType, AnyType, TypeOfAny, TypedDictType, get_proper_type
+)
 from mypy import nodes
 
 
@@ -34,7 +36,7 @@ def map_actuals_to_formals(actual_kinds: List[int],
                     formal_to_actual[fi].append(ai)
         elif actual_kind == nodes.ARG_STAR:
             # We need to know the actual type to map varargs.
-            actualt = actual_arg_type(ai)
+            actualt = get_proper_type(actual_arg_type(ai))
             if isinstance(actualt, TupleType):
                 # A tuple actual maps to a fixed number of formals.
                 for _ in range(len(actualt.items)):
@@ -65,7 +67,7 @@ def map_actuals_to_formals(actual_kinds: List[int],
                 formal_to_actual[formal_kinds.index(nodes.ARG_STAR2)].append(ai)
         else:
             assert actual_kind == nodes.ARG_STAR2
-            actualt = actual_arg_type(ai)
+            actualt = get_proper_type(actual_arg_type(ai))
             if isinstance(actualt, TypedDictType):
                 for name, value in actualt.items.items():
                     if name in formal_names:
@@ -153,6 +155,7 @@ def expand_actual_type(self,
         This is supposed to be called for each formal, in order. Call multiple times per
         formal if multiple actuals map to a formal.
         """
+        actual_type = get_proper_type(actual_type)
         if actual_kind == nodes.ARG_STAR:
             if isinstance(actual_type, Instance):
                 if actual_type.type.fullname() == 'builtins.list':

mypy/binder.py

@@ -4,7 +4,9 @@
 from typing import Dict, List, Set, Iterator, Union, Optional, Tuple, cast
 from typing_extensions import DefaultDict
 
-from mypy.types import Type, AnyType, PartialType, UnionType, TypeOfAny, NoneType
+from mypy.types import (
+    Type, AnyType, PartialType, UnionType, TypeOfAny, NoneType, get_proper_type
+)
 from mypy.subtypes import is_subtype
 from mypy.join import join_simple
 from mypy.sametypes import is_same_type
@@ -191,7 +193,7 @@ def update_from_options(self, frames: List[Frame]) -> bool:
 
             type = resulting_values[0]
             assert type is not None
-            declaration_type = self.declarations.get(key)
+            declaration_type = get_proper_type(self.declarations.get(key))
             if isinstance(declaration_type, AnyType):
                 # At this point resulting values can't contain None, see continue above
                 if not all(is_same_type(type, cast(Type, t)) for t in resulting_values[1:]):
@@ -246,6 +248,9 @@ def assign_type(self, expr: Expression,
                     type: Type,
                     declared_type: Optional[Type],
                     restrict_any: bool = False) -> None:
+        type = get_proper_type(type)
+        declared_type = get_proper_type(declared_type)
+
         if self.type_assignments is not None:
             # We are in a multiassign from union, defer the actual binding,
             # just collect the types.
@@ -270,7 +275,7 @@ def assign_type(self, expr: Expression,
             # times?
             return
 
-        enclosing_type = self.most_recent_enclosing_type(expr, type)
+        enclosing_type = get_proper_type(self.most_recent_enclosing_type(expr, type))
         if isinstance(enclosing_type, AnyType) and not restrict_any:
             # If x is Any and y is int, after x = y we do not infer that x is int.
             # This could be changed.
@@ -287,7 +292,8 @@ def assign_type(self, expr: Expression,
         elif (isinstance(type, AnyType)
               and isinstance(declared_type, UnionType)
               and any(isinstance(item, NoneType) for item in declared_type.items)
-              and isinstance(self.most_recent_enclosing_type(expr, NoneType()), NoneType)):
+              and isinstance(get_proper_type(self.most_recent_enclosing_type(expr, NoneType())),
+                             NoneType)):
             # Replace any Nones in the union type with Any
             new_items = [type if isinstance(item, NoneType) else item
                          for item in declared_type.items]
@@ -320,6 +326,7 @@ def invalidate_dependencies(self, expr: BindableExpression) -> None:
             self._cleanse_key(dep)
 
     def most_recent_enclosing_type(self, expr: BindableExpression, type: Type) -> Optional[Type]:
+        type = get_proper_type(type)
         if isinstance(type, AnyType):
             return get_declaration(expr)
         key = literal_hash(expr)
@@ -412,7 +419,7 @@ def top_frame_context(self) -> Iterator[Frame]:
 
 def get_declaration(expr: BindableExpression) -> Optional[Type]:
     if isinstance(expr, RefExpr) and isinstance(expr.node, Var):
-        type = expr.node.type
+        type = get_proper_type(expr.node.type)
         if not isinstance(type, PartialType):
             return type
     return None

mypy/build.py

@@ -57,6 +57,7 @@
 from mypy.renaming import VariableRenameVisitor
 from mypy.config_parser import parse_mypy_comments
 from mypy.freetree import free_tree
+from mypy import errorcodes as codes
 
 
 # Switch to True to produce debug output related to fine-grained incremental
@@ -2422,14 +2423,16 @@ def module_not_found(manager: BuildManager, line: int, caller_state: State,
           or (manager.options.python_version[0] >= 3
               and moduleinfo.is_py3_std_lib_module(target))):
         errors.report(
-            line, 0, "No library stub file for standard library module '{}'".format(target))
+            line, 0, "No library stub file for standard library module '{}'".format(target),
+            code=codes.IMPORT)
         errors.report(line, 0, stub_msg, severity='note', only_once=True)
     elif moduleinfo.is_third_party_module(target):
-        errors.report(line, 0, "No library stub file for module '{}'".format(target))
+        errors.report(line, 0, "No library stub file for module '{}'".format(target),
+                      code=codes.IMPORT)
         errors.report(line, 0, stub_msg, severity='note', only_once=True)
     else:
         note = "See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports"
-        errors.report(line, 0, "Cannot find module named '{}'".format(target))
+        errors.report(line, 0, "Cannot find module named '{}'".format(target), code=codes.IMPORT)
         errors.report(line, 0, note, severity='note', only_once=True)
     errors.set_import_context(save_import_context)