Address reviews

Author: sobolevn

mypy/constraints.py

@@ -126,6 +126,15 @@ def infer_constraints_for_callable(
     param_spec_arg_names = []
     param_spec_arg_kinds = []
 
+    incomplete_star_mapping = False
+    for i, actuals in enumerate(formal_to_actual):  # TODO: isn't this `enumerate(arg_types)`?
+        for actual in actuals:
+            if actual is None and callee.arg_kinds[i] in (ARG_STAR, ARG_STAR2):  # type: ignore[unreachable]
+                # We can't use arguments to infer ParamSpec constraint, if only some
+                # are present in the current inference pass.
+                incomplete_star_mapping = True  # type: ignore[unreachable]
+                break
+
     for i, actuals in enumerate(formal_to_actual):
         if isinstance(callee.arg_types[i], UnpackType):
             unpack_type = callee.arg_types[i]
@@ -221,16 +230,17 @@ def infer_constraints_for_callable(
                     # constraints, instead store them and infer single constraint at the end.
                     # It is impossible to map actual kind to formal kind, so use some heuristic.
                     # This inference is used as a fallback, so relying on heuristic should be OK.
-                    param_spec_arg_types.append(
-                        mapper.expand_actual_type(
-                            actual_arg_type, arg_kinds[actual], None, arg_kinds[actual]
+                    if not incomplete_star_mapping:
+                        param_spec_arg_types.append(
+                            mapper.expand_actual_type(
+                                actual_arg_type, arg_kinds[actual], None, arg_kinds[actual]
+                            )
                         )
-                    )
-                    actual_kind = arg_kinds[actual]
-                    param_spec_arg_kinds.append(
-                        ARG_POS if actual_kind not in (ARG_STAR, ARG_STAR2) else actual_kind
-                    )
-                    param_spec_arg_names.append(arg_names[actual] if arg_names else None)
+                        actual_kind = arg_kinds[actual]
+                        param_spec_arg_kinds.append(
+                            ARG_POS if actual_kind not in (ARG_STAR, ARG_STAR2) else actual_kind
+                        )
+                        param_spec_arg_names.append(arg_names[actual] if arg_names else None)
                 else:
                     actual_type = mapper.expand_actual_type(
                         actual_arg_type,
@@ -240,7 +250,11 @@ def infer_constraints_for_callable(
                     )
                     c = infer_constraints(callee.arg_types[i], actual_type, SUPERTYPE_OF)
                     constraints.extend(c)
-    if param_spec and not any(c.type_var == param_spec.id for c in constraints):
+    if (
+        param_spec
+        and not any(c.type_var == param_spec.id for c in constraints)
+        and not incomplete_star_mapping
+    ):
         # Use ParamSpec constraint from arguments only if there are no other constraints,
         # since as explained above it is quite ad-hoc.
         constraints.append(

mypy/nodes.py

@@ -171,7 +171,11 @@ class Node(Context):
     __slots__ = ()
 
     def __str__(self) -> str:
-        return self.accept(mypy.strconv.StrConv(options=Options()))
+        ans = self.accept(mypy.strconv.StrConv(options=Options()))
+        if ans is None:
+            # Some visitors might have empty bodies and actually return `None`
+            return repr(self)  # type: ignore[unreachable]
+        return ans
 
     def str_with_options(self, options: Options) -> str:
         ans = self.accept(mypy.strconv.StrConv(options=options))
@@ -867,6 +871,8 @@ def deserialize(cls, data: JsonDict) -> FuncDef:
 
 # All types that are both SymbolNodes and FuncBases. See the FuncBase
 # docstring for the rationale.
+# See https://github.com/python/mypy/pull/13607#issuecomment-1236357236
+# TODO: we want to remove this at some point and just use `FuncBase` ideally.
 SYMBOL_FUNCBASE_TYPES: Final = (OverloadedFuncDef, FuncDef)
 
 

mypy/server/mergecheck.py

@@ -25,13 +25,18 @@ def check_consistency(o: object) -> None:
         if isinstance(sym, FakeInfo):
             continue
 
+        fn = sym.fullname
+        # Skip None and empty names, since they are ambiguous.
+        # TODO: Everything should have a proper full name?
+        if not fn:
+            continue
+
         # Skip stuff that should be expected to have duplicate names
         if isinstance(sym, (Var, Decorator)):
             continue
         if isinstance(sym, FuncDef) and sym.is_overload:
             continue
 
-        fn = sym.fullname
         if fn not in m:
             m[fn] = sym
             continue