Merge remote-tracking branch 'upstream/master' into conditional-overloads

Author: cdce8p

misc/cherry-pick-typeshed.py

@@ -0,0 +1,67 @@
+"""Cherry-pick a commit from typeshed.
+
+Usage:
+
+  python3 misc/cherry-pick-typeshed.py --typeshed-dir dir hash
+"""
+
+import argparse
+import os.path
+import re
+import subprocess
+import sys
+import tempfile
+
+
+def parse_commit_title(diff: str) -> str:
+    m = re.search("\n    ([^ ].*)", diff)
+    assert m is not None, "Could not parse diff"
+    return m.group(1)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--typeshed-dir", help="location of typeshed", metavar="dir", required=True
+    )
+    parser.add_argument(
+        "commit", help="typeshed commit hash to cherry-pick"
+    )
+    args = parser.parse_args()
+    typeshed_dir = args.typeshed_dir
+    commit = args.commit
+
+    if not os.path.isdir(typeshed_dir):
+        sys.exit(f"error: {typeshed_dir} does not exist")
+    if not re.match("[0-9a-fA-F]+$", commit):
+        sys.exit(f"error: Invalid commit {commit!r}")
+
+    if not os.path.exists("mypy") or not os.path.exists("mypyc"):
+        sys.exit(f"error: This script must be run at the mypy repository root directory")
+
+    with tempfile.TemporaryDirectory() as d:
+        diff_file = os.path.join(d, "diff")
+        out = subprocess.run(["git", "show", commit],
+                             capture_output=True,
+                             text=True,
+                             check=True,
+                             cwd=typeshed_dir)
+        with open(diff_file, "w") as f:
+            f.write(out.stdout)
+        subprocess.run(["git",
+                        "apply",
+                        "--index",
+                        "--directory=mypy/typeshed",
+                        "--exclude=**/tests/**",
+                        diff_file],
+                       check=True)
+
+        title = parse_commit_title(out.stdout)
+        subprocess.run(["git", "commit", "-m", f"Typeshed cherry-pick: {title}"], check=True)
+
+    print()
+    print(f"Cherry-picked commit {commit} from {typeshed_dir}")
+
+
+if __name__ == '__main__':
+    main()

mypy/build.py

@@ -2188,11 +2188,8 @@ def type_checker(self) -> TypeChecker:
         if not self._type_checker:
             assert self.tree is not None, "Internal error: must be called on parsed file only"
             manager = self.manager
-            self._type_checker = TypeChecker(
-                manager.errors, manager.modules, self.options,
-                self.tree, self.xpath, manager.plugin,
-                self.manager.semantic_analyzer.future_import_flags,
-            )
+            self._type_checker = TypeChecker(manager.errors, manager.modules, self.options,
+                                             self.tree, self.xpath, manager.plugin)
         return self._type_checker
 
     def type_map(self) -> Dict[Expression, Type]:

mypy/checker.py

@@ -221,12 +221,8 @@ class TypeChecker(NodeVisitor[None], CheckerPluginInterface):
     # functions such as open(), etc.
     plugin: Plugin
 
-    # Future flags that we get from semantic analyzer.
-    future_import_flags: Set[str]
-
     def __init__(self, errors: Errors, modules: Dict[str, MypyFile], options: Options,
-                 tree: MypyFile, path: str, plugin: Plugin,
-                 future_import_flags: Set[str]) -> None:
+                 tree: MypyFile, path: str, plugin: Plugin) -> None:
         """Construct a type checker.
 
         Use errors to report type check errors.
@@ -272,8 +268,6 @@ def __init__(self, errors: Errors, modules: Dict[str, MypyFile], options: Option
         # argument through various `checker` and `checkmember` functions.
         self._is_final_def = False
 
-        self.future_import_flags = future_import_flags
-
     @property
     def type_context(self) -> List[Optional[Type]]:
         return self.expr_checker.type_context
@@ -3492,7 +3486,7 @@ def visit_raise_stmt(self, s: RaiseStmt) -> None:
         if s.expr:
             self.type_check_raise(s.expr, s)
         if s.from_expr:
-            self.type_check_raise(s.from_expr, s, optional=True)
+            self.type_check_raise(s.from_expr, s, True)
         self.binder.unreachable()
 
     def type_check_raise(self, e: Expression, s: RaiseStmt,
@@ -3501,88 +3495,24 @@ def type_check_raise(self, e: Expression, s: RaiseStmt,
         if isinstance(typ, DeletedType):
             self.msg.deleted_as_rvalue(typ, e)
             return
-
-        if self.options.python_version[0] == 2:
-            # Since `raise` has very different rule on python2, we use a different helper.
-            # https://github.com/python/mypy/pull/11289
-            self._type_check_raise_python2(e, s, typ)
-            return
-
-        # Python3 case:
         exc_type = self.named_type('builtins.BaseException')
-        expected_type_items = [exc_type, TypeType(exc_type)]
+        expected_type = UnionType([exc_type, TypeType(exc_type)])
         if optional:
-            # This is used for `x` part in a case like `raise e from x`,
-            # where we allow `raise e from None`.
-            expected_type_items.append(NoneType())
-
-        self.check_subtype(
-            typ, UnionType.make_union(expected_type_items), s,
-            message_registry.INVALID_EXCEPTION,
-        )
+            expected_type.items.append(NoneType())
+        if self.options.python_version[0] == 2:
+            # allow `raise type, value, traceback`
+            # https://docs.python.org/2/reference/simple_stmts.html#the-raise-statement
+            # TODO: Also check tuple item types.
+            any_type = AnyType(TypeOfAny.implementation_artifact)
+            tuple_type = self.named_type('builtins.tuple')
+            expected_type.items.append(TupleType([any_type, any_type], tuple_type))
+            expected_type.items.append(TupleType([any_type, any_type, any_type], tuple_type))
+        self.check_subtype(typ, expected_type, s, message_registry.INVALID_EXCEPTION)
 
         if isinstance(typ, FunctionLike):
             # https://github.com/python/mypy/issues/11089
             self.expr_checker.check_call(typ, [], [], e)
 
-    def _type_check_raise_python2(self, e: Expression, s: RaiseStmt, typ: ProperType) -> None:
-        # Python2 has two possible major cases:
-        # 1. `raise expr`, where `expr` is some expression, it can be:
-        #    - Exception typ
-        #    - Exception instance
-        #    - Old style class (not supported)
-        #    - Tuple, where 0th item is exception type or instance
-        # 2. `raise exc, msg, traceback`, where:
-        #    - `exc` is exception type (not instance!)
-        #    - `traceback` is `types.TracebackType | None`
-        # Important note: `raise exc, msg` is not the same as `raise (exc, msg)`
-        # We call `raise exc, msg, traceback` - legacy mode.
-        exc_type = self.named_type('builtins.BaseException')
-
-        if (not s.legacy_mode and (isinstance(typ, TupleType) and typ.items
-                or (isinstance(typ, Instance) and typ.args
-                    and typ.type.fullname == 'builtins.tuple'))):
-            # `raise (exc, ...)` case:
-            item = typ.items[0] if isinstance(typ, TupleType) else typ.args[0]
-            self.check_subtype(
-                item, UnionType([exc_type, TypeType(exc_type)]), s,
-                'When raising a tuple, first element must by derived from BaseException',
-            )
-            return
-        elif s.legacy_mode:
-            # `raise Exception, msg` case
-            # `raise Exception, msg, traceback` case
-            # https://docs.python.org/2/reference/simple_stmts.html#the-raise-statement
-            assert isinstance(typ, TupleType)  # Is set in fastparse2.py
-            self.check_subtype(
-                typ.items[0], TypeType(exc_type), s,
-                'First argument must be BaseException subtype',
-            )
-
-            # Typecheck `traceback` part:
-            if len(typ.items) == 3:
-                # Now, we typecheck `traceback` argument if it is present.
-                # We do this after the main check for better error message
-                # and better ordering: first about `BaseException` subtype,
-                # then about `traceback` type.
-                traceback_type = UnionType.make_union([
-                    self.named_type('types.TracebackType'),
-                    NoneType(),
-                ])
-                self.check_subtype(
-                    typ.items[2], traceback_type, s,
-                    'Third argument to raise must have "{}" type'.format(traceback_type),
-                )
-        else:
-            expected_type_items = [
-                # `raise Exception` and `raise Exception()` cases:
-                exc_type, TypeType(exc_type),
-            ]
-            self.check_subtype(
-                typ, UnionType.make_union(expected_type_items),
-                s, message_registry.INVALID_EXCEPTION,
-            )
-
     def visit_try_stmt(self, s: TryStmt) -> None:
         """Type check a try statement."""
         # Our enclosing frame will get the result if the try/except falls through.

mypy/checkexpr.py

@@ -2414,7 +2414,8 @@ def dangerous_comparison(self, left: Type, right: Type,
 
     def get_operator_method(self, op: str) -> str:
         if op == '/' and self.chk.options.python_version[0] == 2:
-            return '__truediv__' if 'division' in self.chk.future_import_flags else '__div__'
+            # TODO also check for "from __future__ import division"
+            return '__div__'
         else:
             return operators.op_methods[op]
 

mypy/fastparse.py

@@ -1445,6 +1445,12 @@ def visit_Index(self, n: Index) -> Node:
         # cast for mypyc's benefit on Python 3.9
         return self.visit(cast(Any, n).value)
 
+    def visit_Match(self, n: Any) -> Node:
+        self.fail("Match statement is not supported",
+                  line=n.lineno, column=n.col_offset, blocker=True)
+        # Just return some valid node
+        return PassStmt()
+
 
 class TypeConverter:
     def __init__(self,

mypy/fastparse2.py

@@ -664,23 +664,19 @@ def visit_With(self, n: ast27.With) -> WithStmt:
                         typ)
         return self.set_line(stmt, n)
 
-    # 'raise' [test [',' test [',' test]]]
     def visit_Raise(self, n: ast27.Raise) -> RaiseStmt:
-        legacy_mode = False
         if n.type is None:
             e = None
         else:
             if n.inst is None:
                 e = self.visit(n.type)
             else:
-                legacy_mode = True
                 if n.tback is None:
                     e = TupleExpr([self.visit(n.type), self.visit(n.inst)])
                 else:
                     e = TupleExpr([self.visit(n.type), self.visit(n.inst), self.visit(n.tback)])
 
         stmt = RaiseStmt(e, None)
-        stmt.legacy_mode = legacy_mode
         return self.set_line(stmt, n)
 
     # TryExcept(stmt* body, excepthandler* handlers, stmt* orelse)

mypy/nodes.py

@@ -1294,19 +1294,16 @@ def accept(self, visitor: StatementVisitor[T]) -> T:
 
 
 class RaiseStmt(Statement):
-    __slots__ = ('expr', 'from_expr', 'legacy_mode')
+    __slots__ = ('expr', 'from_expr')
 
     # Plain 'raise' is a valid statement.
     expr: Optional[Expression]
     from_expr: Optional[Expression]
-    # Is set when python2 has `raise exc, msg, traceback`.
-    legacy_mode: bool
 
     def __init__(self, expr: Optional[Expression], from_expr: Optional[Expression]) -> None:
         super().__init__()
         self.expr = expr
         self.from_expr = from_expr
-        self.legacy_mode = False
 
     def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_raise_stmt(self)

mypy/test/data.py

@@ -578,8 +578,13 @@ def split_test_cases(parent: 'DataFileCollector', suite: 'DataSuite',
                      data,
                      flags=re.DOTALL | re.MULTILINE)
     line_no = cases[0].count('\n') + 1
+    test_names = set()
     for i in range(1, len(cases), NUM_GROUPS):
         name, writescache, only_when, platform_flag, skip, xfail, data = cases[i:i + NUM_GROUPS]
+        if name in test_names:
+            raise RuntimeError('Found a duplicate test name "{}" in {} on line {}'.format(
+                name, parent.name, line_no,
+            ))
         platform = platform_flag[1:] if platform_flag else None
         yield DataDrivenTestCase.from_parent(
             parent=parent,
@@ -596,6 +601,9 @@ def split_test_cases(parent: 'DataFileCollector', suite: 'DataSuite',
         )
         line_no += data.count('\n') + 1
 
+        # Record existing tests to prevent duplicates:
+        test_names.update({name})
+
 
 class DataSuiteCollector(pytest.Class):
     def collect(self) -> Iterator['DataFileCollector']:

mypy/test/testcheck.py

@@ -104,6 +104,8 @@
     typecheck_files.append('check-python38.test')
 if sys.version_info >= (3, 9):
     typecheck_files.append('check-python39.test')
+if sys.version_info >= (3, 10):
+    typecheck_files.append('check-python310.test')
 
 # Special tests for platforms with case-insensitive filesystems.
 if sys.platform in ('darwin', 'win32'):

mypy/typeshed/stdlib/_typeshed/__init__.pyi

@@ -45,6 +45,26 @@ class SupportsGreaterThan(Protocol):
 
 SupportsGreaterThanT = TypeVar("SupportsGreaterThanT", bound=SupportsGreaterThan)  # noqa: Y001
 
+# Comparison protocols
+
+class SupportsDunderLT(Protocol):
+    def __lt__(self, __other: Any) -> Any: ...
+
+class SupportsDunderGT(Protocol):
+    def __gt__(self, __other: Any) -> Any: ...
+
+class SupportsDunderLE(Protocol):
+    def __le__(self, __other: Any) -> Any: ...
+
+class SupportsDunderGE(Protocol):
+    def __ge__(self, __other: Any) -> Any: ...
+
+class SupportsAllComparisons(SupportsDunderLT, SupportsDunderGT, SupportsDunderLE, SupportsDunderGE, Protocol): ...
+
+SupportsRichComparison = Union[SupportsDunderLT, SupportsDunderGT]
+SupportsRichComparisonT = TypeVar("SupportsRichComparisonT", bound=SupportsRichComparison)  # noqa: Y001
+SupportsAnyComparison = Union[SupportsDunderLE, SupportsDunderGE, SupportsDunderGT, SupportsDunderLT]
+
 class SupportsDivMod(Protocol[_T_contra, _T_co]):
     def __divmod__(self, __other: _T_contra) -> _T_co: ...