Merge pull request #1194 from google/google_sync

Google sync

Author: rchen152

CHANGELOG

@@ -1,3 +1,15 @@
+Version 2022.04.26:
+
+Updates:
+* Enable --enable-typed-dicts by default.
+
+Bug fixes:
+* Preserve the full name of imported TypedDicts.
+* Stop dropping TypedDict annotations from local assignments.
+* Don't mark fields of anonymous namedtuple parents as ClassVars.
+* Instantiate imported TypedDicts to typed_dict.TypedDict, not Instance.
+* Fix more typeshed circular dependency issues.
+
 Version 2022.04.22:
 
 Updates:

docs/support.md

@@ -13,7 +13,7 @@ of pytype.
          * [Typing](#typing)
          * [Third-Party Libraries](#third-party-libraries)
 
-<!-- Added by: rechen, at: 2022-04-06T14:32-07:00 -->
+<!-- Added by: rechen, at: 2022-04-22T15:56-07:00 -->
 
 <!--te-->
 
@@ -66,7 +66,7 @@ Feature
 [PEP 563 -- Postponed Evaluation of Annotations][563]                                   | 3.7     | ✅        |
 [PEP 585 -- Type Hinting Generics in Standard Collections][585]                         | 3.9     | ✅        |
 [PEP 586 -- Literal Types][586]                                                         | 3.8     | ✅        |
-[PEP 589 -- TypedDict][589]                                                             | 3.8     | ✅        | Requires `--enable-typed-dicts` flag externally
+[PEP 589 -- TypedDict][589]                                                             | 3.8     | ✅        |
 [PEP 591 -- Adding a Final Qualifier to Typing][591]                                    | 3.8     | ✅        |
 [PEP 593 -- Flexible Function and Variable Annotations][593]                            | 3.9     | ✅        |
 [PEP 604 -- Allow Writing Union Types as X \| Y][604]                                   | 3.10    | ❌        | [#785][union-pipe]

pytype/__version__.py

@@ -1,2 +1,2 @@
 # pylint: skip-file
-__version__ = '2022.04.22'
+__version__ = '2022.04.26'

pytype/config.py

@@ -160,7 +160,7 @@ def add_basic_options(o):
      "Enable exhaustive checking of function parameter types."),
     ("--enable-nested-classes", False,
      "Enable support for nested classes in .py files."),
-    ("--enable-typed-dicts", False,
+    ("--enable-typed-dicts", True,
      "Enable support for TypedDicts."),
     ("--strict-primitive-comparisons", False,
      "Emit errors for comparisons between incompatible primitive types."),

pytype/convert.py

@@ -824,7 +824,10 @@ def _constant_to_value(self, pyval, subst, get_node):
             instance = self._create_new_unknown_value("type")
           else:
             mycls = self.constant_to_value(cls, subst, self.ctx.root_node)
-            instance = abstract.Instance(mycls, self.ctx)
+            if isinstance(mycls, typed_dict.TypedDictClass):
+              instance = mycls.instantiate_value(self.ctx.root_node, None)
+            else:
+              instance = abstract.Instance(mycls, self.ctx)
           log.info("New pytd instance for %s: %r", cls.name, instance)
           self._convert_cache[key] = instance
         return self._convert_cache[key]

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/output.py

@@ -863,13 +863,19 @@ def add_attributes_from(instance):
       if not any(x.name == "typing.NamedTuple" for x in bases):
         bases.append(pytd.NamedType("typing.NamedTuple"))
 
-    if any(isinstance(x, named_tuple.NamedTupleClass)
-           for x in missing_bases):
+    has_namedtuple_parent = False
+    parent_field_names = set()
+    for x in missing_bases:
+      if isinstance(x, named_tuple.NamedTupleClass):
+        has_namedtuple_parent = True
+        parent_field_names.update(field.name for field in x.props.fields)
+    if has_namedtuple_parent:
       # If inheriting from an anonymous namedtuple, mark all derived class
       # constants as ClassVars, otherwise MergeBaseClasses will convert them
       # into namedtuple fields.
-      for c in constants.values():
-        c.wrap("typing.ClassVar")
+      for k, c in constants.items():
+        if k not in parent_field_names:
+          c.wrap("typing.ClassVar")
 
     final_constants = []
     if isinstance(v, named_tuple.NamedTupleClass):

pytype/overlays/typed_dict.py

@@ -178,12 +178,15 @@ def _new_instance(self, container, node, args):
       ret.set_str_item(node, k, v)
     return ret
 
-  def instantiate(self, node, container=None):
+  def instantiate_value(self, node, container):
     args = function.Args(())
     for name, typ in self.props.fields.items():
       args.namedargs[name] = self.ctx.join_variables(
           node, [t.instantiate(node) for t in typ.data])
-    return self._new_instance(container, node, args).to_variable(node)
+    return self._new_instance(container, node, args)
+
+  def instantiate(self, node, container=None):
+    return self.instantiate_value(node, container).to_variable(node)
 
   def make_class(self, *args, **kwargs):
     return self._base_cls.make_class(*args, **kwargs)

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" % (