Properly track positional-only arguments for unannotated functions

I was originally planning to address this by adding an ARG_POS_ONLY
kind (as a concrete win for what I hoped would be a generally positive
refactor), but it was actually really easy to fix it on its own, and
then we can address the refactor purely on its own merits.

Author: msullivan

mypy/fastparse.py

@@ -602,10 +602,12 @@ def do_func_def(self, n: Union[ast3.FunctionDef, ast3.AsyncFunctionDef],
                                          AnyType(TypeOfAny.unannotated),
                                          _dummy_fallback)
 
-        func_def = FuncDef(n.name,
-                       args,
-                       self.as_required_block(n.body, lineno),
-                       func_type)
+        func_def = FuncDef(
+            n.name,
+            args,
+            self.as_required_block(n.body, lineno),
+            func_type,
+            num_pos_only=len(posonlyargs))
         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()
@@ -992,8 +994,10 @@ 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))
+                       self.as_required_block([body], n.lineno),
+                       num_pos_only=num_pos_only)
         e.set_line(n.lineno, n.col_offset)  # Overrides set_line -- can't use self.set_line
         return e
 

mypy/nodes.py

@@ -598,6 +598,7 @@ class FuncItem(FuncBase):
     __slots__ = ('arguments',  # Note that can be None if deserialized (type is a lie!)
                  'arg_names',  # Names of arguments
                  'arg_kinds',  # Kinds of arguments
+                 'num_pos_only',  # Number of positional only args
                  'min_args',  # Minimum number of arguments
                  'max_pos',  # Maximum number of positional arguments, -1 if no explicit
                              # limit (*args not included)
@@ -616,11 +617,13 @@ class FuncItem(FuncBase):
     def __init__(self,
                  arguments: List[Argument],
                  body: 'Block',
-                 typ: 'Optional[mypy.types.FunctionLike]' = None) -> None:
+                 typ: 'Optional[mypy.types.FunctionLike]' = None,
+                 num_pos_only: int = 0) -> None:
         super().__init__()
         self.arguments = arguments
         self.arg_names = [arg.variable.name for arg in self.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
@@ -675,8 +678,9 @@ def __init__(self,
                  name: str,              # Function name
                  arguments: List[Argument],
                  body: 'Block',
-                 typ: 'Optional[mypy.types.FunctionLike]' = None) -> None:
-        super().__init__(arguments, body, typ)
+                 typ: 'Optional[mypy.types.FunctionLike]' = None,
+                 num_pos_only: int = 0) -> None:
+        super().__init__(arguments, body, typ, num_pos_only)
         self._name = name
         self.is_decorated = False
         self.is_conditional = False  # Defined conditionally (within block)?

mypy/typeops.py

@@ -564,7 +564,8 @@ def callable_type(fdef: FuncItem, fallback: Instance,
     return CallableType(
         args,
         fdef.arg_kinds,
-        [None if argument_elide_name(n) else n for n in fdef.arg_names],
+        [None if argument_elide_name(n) or i < fdef.num_pos_only else n
+         for i, n in enumerate(fdef.arg_names)],
         ret_type or AnyType(TypeOfAny.unannotated),
         fallback,
         name=fdef.name,

test-data/unit/check-python38.test

@@ -192,6 +192,12 @@ def f(p1: bytes, p2: float, /) -> None:
     reveal_type(p1)  # N: Revealed type is "builtins.bytes"
     reveal_type(p2)  # N: Revealed type is "builtins.float"
 
+[case testPEP570Unannotated]
+def f(arg, /): ...
+g = lambda arg, /: arg
+f(arg=0)  # E: Unexpected keyword argument "arg" for "f"
+g(arg=0)  # E: Unexpected keyword argument "arg"
+
 [case testWalrus]
 # flags: --strict-optional
 from typing import NamedTuple, Optional, List
@@ -206,7 +212,7 @@ while b := "x":
 l = [y2 := 1, y2 + 2, y2 + 3]
 reveal_type(y2)  # N: Revealed type is "builtins.int"
 reveal_type(l)  # N: Revealed type is "builtins.list[builtins.int*]"
- 
+
 filtered_data = [y3 for x in l if (y3 := a) is not None]
 reveal_type(filtered_data)  # N: Revealed type is "builtins.list[builtins.int*]"
 reveal_type(y3)  # N: Revealed type is "builtins.int"