Improve name (and fix bug)

Author: chadrik

mypy/stubgen.py

@@ -521,15 +521,15 @@ def _get_func_return(self, o: FuncDef, ctx: FunctionContext) -> str | None:
             send_name = "None"
             return_name = "None"
             if has_yield_from_expression(o):
-                yield_name = send_name = self.add_typing_import("Incomplete")
+                yield_name = send_name = self.add_incomplete()
             else:
                 for expr, in_assignment in all_yield_expressions(o):
                     if expr.expr is not None and not is_none_expr(expr.expr):
-                        yield_name = self.add_obj_import("_typeshed", "Incomplete", require=True)
+                        yield_name = self.add_incomplete()
                     if in_assignment:
-                        send_name = self.add_obj_import("_typeshed", "Incomplete", require=True)
+                        send_name = self.add_incomplete()
             if has_return_statement(o):
-                return_name = self.add_obj_import("_typeshed", "Incomplete", require=True)
+                return_name = self.add_incomplete()
             generator_name = self.add_typing_import("Generator")
             return f"{generator_name}[{yield_name}, {send_name}, {return_name}]"
         if not has_return_statement(o) and o.abstract_status == NOT_ABSTRACT:
@@ -736,15 +736,13 @@ def get_base_types(self, cdef: ClassDef) -> list[str]:
                         self.add_typing_import("NamedTuple")
                     else:
                         # Invalid namedtuple() call, cannot determine fields
-                        base_types.append(
-                            self.add_obj_import("_typeshed", "Incomplete", require=True)
-                        )
+                        base_types.append(self.add_incomplete())
                 elif self.is_typed_namedtuple(base):
                     base_types.append(base.accept(p))
                 else:
                     # At this point, we don't know what the base class is, so we
                     # just use Incomplete as the base class.
-                    base_types.append(self.add_obj_import("_typeshed", "Incomplete", require=True))
+                    base_types.append(self.add_incomplete())
         for name, value in cdef.keywords.items():
             if name == "metaclass":
                 continue  # handled separately
@@ -825,7 +823,7 @@ def _get_namedtuple_fields(self, call: CallExpr) -> list[tuple[str, str]] | None
             else:
                 return None  # Invalid namedtuple fields type
             if field_names:
-                incomplete = self.add_typing_import("Incomplete")
+                incomplete = self.add_incomplete()
                 return [(field_name, incomplete) for field_name in field_names]
             else:
                 return []
@@ -933,7 +931,7 @@ def process_typeddict(self, lvalue: NameExpr, rvalue: CallExpr) -> None:
                 self._state = CLASS
 
     def annotate_as_incomplete(self, lvalue: NameExpr) -> None:
-        incomplete = self.add_obj_import("_typeshed", "Incomplete", require=True)
+        incomplete = self.add_incomplete()
         self.add(f"{self._indent}{lvalue.name}: {incomplete}\n")
         self._state = VAR
 
@@ -1136,10 +1134,10 @@ def get_str_type_of_node(
         if isinstance(rvalue, NameExpr) and rvalue.name in ("True", "False"):
             return "bool"
         if can_infer_optional and isinstance(rvalue, NameExpr) and rvalue.name == "None":
-            incomplete = self.add_obj_import("_typeshed", "Incomplete", require=True)
+            incomplete = self.add_incomplete()
             return f"{incomplete} | None"
         if can_be_any:
-            return self.add_obj_import("_typeshed", "Incomplete", require=True)
+            return self.add_incomplete()
         else:
             return ""
 

mypy/stubgenc.py

@@ -288,7 +288,7 @@ def get_annotation(key: str) -> str | None:
                     if argtype == "None":
                         # None is not a useful annotation, but we can infer that the arg
                         # is optional
-                        incomplete = self.add_obj_import("_typeshed", "Incomplete", require=True)
+                        incomplete = self.add_incomplete()
                         argtype = f"{incomplete} | None"
                 arglist.append(ArgSig(arg, argtype, default=True))
             else:
@@ -649,7 +649,7 @@ def generate_property_stub(
             classvar = self.add_typing_import("ClassVar")
             trailing_comment = "  # read-only" if readonly else ""
             if inferred_type is None:
-                inferred_type = self.add_obj_import("_typeshed", "Incomplete", require=True)
+                inferred_type = self.add_incomplete()
 
             static_properties.append(
                 f"{self._indent}{name}: {classvar}[{inferred_type}] = ...{trailing_comment}"
@@ -661,7 +661,7 @@ def generate_property_stub(
                 ro_properties.append(self._indent + sig.format_sig())
             else:
                 if inferred_type is None:
-                    inferred_type = self.add_obj_import("_typeshed", "Incomplete", require=True)
+                    inferred_type = self.add_incomplete()
 
                 rw_properties.append(f"{self._indent}{name}: {inferred_type}")
 

mypy/stubutil.py

@@ -564,6 +564,9 @@ def add_typing_import(self, name: str, require: bool = True) -> str:
         """
         return self.add_obj_import("typing", name, require=require)
 
+    def add_incomplete(self, require: bool = True) -> str:
+        return self.add_obj_import("_typeshed", "Incomplete", require=require)
+
     def add_abc_import(self, name: str, require: bool = True) -> str:
         """Add a name to be imported from collections.abc, unless it's imported already.