Handle more cases where builtins.int isn't ready yet

Author: tungol

mypy/semanal.py

@@ -3181,7 +3181,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         else:
             s.rvalue.accept(self)
 
-        if self.found_incomplete_ref(tag) or self.should_wait_rhs(s.rvalue):
+        if self.found_incomplete_ref(tag) or self.should_wait_rhs(s.rvalue, s):
             # Initializer couldn't be fully analyzed. Defer the current node and give up.
             # Make sure that if we skip the definition of some local names, they can't be
             # added later in this scope, since an earlier definition should take precedence.
@@ -3280,7 +3280,7 @@ def analyze_identity_global_assignment(self, s: AssignmentStmt) -> bool:
                     node.fullname = sym.node.fullname
             return True
 
-    def should_wait_rhs(self, rv: Expression) -> bool:
+    def should_wait_rhs(self, rv: Expression, s: AssignmentStmt) -> bool:
         """Can we already classify this r.h.s. of an assignment or should we wait?
 
         This returns True if we don't have enough information to decide whether
@@ -3291,6 +3291,10 @@ def should_wait_rhs(self, rv: Expression) -> bool:
         if self.final_iteration:
             # No chance, nothing has changed.
             return False
+        if isinstance(s.type, UnboundType):
+            lookup = self.lookup_qualified(s.type.name, s, suppress_errors=True)
+            if lookup and isinstance(lookup.node, PlaceholderNode):
+                return True
         if isinstance(rv, NameExpr):
             n = self.lookup(rv.name, rv)
             if n and isinstance(n.node, PlaceholderNode) and not n.node.becomes_typeinfo:
@@ -3302,11 +3306,11 @@ def should_wait_rhs(self, rv: Expression) -> bool:
                 if n and isinstance(n.node, PlaceholderNode) and not n.node.becomes_typeinfo:
                     return True
         elif isinstance(rv, IndexExpr) and isinstance(rv.base, RefExpr):
-            return self.should_wait_rhs(rv.base)
+            return self.should_wait_rhs(rv.base, s)
         elif isinstance(rv, CallExpr) and isinstance(rv.callee, RefExpr):
             # This is only relevant for builtin SCC where things like 'TypeVar'
             # may be not ready.
-            return self.should_wait_rhs(rv.callee)
+            return self.should_wait_rhs(rv.callee, s)
         return False
 
     def can_be_type_alias(self, rv: Expression, allow_none: bool = False) -> bool:

mypy/typeanal.py

@@ -297,43 +297,40 @@ def not_declared_in_type_params(self, tvar_name: str) -> bool:
             and tvar_name not in self.alias_type_params_names
         )
 
-    def handle_placeholder_node(self, node: PlaceholderNode, t: UnboundType) -> Type:
-        if node.becomes_typeinfo:
-            # Reference to placeholder type.
-            if self.api.final_iteration:
-                self.cannot_resolve_type(t)
-                return AnyType(TypeOfAny.from_error)
-            elif self.allow_placeholder:
-                self.api.defer()
-            else:
-                self.api.record_incomplete_ref()
-            # Always allow ParamSpec for placeholders, if they are actually not valid,
-            # they will be reported later, after we resolve placeholders.
-            return PlaceholderType(
-                node.fullname,
-                self.anal_array(
-                    t.args,
-                    allow_param_spec=True,
-                    allow_param_spec_literals=True,
-                    allow_unpack=True,
-                ),
-                t.line,
-            )
-        else:
-            if self.api.final_iteration:
-                self.cannot_resolve_type(t)
-                return AnyType(TypeOfAny.from_error)
-            else:
-                # Reference to an unknown placeholder node.
-                self.api.record_incomplete_ref()
-                return AnyType(TypeOfAny.special_form)
-
     def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool) -> Type:
         sym = self.lookup_qualified(t.name, t)
         if sym is not None:
             node = sym.node
             if isinstance(node, PlaceholderNode):
-                return self.handle_placeholder_node(node, t)
+                if node.becomes_typeinfo:
+                    # Reference to placeholder type.
+                    if self.api.final_iteration:
+                        self.cannot_resolve_type(t)
+                        return AnyType(TypeOfAny.from_error)
+                    elif self.allow_placeholder:
+                        self.api.defer()
+                    else:
+                        self.api.record_incomplete_ref()
+                    # Always allow ParamSpec for placeholders, if they are actually not valid,
+                    # they will be reported later, after we resolve placeholders.
+                    return PlaceholderType(
+                        node.fullname,
+                        self.anal_array(
+                            t.args,
+                            allow_param_spec=True,
+                            allow_param_spec_literals=True,
+                            allow_unpack=True,
+                        ),
+                        t.line,
+                    )
+                else:
+                    if self.api.final_iteration:
+                        self.cannot_resolve_type(t)
+                        return AnyType(TypeOfAny.from_error)
+                    else:
+                        # Reference to an unknown placeholder node.
+                        self.api.record_incomplete_ref()
+                        return AnyType(TypeOfAny.special_form)
             if node is None:
                 self.fail(f"Internal error (node is None, kind={sym.kind})", t)
                 return AnyType(TypeOfAny.special_form)
@@ -1705,9 +1702,14 @@ def analyze_literal_param(self, idx: int, arg: Type, ctx: Context) -> list[Type]
                 return None
 
             # Make sure the literal's class is ready
-            sym = self.lookup_fully_qualified(arg.base_type_name)
-            if isinstance(sym.node, PlaceholderNode):
-                return [self.handle_placeholder_node(sym.node, UnboundType(arg.base_type_name))]
+            sym = self.api.lookup_fully_qualified_or_none(arg.base_type_name)
+            if sym is None or isinstance(sym.node, PlaceholderNode):
+                assert arg.base_type_name.startswith("builtins.")
+                if self.api.is_incomplete_namespace("builtins"):
+                    self.api.record_incomplete_ref()
+                else:
+                    self.fail(f'Name "{arg.base_type_name}" is not defined', arg)
+                return [AnyType(TypeOfAny.special_form)]
 
             # Remap bytes and unicode into the appropriate type for the correct Python version
             fallback = self.named_type(arg.base_type_name)

test-data/unit/check-literal.test

@@ -3021,3 +3021,39 @@ class str: ...
 class list: ...
 class dict: ...
 class ellipsis: ...
+
+
+-- In this version, looking up the node for builtins.int
+-- during type analysis of _LiteralInteger returns None
+[case testDeferIntLiteral2]
+[file _collections_abc.pyi]
+[file abc.pyi]
+[file collections/__init__.pyi]
+[file collections/abc.pyi]
+[file types.pyi]
+class UnionType: ...
+
+[file typing_extensions.pyi]
+from typing import Any
+TypeAlias: Any
+
+[file typing.pyi]
+Any = object()
+Literal: Any
+
+[file builtins.pyi]
+import _collections_abc
+import abc
+import collections.abc
+import types
+from typing import Literal
+from typing_extensions import TypeAlias
+
+class int: ...
+class ellipsis: ...
+class str: ...
+class list: ...
+class dict: ...
+
+_PositiveInteger: TypeAlias = Literal[1]
+_LiteralInteger = _PositiveInteger | Literal[0]