Fix more typeshed circular dependency issues.

Fixes pytype test failures seen in python/typeshed#7676
by doing more extensive re-resolving of external types upon encountering
circular imports. This also lets us remove a previous hack that we put in to
partially work around this problem.

PiperOrigin-RevId: 444427690

Author: rchen152

pytype/load_pytd.py

@@ -312,8 +312,7 @@ def resolve_builtin_types(self, mod_ast, *, lookup_ast=None):
         visitors.ExpandCompatibleBuiltins(self.builtins_ast))
     return mod_ast
 
-  def resolve_external_types(self, mod_ast, module_map, aliases, *,
-                             mod_name=None):
+  def resolve_external_types(self, mod_ast, module_map, aliases, *, mod_name):
     name = mod_name or mod_ast.name
     try:
       mod_ast = mod_ast.Visit(visitors.LookupExternalTypes(
@@ -616,10 +615,15 @@ def finish_and_verify_ast(self, mod_ast):
     if mod_ast:
       try:
         self._resolver.verify(mod_ast)
-      except BadDependencyError:
+      except (BadDependencyError, visitors.ContainerError):
         # In the case of a circular import, an external type may be left
-        # unresolved. As long as the module containing the unresolved type does
-        # not also contain a circular import, an extra lookup should resolve it.
+        # unresolved, so we re-resolve lookups in this module and its direct
+        # dependencies. Technically speaking, we should re-resolve all
+        # transitive imports, but lookups are expensive.
+        dependencies = self._resolver.collect_dependencies(mod_ast)
+        for k in dependencies:
+          self._modules[k].ast = self._resolve_external_types(
+              self._modules[k].ast)
         mod_ast = self._resolve_external_types(mod_ast)
         self._resolver.verify(mod_ast)
     return mod_ast

pytype/pytd/pytd.py

@@ -644,10 +644,7 @@ def IsContainer(t):
   for p in t.bases:
     if isinstance(p, GenericType):
       base = p.base_type
-      # We need to check for Generic and Protocol again here because base may
-      # not yet have been resolved to a ClassType.
-      if (base.name in ('typing.Generic', 'typing.Protocol') or
-          isinstance(base, ClassType) and IsContainer(base.cls)):
+      if isinstance(base, ClassType) and IsContainer(base.cls):
         return True
   return False
 

pytype/pytd/visitors.py

@@ -1594,16 +1594,7 @@ def EnterGenericType(self, node):
           raise ContainerError("Name %s must be defined as a TypeVar" % t.name)
     elif not isinstance(node, (pytd.CallableType, pytd.TupleType)):
       actual_param_count = len(node.parameters)
-      if actual_param_count and not base_type.cls.template:
-        # This AdjustTypeParameters() call is needed because we validate nodes
-        # before their type parameters have been adjusted in some circular
-        # import cases. The result of this adjustment is not saved because it
-        # may not be accurate if the container is only partially resolved, but
-        # it's good enough to avoid some spurious container validation errors.
-        cls = base_type.cls.Visit(AdjustTypeParameters())
-      else:
-        cls = base_type.cls
-      max_param_count = len(cls.template)
+      max_param_count = len(base_type.cls.template)
       if actual_param_count > max_param_count:
         raise ContainerError(
             "Too many parameters on %s: expected %s, got %s" % (