fix method name

python · JukkaL · Sep 2, 2016 · Jul 6, 2016 · Jul 6, 2016 · Jul 6, 2016
commit eb6534e434f41be68989b16af8a47a3bbee5ea64
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -1221,8 +1221,7 @@ def visit_tuple_slice_helper(self, left_type: TupleType, slic: SliceExpr):
                     slic.stride)
                 return AnyType()
 
-        return TupleType(left_type.items[begin:end:stride], left_type.fallback,
-                    left_type.line, left_type.implicit)
+        return left_type.slice(begin, stride, end)
 
     def _get_value(self, index: Node) -> Optional[int]:
         if isinstance(index, IntExpr):

diff --git a/mypy/expandtype.py b/mypy/expandtype.py
@@ -88,7 +88,7 @@ def visit_overloaded(self, t: Overloaded) -> Type:
         return Overloaded(items)
 
     def visit_tuple_type(self, t: TupleType) -> Type:
-        return TupleType(self.expand_types(t.items), t.fallback, t.line)
+        return t.with_types(self.expand_types(t.items))
 
     def visit_union_type(self, t: UnionType) -> Type:
         # After substituting for type variables in t.items,

diff --git a/mypy/messages.py b/mypy/messages.py
@@ -486,7 +486,7 @@ def incompatible_argument(self, n: int, m: int, callee: CallableType, arg_type:
             except IndexError:  # Varargs callees
                 expected_type = callee.arg_types[-1]
             arg_type_str, expected_type_str = self.format_distinctly(arg_type, expected_type)
-            import pdb; pdb.set_trace()
+            #import pdb; pdb.set_trace()
             if arg_kind == ARG_STAR:
                 arg_type_str = '*' + arg_type_str
             elif arg_kind == ARG_STAR2:

diff --git a/mypy/nodes.py b/mypy/nodes.py
@@ -1977,7 +1977,7 @@ def deserialize(cls, data: JsonDict) -> 'TypeInfo':
         return ti
 
 
-def NamedTupleTypeInfo(tup: 'mypy.types.NamedTupleType', *args) -> None:
+def NamedTupleTypeInfo(tup: 'mypy.types.NamedTupleType', *args) -> TypeInfo:
     info = TypeInfo(*args)
     info.tuple_type = tup
     info.bases = [tup.fallback]

diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -1543,7 +1543,7 @@ def build_namedtuple_typeinfo(self, name: str, items: List[str],
         self.add_namedtuple_method('_replace', symbols, info, this_type, this_type,
                                    self.make_factory_args(vars, ARG_NAMED, initializer=EllipsisExpr()))
         self.add_namedtuple_method('__init__', symbols, info, this_type, NoneTyp(),
-                                   self.make_factory_args(vars, ARG_NAMED))
+                                   self.make_factory_args(vars, ARG_POS), info.name())
         # TODO: refine to OrderedDict[Union[types]]
         self.add_namedtuple_method('_asdict', symbols, info, this_type, AnyType(), [])
         return info
@@ -1553,15 +1553,15 @@ def make_factory_args(self, vars: List[Var], kind: int,
         return [Argument(var, var.type, initializer, kind) for var in vars]
 
     def add_namedtuple_method(self, funcname: str, symbols: SymbolTable, info: TypeInfo,
-                              this_type: Type, ret: Type, args: List[Argument]) -> None:
+                              this_type: Type, ret: Type, args: List[Argument], name=None) -> None:
         args = [Argument(Var('self'), this_type, None, ARG_POS)] + args
         types = [arg.type_annotation for arg in args]
         items = [arg.variable.name() for arg in args]
         arg_kinds = [arg.kind for arg in args]
         # TODO: Make sure that the self argument name is not visible?
         signature = CallableType(types, arg_kinds, items, ret,
                                  self.named_type('__builtins__.function'),
-                                 name=info.name())
+                                 name=name or info.name() + '.' + funcname)
         func = FuncDef(funcname,
                        args,
                        Block([]),

diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -193,6 +193,7 @@ def visit_tuple_type(self, left: TupleType) -> bool:
             return False
 
     def visit_namedtuple_type(self, left: NamedTupleType) -> bool:
+        #import pdb; pdb.set_trace()
         if isinstance(self.right, NamedTupleType):
             # left.attrs.issubset(right.attrs) is insufficient
             # (a: int, b: str) is not subtype of (b: int, a: str)

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -171,7 +171,7 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                         return AnyType()
                     # import pdb; pdb.set_trace()
                     if info.is_named_tuple:
-                        return NamedTupleType(info.name, info.attrs, 
+                        return NamedTupleType(info.name(), info.attrs, 
                                               self.anal_array(info.tuple_type.items),
                                               fallback=instance,
                                               line=t.line)

diff --git a/mypy/types.py b/mypy/types.py
@@ -762,7 +762,14 @@ def deserialize(cls, data: JsonDict) -> 'TupleType':
                          implicit=data['implicit'])
 
     def self_type(self, inst: Instance) -> 'TupleType':
-        return TupleType(self.items, inst)
+        return TupleType(self.items, inst, self.line, self.implicit)
+
+    def with_types(self, items: List[Type]) -> 'TupleType':
+        return TupleType(items, self.fallback, self.line, self.implicit)
+
+    def slice(self, begin: int, stride: int, end: int) -> 'TupleType':
+        return TupleType(self.items[begin:end:stride], self.fallback,
+                         self.line, self.implicit)
 
 
 class NamedTupleType(TupleType):
@@ -775,7 +782,11 @@ def __init__(self, name: str, attrs: List[str], *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
     def self_type(self, inst: Instance) -> 'NamedTupleType':
-        return NamedTupleType(self.name, self.attrs, self.items, inst)
+        return NamedTupleType(self.name, self.attrs, self.items, inst, self.line)
+
+    def with_types(self, items: List[Type]) -> 'NamedTupleType':
+        return NamedTupleType(self.name, self.attrs, items,
+                              self.fallback, self.line, self.implicit)
 
     def accept(self, visitor: 'TypeVisitor[T]') -> T:
         try:

diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test
@@ -143,9 +143,9 @@ class B(A): pass
 a = A(1, '')
 b = B(1, '')
 t = None  # type: Tuple[int, str]
-b = a # E: Incompatible types in assignment (expression has type "A", variable has type "B")
-a = t # E: Incompatible types in assignment (expression has type "Tuple[int, str]", variable has type "A")
-b = t # E: Incompatible types in assignment (expression has type "Tuple[int, str]", variable has type "B")
+b = a  # E: Incompatible types in assignment (expression has type "A", variable has type "B")
+a = t  # E: Incompatible types in assignment (expression has type "Tuple[int, str]", variable has type "A")
+b = t  # E: Incompatible types in assignment (expression has type "Tuple[int, str]", variable has type "B")
 t = a
 t = (1, '')
 t = b
@@ -199,8 +199,8 @@ from collections import namedtuple
 X = namedtuple('X', ['x', 'y'])
 x = None  # type: X
 x = x._replace(y=5)
-x = x._replace(z=5)  # E: Unexpected keyword argument "z" for X
-x = x._replace(5)  # E: Too many positional arguments for X
+x = x._replace(z=5)  # E: Unexpected keyword argument "z" for X._replace
+x = x._replace(5)  # E: Too many positional arguments for X._replace
 
 [case testNamedTupleReplaceAsClass]
 from collections import namedtuple
@@ -216,4 +216,4 @@ from typing import NamedTuple
 X = NamedTuple('X', [('x', int), ('y', str)])
 x = None  # type: X
 x = x._replace(x=5)
-x = x._replace(y=5)  # E: Argument 1 to X has incompatible type "int"; expected "str"
+x = x._replace(y=5)  # E: Argument 1 to X._replace has incompatible type "int"; expected "str"
diff --git a/test-data/unit/check-tuples.test b/test-data/unit/check-tuples.test
@@ -2,7 +2,7 @@
 -- -------------------------------
 
 
-[case testAssignmentWithTupleTypes]
+[case testTupleAssignmentWithTupleTypes]
 from typing import Tuple
 t1 = None # type: Tuple[A]
 t2 = None # type: Tuple[B]