Merge pull request #1200 from google/google_sync

Google sync

Author: rchen152

CHANGELOG

@@ -1,3 +1,22 @@
+Version 2022.05.05:
+
+Updates:
+* Update typeshed pin to commit 354787f from Apr 8.
+* Remove --enable-typed-dicts, which has been a no-op since the last release.
+* Add a group of feature flags for checking compatibility of signatures for
+  overriding methods:
+  * --overriding-default-value-checks
+  * --overriding-parameter-count-checks
+  * --overriding-parameter-name-checks
+  * --overriding-parameter-type-checks
+  * --overriding-return-type-checks
+* Add code structure for gradual migration to argument-by-argument call
+  matching.
+
+Bug fixes:
+* Move a check out of --enable-nested-classes.
+* Fix spurious not-callable error for typing.OrderedDict.
+
 Version 2022.04.26:
 
 Updates:

pytype/__version__.py

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

pytype/abstract/_classes.py

@@ -185,8 +185,7 @@ def get_inner_classes(self):
         continue
       if value.official_name is None or (
           self.official_name and
-          value.official_name.startswith(f"{self.official_name}.")) or (
-              not self.ctx.options.enable_nested_classes and value != self):
+          value.official_name.startswith(f"{self.official_name}.")):
         inner_classes.append(value)
     return inner_classes
 

pytype/overlays/CMakeLists.txt

@@ -92,6 +92,7 @@ py_library(
   DEPS
     .named_tuple
     .overlay
+    .typing_overlay
 )
 
 py_library(

pytype/overlays/collections_overlay.py

@@ -2,6 +2,7 @@
 
 from pytype.overlays import named_tuple
 from pytype.overlays import overlay
+from pytype.overlays import typing_overlay
 
 
 class CollectionsOverlay(overlay.Overlay):
@@ -27,3 +28,10 @@ def __init__(self, ctx):
     "namedtuple": overlay.build(
         "namedtuple", named_tuple.NamedTupleBuilder.make),
 }
+
+
+class ABCOverlay(typing_overlay.Redirect):
+  """A custom overlay for the 'collections.abc' module."""
+
+  def __init__(self, ctx):
+    super().__init__("collections.abc", {}, ctx)

pytype/overlays/overlay_dict.py

@@ -32,6 +32,7 @@
     "attr": attr_overlay.AttrOverlay,
     "chex": chex_overlay.ChexOverlay,
     "collections": collections_overlay.CollectionsOverlay,
+    "collections.abc": collections_overlay.ABCOverlay,
     "dataclasses": dataclass_overlay.DataclassOverlay,
     "enum": enum_overlay.EnumOverlay,
     "flax.struct": flax_overlay.DataclassOverlay,

pytype/overlays/typing_extensions_overlay.py

@@ -1,30 +1,14 @@
 """Implementation of special members of typing_extensions."""
 
-from pytype.overlays import overlay
 from pytype.overlays import typing_overlay
 
 
-class TypingExtensionsOverlay(overlay.Overlay):
+class TypingExtensionsOverlay(typing_overlay.Redirect):
   """A custom overlay for the 'typing_extensions' module."""
 
   def __init__(self, ctx):
-    ast = ctx.loader.import_name("typing_extensions")
-    member_map = {
-        "runtime": _build("typing.runtime_checkable"),
-    }
-    for pyval in ast.aliases + ast.classes + ast.constants + ast.functions:
-      # Any public typing_extensions members that are not explicitly implemented
-      # are unsupported.
-      _, name = pyval.name.rsplit(".", 1)
-      if name.startswith("_"):
-        continue
-      if name in typing_overlay.typing_overlay:
-        member_map[name] = typing_overlay.typing_overlay[name][0]
-      elif f"typing.{name}" in ctx.loader.typing:
-        member_map[name] = _build(f"typing.{name}")
-      elif name not in member_map:
-        member_map[name] = _build_not_supported_yet(name, ast)
-    super().__init__(ctx, "typing_extensions", member_map, ast)
+    aliases = {"runtime": "typing.runtime_checkable"}
+    super().__init__("typing_extensions", aliases, ctx)
 
   def _convert_member(self, name, member, subst=None):
     var = super()._convert_member(name, member, subst)
@@ -35,11 +19,3 @@ def _convert_member(self, name, member, subst=None):
       # on an abstract value.
       val.module = "typing"
     return var
-
-
-def _build(name):
-  return lambda ctx: ctx.convert.name_to_value(name)
-
-
-def _build_not_supported_yet(name, ast):
-  return lambda ctx: typing_overlay.not_supported_yet(name, ctx, ast=ast)

pytype/overlays/typing_overlay.py

@@ -61,6 +61,38 @@ def _convert_member(
     return super()._convert_member(name, builder, subst)
 
 
+class Redirect(overlay.Overlay):
+  """Base class for overlays that redirect to typing."""
+
+  def __init__(self, module_name, aliases, ctx):
+    ast = ctx.loader.import_name(module_name)
+    member_map = {k: _build(v) for k, v in aliases.items()}
+    for pyval in ast.aliases + ast.classes + ast.constants + ast.functions:
+      # Any public members that are not explicitly implemented are unsupported.
+      _, name = pyval.name.rsplit(".", 1)
+      if name.startswith("_"):
+        continue
+      if name in typing_overlay:
+        member_map[name] = typing_overlay[name][0]
+      elif f"typing.{name}" in ctx.loader.typing:
+        member_map[name] = _build(f"typing.{name}")
+      elif name not in member_map:
+        member_map[name] = _build_not_supported_yet(name, ast)
+    super().__init__(ctx, module_name, member_map, ast)
+
+
+def _build(name):
+  def resolve(ctx):
+    ast = ctx.loader.typing
+    pytd_type = pytd.ToType(ast.Lookup(name), True, True, True)
+    return ctx.convert.constant_to_value(pytd_type)
+  return resolve
+
+
+def _build_not_supported_yet(name, ast):
+  return lambda ctx: not_supported_yet(name, ctx, ast=ast)
+
+
 class Union(abstract.AnnotationClass):
   """Implementation of typing.Union[...]."""
 

pytype/pytd/serialize_ast.py

@@ -202,8 +202,11 @@ def _LookupClassReferences(serializable_ast, module_map, self_name):
   class_lookup = visitors.LookupExternalTypes(module_map, self_name=self_name)
   raw_ast = serializable_ast.ast
 
+  decorators = {d.type.name for c in raw_ast.classes for d in c.decorators}  # pylint: disable=g-complex-comprehension
+
   for node in (serializable_ast.class_type_nodes or ()):
     try:
+      class_lookup.allow_functions = node.name in decorators
       if node is not class_lookup.VisitClassType(node):
         serializable_ast = serializable_ast.Replace(class_type_nodes=None)
         break

pytype/pytd/visitors.py

@@ -250,6 +250,7 @@ def __init__(self, allow_singletons):
     self._in_alias = False
     self._in_literal = 0
     self.allow_singletons = allow_singletons
+    self.allow_functions = False
 
   def EnterAlias(self, _):
     assert not self._in_alias
@@ -267,7 +268,7 @@ def LeaveLiteral(self, _):
 
   def to_type(self, t):
     allow_constants = self._in_alias or self._in_literal
-    allow_functions = self._in_alias
+    allow_functions = self._in_alias or self.allow_functions
     return pytd.ToType(
         t, allow_constants=allow_constants, allow_functions=allow_functions,
         allow_singletons=self.allow_singletons)