Merge pull request #1197 from google/google_sync

Google sync

Author: rchen152

pytype/CMakeLists.txt

@@ -332,6 +332,16 @@ py_library(
     pytype.pytd.pytd
 )
 
+py_library(
+  NAME
+    overriding_checks
+  SRCS
+    overriding_checks.py
+  DEPS
+    pytype.abstract.abstract
+    pytype.pytd.pytd
+)
+
 py_library(
   NAME
     pytype_source_utils
@@ -428,6 +438,7 @@ py_library(
     ._utils
     .blocks
     .metaclass
+    .overriding_checks
     .state
     pytype.abstract.abstract
     pytype.pyc.pyc

pytype/config.py

@@ -160,10 +160,18 @@ 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", True,
-     "Enable support for TypedDicts."),
     ("--strict-primitive-comparisons", False,
      "Emit errors for comparisons between incompatible primitive types."),
+    ("--overriding-default-value-checks", False,
+     "Enable default value checks for overriding methods."),
+    ("--overriding-parameter-count-checks", False,
+     "Enable parameter count checks for overriding methods."),
+    ("--overriding-parameter-name-checks", False,
+     "Enable parameter name checks for overriding methods."),
+    ("--overriding-parameter-type-checks", False,
+     "Enable parameter type checks for overriding methods."),
+    ("--overriding-return-type-checks", False,
+     "Enable return type checks for overriding methods."),
 ]
 
 

pytype/context.py

@@ -17,6 +17,8 @@
 from pytype import vm_utils
 from pytype.abstract import abstract
 from pytype.abstract import abstract_utils
+from pytype.abstract import class_mixin
+from pytype.abstract import function
 from pytype.typegraph import cfg
 from pytype.typegraph import cfg_utils
 
@@ -92,6 +94,10 @@ def __init__(
     # If set, allow construction of recursive values, setting the
     # self-referential field to Any
     self.recursion_allowed = False
+    # Map from classes to maps from names of the instance methods
+    # of the class to their signatures.
+    self.method_signature_map: Dict[class_mixin.Class,
+                                    Dict[str, function.Signature]] = {}
 
   def matcher(self, node):
     return matcher.AbstractMatcher(node, self)

pytype/errors.py

@@ -1364,6 +1364,27 @@ def overriding_final_attribute(self, stack, cls, base, name, details=None):
     self._overriding_final(stack, cls, base, name, details=details,
                            is_method=False)
 
+  def _normalize_signature(self, signature):
+    """If applicable, converts from `f(self: A, ...)` to `A.f(self, ...)`."""
+    self_name = signature.param_names[0]
+    if "." not in signature.name and self_name in signature.annotations:
+      annotations = dict(signature.annotations)
+      self_annot = annotations.pop(self_name)
+      signature = signature._replace(
+          name=f"{self_annot.full_name}.{signature.name}",
+          annotations=annotations)
+    return signature
+
+  @_error_name("signature-mismatch")
+  def overriding_signature_mismatch(self, stack, base_signature,
+                                    class_signature, details=None):
+    base_signature = self._normalize_signature(base_signature)
+    class_signature = self._normalize_signature(class_signature)
+    err_msg = (f"Overriding method signature mismatch.\n"
+               f"Base signature: '{base_signature}'.\n"
+               f"Subclass signature: '{class_signature}'.")
+    self.error(stack, err_msg, details=details)
+
   @_error_name("final-error")
   def assigning_to_final(self, stack, name, local):
     """Attempting to reassign a variable annotated with Final."""

pytype/overlays/typing_overlay.py

@@ -425,17 +425,6 @@ def build_any(ctx):
   return ctx.convert.unsolvable
 
 
-def build_namedtuple(ctx):
-  return named_tuple.NamedTupleClassBuilder(ctx)
-
-
-def build_typeddict(ctx):
-  if ctx.options.enable_typed_dicts:
-    return typed_dict.TypedDictBuilder(ctx)
-  else:
-    return not_supported_yet("TypedDict", ctx)
-
-
 def build_newtype(ctx):
   return NewType.make("NewType", ctx, "typing")
 
@@ -482,13 +471,13 @@ def build_final_decorator(ctx):
     "Final": (overlay.build("Final", Final), (3, 8)),
     "Generic": (overlay.build("Generic", Generic), None),
     "Literal": (overlay.build("Literal", Literal), (3, 8)),
-    "NamedTuple": (build_namedtuple, None),
+    "NamedTuple": (named_tuple.NamedTupleClassBuilder, None),
     "NewType": (build_newtype, None),
     "NoReturn": (build_noreturn, None),
     "Optional": (overlay.build("Optional", Optional), None),
     "Tuple": (overlay.build("Tuple", Tuple), None),
     "TypeVar": (build_typevar, None),
-    "TypedDict": (build_typeddict, (3, 8)),
+    "TypedDict": (typed_dict.TypedDictBuilder, (3, 8)),
     "Union": (Union, None),
     "TYPE_CHECKING": (build_typechecking, None),
     "cast": (build_cast, None),