Drop num_pos_only in favor of tracking pos_only in Argument

Author: msullivan

mypy/fastparse.py

@@ -522,14 +522,13 @@ def do_func_def(self, n: Union[ast3.FunctionDef, ast3.AsyncFunctionDef],
 
         lineno = n.lineno
         args = self.transform_args(n.args, lineno, no_type_check=no_type_check)
+        if special_function_elide_names(n.name):
+            for arg in args:
+                arg.pos_only = True
 
-        posonlyargs = [arg.arg for arg in getattr(n.args, "posonlyargs", [])]
         arg_kinds = [arg.kind for arg in args]
-        arg_names: List[Optional[str]] = [arg.variable.name for arg in args]
-        arg_names = [None if argument_elide_name(name) or name in posonlyargs else name
-                     for name in arg_names]
-        if special_function_elide_names(n.name):
-            arg_names = [None] * len(arg_names)
+        arg_names = [None if arg.pos_only else arg.variable.name for arg in args]
+
         arg_types: List[Optional[Type]] = []
         if no_type_check:
             arg_types = [None] * len(args)
@@ -606,8 +605,7 @@ def do_func_def(self, n: Union[ast3.FunctionDef, ast3.AsyncFunctionDef],
             n.name,
             args,
             self.as_required_block(n.body, lineno),
-            func_type,
-            num_pos_only=len(posonlyargs))
+            func_type)
         if isinstance(func_def.type, CallableType):
             # semanal.py does some in-place modifications we want to avoid
             func_def.unanalyzed_type = func_def.type.copy_modified()
@@ -662,17 +660,20 @@ def transform_args(self,
                        ) -> List[Argument]:
         new_args = []
         names: List[ast3.arg] = []
-        args_args = getattr(args, "posonlyargs", cast(List[ast3.arg], [])) + args.args
+        posonlyargs = getattr(args, "posonlyargs", cast(List[ast3.arg], []))
+        args_args = posonlyargs + args.args
         args_defaults = args.defaults
         num_no_defaults = len(args_args) - len(args_defaults)
         # positional arguments without defaults
-        for a in args_args[:num_no_defaults]:
-            new_args.append(self.make_argument(a, None, ARG_POS, no_type_check))
+        for i, a in enumerate(args_args[:num_no_defaults]):
+            pos_only = i < len(posonlyargs)
+            new_args.append(self.make_argument(a, None, ARG_POS, no_type_check, pos_only))
             names.append(a)
 
         # positional arguments with defaults
-        for a, d in zip(args_args[num_no_defaults:], args_defaults):
-            new_args.append(self.make_argument(a, d, ARG_OPT, no_type_check))
+        for i, (a, d) in enumerate(zip(args_args[num_no_defaults:], args_defaults)):
+            pos_only = num_no_defaults + i < len(posonlyargs)
+            new_args.append(self.make_argument(a, d, ARG_OPT, no_type_check, pos_only))
             names.append(a)
 
         # *arg
@@ -699,7 +700,7 @@ def transform_args(self,
         return new_args
 
     def make_argument(self, arg: ast3.arg, default: Optional[ast3.expr], kind: ArgKind,
-                      no_type_check: bool) -> Argument:
+                      no_type_check: bool, pos_only: bool = False) -> Argument:
         if no_type_check:
             arg_type = None
         else:
@@ -712,7 +713,10 @@ def make_argument(self, arg: ast3.arg, default: Optional[ast3.expr], kind: ArgKi
                 arg_type = TypeConverter(self.errors, line=arg.lineno).visit(annotation)
             else:
                 arg_type = self.translate_type_comment(arg, type_comment)
-        return Argument(Var(arg.arg), arg_type, self.visit(default), kind)
+        if argument_elide_name(arg.arg):
+            pos_only = True
+
+        return Argument(Var(arg.arg), arg_type, self.visit(default), kind, pos_only)
 
     def fail_arg(self, msg: str, arg: ast3.arg) -> None:
         self.fail(msg, arg.lineno, arg.col_offset)
@@ -994,10 +998,8 @@ def visit_Lambda(self, n: ast3.Lambda) -> LambdaExpr:
         body.lineno = n.body.lineno
         body.col_offset = n.body.col_offset
 
-        num_pos_only = len(getattr(n.args, "posonlyargs", []))
         e = LambdaExpr(self.transform_args(n.args, n.lineno),
-                       self.as_required_block([body], n.lineno),
-                       num_pos_only=num_pos_only)
+                       self.as_required_block([body], n.lineno))
         e.set_line(n.lineno, n.col_offset)  # Overrides set_line -- can't use self.set_line
         return e
 

mypy/fastparse2.py

@@ -369,12 +369,12 @@ def visit_FunctionDef(self, n: ast27.FunctionDef) -> Statement:
         converter = TypeConverter(self.errors, line=lineno, override_column=n.col_offset,
                                   assume_str_is_unicode=self.unicode_literals)
         args, decompose_stmts = self.transform_args(n.args, lineno)
+        if special_function_elide_names(n.name):
+            for arg in args:
+                arg.pos_only = True
 
         arg_kinds = [arg.kind for arg in args]
-        arg_names: List[Optional[str]] = [arg.variable.name for arg in args]
-        arg_names = [None if argument_elide_name(name) else name for name in arg_names]
-        if special_function_elide_names(n.name):
-            arg_names = [None] * len(arg_names)
+        arg_names = [None if arg.pos_only else arg.variable.name for arg in args]
 
         arg_types: List[Optional[Type]] = []
         type_comment = n.type_comment
@@ -518,6 +518,10 @@ def transform_args(self,
             new_args.append(Argument(Var(n.kwarg), typ, None, ARG_STAR2))
             names.append(n.kwarg)
 
+        for arg in new_args:
+            if argument_elide_name(arg.variable.name):
+                arg.pos_only = True
+
         # We don't have any context object to give, but we have closed around the line num
         def fail_arg(msg: str, arg: None) -> None:
             self.fail(msg, line, 0)

mypy/messages.py

@@ -1936,9 +1936,9 @@ def [T <: int] f(self, x: int, y: T) -> None
 
     # If we got a "special arg" (i.e: self, cls, etc...), prepend it to the arg list
     if isinstance(tp.definition, FuncDef) and tp.definition.name is not None:
-        definition_args = tp.definition.arg_names
+        definition_args = [arg.variable.name for arg in tp.definition.arguments]
         if definition_args and tp.arg_names != definition_args \
-                and len(definition_args) > 0:
+                and len(definition_args) > 0 and definition_args[0]:
             if s:
                 s = ', ' + s
             s = definition_args[0] + s

mypy/nodes.py

@@ -561,18 +561,20 @@ def deserialize(cls, data: JsonDict) -> 'OverloadedFuncDef':
 class Argument(Node):
     """A single argument in a FuncItem."""
 
-    __slots__ = ('variable', 'type_annotation', 'initializer', 'kind')
+    __slots__ = ('variable', 'type_annotation', 'initializer', 'kind', 'pos_only')
 
     def __init__(self,
                  variable: 'Var',
                  type_annotation: 'Optional[mypy.types.Type]',
                  initializer: Optional[Expression],
-                 kind: 'ArgKind') -> None:
+                 kind: 'ArgKind',
+                 pos_only: bool = False) -> None:
         super().__init__()
         self.variable = variable
         self.type_annotation = type_annotation
         self.initializer = initializer
         self.kind = kind  # must be an ARG_* constant
+        self.pos_only = pos_only
 
     def set_line(self,
                  target: Union[Context, int],
@@ -617,13 +619,11 @@ class FuncItem(FuncBase):
     def __init__(self,
                  arguments: List[Argument],
                  body: 'Block',
-                 typ: 'Optional[mypy.types.FunctionLike]' = None,
-                 num_pos_only: int = 0) -> None:
+                 typ: 'Optional[mypy.types.FunctionLike]' = None) -> None:
         super().__init__()
         self.arguments = arguments
-        self.arg_names = [arg.variable.name for arg in self.arguments]
+        self.arg_names = [None if arg.pos_only else arg.variable.name for arg in arguments]
         self.arg_kinds: List[ArgKind] = [arg.kind for arg in self.arguments]
-        self.num_pos_only = num_pos_only
         self.max_pos: int = (
             self.arg_kinds.count(ARG_POS) + self.arg_kinds.count(ARG_OPT))
         self.body: 'Block' = body
@@ -678,9 +678,8 @@ def __init__(self,
                  name: str,              # Function name
                  arguments: List[Argument],
                  body: 'Block',
-                 typ: 'Optional[mypy.types.FunctionLike]' = None,
-                 num_pos_only: int = 0) -> None:
-        super().__init__(arguments, body, typ, num_pos_only)
+                 typ: 'Optional[mypy.types.FunctionLike]' = None) -> None:
+        super().__init__(arguments, body, typ)
         self._name = name
         self.is_decorated = False
         self.is_conditional = False  # Defined conditionally (within block)?

mypy/typeops.py

@@ -22,7 +22,6 @@
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy.expandtype import expand_type_by_instance, expand_type
-from mypy.sharedparse import argument_elide_name
 
 from mypy.typevars import fill_typevars
 
@@ -564,8 +563,7 @@ def callable_type(fdef: FuncItem, fallback: Instance,
     return CallableType(
         args,
         fdef.arg_kinds,
-        [None if argument_elide_name(n) or i < fdef.num_pos_only else n
-         for i, n in enumerate(fdef.arg_names)],
+        fdef.arg_names,
         ret_type or AnyType(TypeOfAny.unannotated),
         fallback,
         name=fdef.name,

mypy/types.py

@@ -1077,7 +1077,7 @@ def __init__(self,
             # after serialization, but it is useful in error messages.
             # TODO: decide how to add more info here (file, line, column)
             # without changing interface hash.
-            self.def_extras = {'first_arg': definition.arg_names[0]
+            self.def_extras = {'first_arg': definition.arguments[0].variable.name
                                if definition.arg_names and definition.info and
                                not definition.is_static else None}
         else:

mypyc/irbuild/mapper.py

@@ -133,8 +133,8 @@ def fdef_to_sig(self, fdef: FuncDef) -> FuncSignature:
             else:
                 ret = object_rprimitive
 
-        args = [RuntimeArg(arg_name, arg_type, arg_kind)
-                for arg_name, arg_kind, arg_type in zip(fdef.arg_names, fdef.arg_kinds, arg_types)]
+        args = [RuntimeArg(arg.variable.name, arg_type, arg.kind)
+                for arg, arg_type in zip(fdef.arguments, arg_types)]
 
         # We force certain dunder methods to return objects to support letting them
         # return NotImplemented. It also avoids some pointless boxing and unboxing,

test-data/unit/check-classes.test

@@ -2759,7 +2759,7 @@ t = Test()
 t.crash = 'test'  # E: "Test" has no attribute "crash"
 
 class A:
-    def __setattr__(self): ...  # E: Invalid signature "def (self: __main__.A) -> Any" for "__setattr__"
+    def __setattr__(self): ...  # E: Invalid signature "def (__main__.A) -> Any" for "__setattr__"
 a = A()
 a.test = 4  # E: "A" has no attribute "test"