rephrase message; test tuple parameter; use call to check

Author: elazarg

mypy/checker.py

@@ -740,9 +740,7 @@ def is_implicit_any(t: Type) -> bool:
 
                 # Type check initialization expressions.
                 for arg in item.arguments:
-                    init = arg.initialization_statement
-                    if init:
-                        self.accept(init)
+                    self.expr_checker.check_default_arg(arg)
 
             # Type check body in a new scope.
             with self.binder.top_frame_context():

mypy/checkexpr.py

@@ -3,7 +3,7 @@
 from collections import OrderedDict
 from typing import cast, Dict, Set, List, Tuple, Callable, Union, Optional
 
-from mypy.errors import report_internal_error
+from mypy.errors import Errors, report_internal_error
 from mypy.typeanal import has_any_from_unimported_type, check_for_explicit_any, set_any_tvars
 from mypy.types import (
     Type, AnyType, CallableType, Overloaded, NoneTyp, TypeVarDef,
@@ -1011,6 +1011,20 @@ def check_arg(self, caller_type: Type, original_caller_type: Type,
             messages.incompatible_argument(n, m, callee, original_caller_type,
                                            caller_kind, context)
 
+    def check_default_arg(self, arg: mypy.nodes.Argument) -> None:
+        rvalue = arg.initializer
+        lval_type = arg.variable.type
+        if rvalue and lval_type and not (self.chk.is_stub and isinstance(rvalue, EllipsisExpr)):
+            single = CallableType([lval_type], [ARG_POS], [None],
+                                  AnyType(), self.named_type('builtins.function'))
+            msg = MessageBuilder(Errors(), self.chk.modules)
+            self.check_call(single, [rvalue], [ARG_POS], arg, arg_messages=msg)
+            if msg.is_errors():
+                rval_type = self.accept(rvalue, lval_type)
+                varname = arg.variable.name()
+                self.msg.incompatible_default_argument(
+                    varname, lval_type, rval_type, arg)
+
     def overload_call_target(self, arg_types: List[Type], arg_kinds: List[int],
                              arg_names: List[str],
                              overload: Overloaded, context: Context,

mypy/fastparse.py

@@ -139,7 +139,7 @@ def is_no_type_check_decorator(expr: ast3.expr) -> bool:
     return False
 
 
-class ASTConverter(ast3.NodeTransformer):  # type: ignore  # typeshed PR #931
+class ASTConverter(ast3.NodeTransformer):
     def __init__(self,
                  options: Options,
                  is_stub: bool,
@@ -962,7 +962,7 @@ def visit_Index(self, n: ast3.Index) -> Node:
         return self.visit(n.value)
 
 
-class TypeConverter(ast3.NodeTransformer):  # type: ignore  # typeshed PR #931
+class TypeConverter(ast3.NodeTransformer):
     def __init__(self, errors: Errors, line: int = -1) -> None:
         self.errors = errors
         self.line = line

mypy/fastparse2.py

@@ -377,9 +377,7 @@ def transform_args(self,
                        n: ast27.arguments,
                        line: int,
                        ) -> Tuple[List[Argument], List[Statement]]:
-        # TODO: remove the cast once https://github.com/python/typeshed/pull/522
-        # is accepted and synced
-        type_comments = cast(List[str], n.type_comments)  # type: ignore
+        type_comments = n.type_comments
         converter = TypeConverter(self.errors, line=line)
         decompose_stmts = []  # type: List[Statement]
 
@@ -826,7 +824,7 @@ def visit_Call(self, n: ast27.Call) -> CallExpr:
         return CallExpr(self.visit(n.func),
                         self.translate_expr_list(arg_types),
                         arg_kinds,
-                        cast("List[str]", signature))
+                        signature)
 
     # Num(object n) -- a number as a PyObject.
     @with_line

mypy/messages.py

@@ -492,6 +492,16 @@ def untyped_function_call(self, callee: CallableType, context: Context) -> Type:
         self.fail('Call to untyped function {} in typed context'.format(name), context)
         return AnyType()
 
+    def incompatible_default_argument(self, name: str, lvalue: Type, rvalue: Type,
+                                      context: Context) -> None:
+        if name.startswith('__tuple_arg_'):
+            fmt = "Incompatible default for tuple argument no' {}".format(name[12:])
+        else:
+            fmt = 'Incompatible default for argument "{}"'.format(name)
+        fmt += ' (argument has type {}, default has type {})'
+        lvalt, rvalt = self.format_distinctly(lvalue, rvalue)
+        self.fail(fmt.format(lvalt, rvalt), context)
+
     def incompatible_argument(self, n: int, m: int, callee: CallableType, arg_type: Type,
                               arg_kind: int, context: Context) -> None:
         """Report an error about an incompatible argument type.

mypy/semanal.py

@@ -1377,7 +1377,23 @@ def visit_import_from(self, imp: ImportFrom) -> None:
                     self.add_submodules_to_parent_modules(possible_module_id, True)
                 elif possible_module_id in self.missing_modules:
                     missing = True
-
+            # If it is still not resolved, and the module is a stub
+            # check for a module level __getattr__
+            if module and not node and module.is_stub and '__getattr__' in module.names:
+                getattr_defn = module.names['__getattr__']
+                if isinstance(getattr_defn.node, FuncDef):
+                    if isinstance(getattr_defn.node.type, CallableType):
+                        typ = getattr_defn.node.type.ret_type
+                    else:
+                        typ = AnyType()
+                    if as_id:
+                        name = as_id
+                    else:
+                        name = id
+                    ast_node = Var(name, type=typ)
+                    symbol = SymbolTableNode(GDEF, ast_node, name)
+                    self.add_symbol(name, symbol, imp)
+                    return
             if node and node.kind != UNBOUND_IMPORTED:
                 node = self.normalize_type_alias(node, imp)
                 if not node:
@@ -4278,8 +4294,7 @@ def consider_sys_version_info(expr: Expression, pyversion: Tuple[int, ...]) -> i
         else:
             return TRUTH_VALUE_UNKNOWN
     elif isinstance(index, tuple) and isinstance(thing, tuple):
-        # Why doesn't mypy see that index can't be None here?
-        lo, hi = cast(Tuple[Optional[int], Optional[int]], index)
+        lo, hi = index
         if lo is None:
             lo = 0
         if hi is None:

mypy/types.py

@@ -1762,7 +1762,7 @@ def function_type(func: mypy.nodes.FuncBase, fallback: Instance) -> FunctionLike
         # 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(cast(mypy.nodes.FuncItem, func), fallback)
+        return callable_type(func, fallback)
 
 
 def callable_type(fdef: mypy.nodes.FuncItem, fallback: Instance,

mypy_self_check.ini

@@ -5,6 +5,8 @@ warn_no_return = True
 strict_optional = True
 no_implicit_optional = True
 disallow_any = generics, unimported
+warn_redundant_casts = True
+warn_unused_ignores = True
 
 ; historical exceptions
 [mypy-mypy.binder]

test-data/unit/check-functions.test

@@ -388,17 +388,42 @@ class A: pass
 
 [case testDefaultArgumentExpressions2]
 import typing
-def f(x: 'A' = B()) -> None: # E: Incompatible types in assignment (expression has type "B", variable has type "A")
+def f(x: 'A' = B()) -> None: # E: Incompatible default for argument "x" (argument has type "A", default has type "B")
     b = x # type: B      # E: Incompatible types in assignment (expression has type "A", variable has type "B")
     a = x # type: A
 
 class B: pass
 class A: pass
-[out]
+
+[case testDefaultArgumentExpressionsGeneric]
+from typing import TypeVar
+T = TypeVar('T', bound='A')
+def f(x: T = B()) -> None: # E: Incompatible default for argument "x" (argument has type "T", default has type "B")
+    b = x # type: B      # E: Incompatible types in assignment (expression has type "T", variable has type "B")
+    a = x # type: A
+
+class B: pass
+class A: pass
+
+[case testDefaultArgumentExpressionsPython2]
+# flags: --python-version 2.7
+from typing import Tuple
+def f(x = B()): # E: Incompatible default for argument "x" (argument has type "A", default has type "B")
+    # type: (A) -> None
+    b = x # type: B      # E: Incompatible types in assignment (expression has type "A", variable has type "B")
+    a = x # type: A
+
+def g((x, y) = (A(), B())): # E: Incompatible default for tuple argument no' 1 (argument has type "Tuple[B, B]", default has type "Tuple[A, B]")
+    # type: ( Tuple[B, B] ) -> None
+    b = x # type: B
+    a = x # type: A      # E: Incompatible types in assignment (expression has type "B", variable has type "A")
+
+class B: pass
+class A: pass
 
 [case testDefaultArgumentsWithSubtypes]
 import typing
-def f(x: 'B' = A()) -> None: # E: Incompatible types in assignment (expression has type "A", variable has type "B")
+def f(x: 'B' = A()) -> None: # E: Incompatible default for argument "x" (argument has type "B", default has type "A")
     pass
 def g(x: 'A' = B()) -> None:
     pass
@@ -409,7 +434,7 @@ class B(A): pass
 
 [case testMultipleDefaultArgumentExpressions]
 import typing
-def f(x: 'A' = B(), y: 'B' = B()) -> None: # E: Incompatible types in assignment (expression has type "B", variable has type "A")
+def f(x: 'A' = B(), y: 'B' = B()) -> None: # E: Incompatible default for argument "x" (argument has type "A", default has type "B")
     pass
 def h(x: 'A' = A(), y: 'B' = B()) -> None:
     pass
@@ -420,7 +445,7 @@ class B: pass
 
 [case testMultipleDefaultArgumentExpressions2]
 import typing
-def g(x: 'A' = A(), y: 'B' = A()) -> None: # E: Incompatible types in assignment (expression has type "A", variable has type "B")
+def g(x: 'A' = A(), y: 'B' = A()) -> None: # E: Incompatible default for argument "y" (argument has type "B", default has type "A")
     pass
 
 class A: pass

test-data/unit/check-inference.test

@@ -1119,7 +1119,7 @@ from typing import Callable
 def f(a: Callable[..., None] = lambda *a, **k: None):
     pass
 
-def g(a: Callable[..., None] = lambda *a, **k: 1):  # E: Incompatible types in assignment (expression has type Callable[[VarArg(Any), KwArg(Any)], int], variable has type Callable[..., None])
+def g(a: Callable[..., None] = lambda *a, **k: 1):  # E: Incompatible default for argument "a" (argument has type Callable[..., None], default has type Callable[[VarArg(Any), KwArg(Any)], int])
     pass
 [builtins fixtures/dict.pyi]
 

test-data/unit/check-modules.test

@@ -475,11 +475,11 @@ def f(x: int = ...) -> None: pass
 [file m.pyi]
 def g(x: int = '') -> None: pass
 [out]
-tmp/m.pyi:1: error: Incompatible types in assignment (expression has type "str", variable has type "int")
-main:2: error: Incompatible types in assignment (expression has type "ellipsis", variable has type "int")
+tmp/m.pyi:1: error: Incompatible default for argument "x" (argument has type "int", default has type "str")
+main:2: error: Incompatible default for argument "x" (argument has type "int", default has type "ellipsis")
 
 [case testEllipsisDefaultArgValueInNonStub]
-def f(x: int = ...) -> None: pass # E: Incompatible types in assignment (expression has type "ellipsis", variable has type "int")
+def f(x: int = ...) -> None: pass # E: Incompatible default for argument "x" (argument has type "int", default has type "ellipsis")
 [out]
 
 [case testStarImportOverlapping]
@@ -1766,3 +1766,53 @@ main:3: error: Module has no attribute "any_attribute"
 [case testModuleLevelGetattribute]
 
 def __getattribute__(): ...  # E: __getattribute__ is not valid at the module level
+
+[case testModuleLevelGetattrImportFrom]
+from has_attr import name
+reveal_type(name)  # E: Revealed type is 'Any'
+
+[file has_attr.pyi]
+from typing import Any
+def __getattr__(name: str) -> Any: ...
+
+[builtins fixtures/module.pyi]
+
+[case testModuleLevelGetattrImportFromRetType]
+from has_attr import int_attr
+reveal_type(int_attr)  # E: Revealed type is 'builtins.int'
+
+[file has_attr.pyi]
+def __getattr__(name: str) -> int: ...
+
+[builtins fixtures/module.pyi]
+
+[case testModuleLevelGetattrImportFromNotStub]
+from non_stub import name
+reveal_type(name)
+
+[file non_stub.py]
+from typing import Any
+def __getattr__(name: str) -> Any: ...
+
+[out]
+tmp/non_stub.py:2: error: __getattr__ is not valid at the module level outside a stub file
+main:1: error: Module 'non_stub' has no attribute 'name'
+main:2: error: Revealed type is 'Any'
+
+[builtins fixtures/module.pyi]
+
+[case testModuleLevelGetattrImportFromAs]
+from has_attr import name as n
+reveal_type(name)
+reveal_type(n)
+
+[file has_attr.pyi]
+from typing import Any
+def __getattr__(name: str) -> Any: ...
+
+[out]
+main:2: error: Revealed type is 'Any'
+main:2: error: Name 'name' is not defined
+main:3: error: Revealed type is 'Any'
+
+[builtins fixtures/module.pyi]

test-data/unit/check-optional.test

@@ -127,7 +127,7 @@ f(None)
 
 [case testNoInferOptionalFromDefaultNone]
 # flags: --no-implicit-optional
-def f(x: int = None) -> None:  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+def f(x: int = None) -> None:  # E: Incompatible default for argument "x" (argument has type "int", default has type None)
   pass
 [out]
 
@@ -140,7 +140,7 @@ f(None)
 
 [case testNoInferOptionalFromDefaultNoneComment]
 # flags: --no-implicit-optional
-def f(x=None):  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+def f(x=None):  # E: Incompatible default for argument "x" (argument has type "int", default has type None)
   # type: (int) -> None
   pass
 [out]