stub mode for TYPE_CHECKING and introducing BASEDMYPY_TYPE_CHECKING

Author: KotlinIsland

.mypy/baseline.json

@@ -2241,7 +2241,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"visit_while_stmt\" is not using @override but is overriding a method in class \"mypy.visitor.NodeVisitor\"",
-        "offset": 36,
+        "offset": 43,
         "src": "def visit_while_stmt(self, s: WhileStmt) -> None:",
         "target": "mypy.checker.TypeChecker.visit_while_stmt"
       },
@@ -5901,7 +5901,7 @@
         "code": "no-any-explicit",
         "column": 20,
         "message": "Explicit \"Any\" is not allowed",
-        "offset": 4,
+        "offset": 5,
         "src": "resp: dict[str, Any] = {}",
         "target": "mypy.dmypy_server.Server.serve"
       },
@@ -6345,19 +6345,11 @@
         "src": "res[\"memory_vms_mib\"] = meminfo.vms / MiB",
         "target": "mypy.dmypy_server.get_meminfo"
       },
-      {
-        "code": "no-any-expr",
-        "column": 12,
-        "message": "Expression type contains \"Any\" (has type \"dict[str, Any]\")",
-        "offset": 12,
-        "src": "res[\"memory_maxrss_mib\"] = rusage.ru_maxrss * factor / MiB",
-        "target": "mypy.dmypy_server.get_meminfo"
-      },
       {
         "code": "no-any-expr",
         "column": 11,
         "message": "Expression type contains \"Any\" (has type \"dict[str, Any]\")",
-        "offset": 1,
+        "offset": 13,
         "src": "return res",
         "target": "mypy.dmypy_server.get_meminfo"
       }
@@ -13395,7 +13387,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"name\" is not using @override but is overriding a method in class \"mypy.nodes.FuncBase\"",
-        "offset": 91,
+        "offset": 93,
         "src": "def name(self) -> str:",
         "target": "mypy.nodes"
       },
@@ -13835,7 +13827,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"accept\" is not using @override but is overriding a method in class \"mypy.nodes.Statement\"",
-        "offset": 19,
+        "offset": 27,
         "src": "def accept(self, visitor: StatementVisitor[T]) -> T:",
         "target": "mypy.nodes.IfStmt.accept"
       },
@@ -14845,7 +14837,7 @@
         "code": "no-any-expr",
         "column": 18,
         "message": "Expression has type \"Any\"",
-        "offset": 128,
+        "offset": 129,
         "src": "MACHDEP = sysconfig.get_config_var(\"MACHDEP\")",
         "target": "mypy.options.Options.__init__"
       },
@@ -15895,7 +15887,7 @@
         "code": "no-any-expr",
         "column": 49,
         "message": "Expression has type \"Any\"",
-        "offset": 146,
+        "offset": 150,
         "src": "result = consider_sys_platform(expr, options.platform)",
         "target": "mypy.reachability.infer_condition_value"
       },
@@ -15954,6 +15946,14 @@
         "offset": 3,
         "src": "def visit_func_def(self, node: FuncDef) -> None:",
         "target": "mypy.reachability.MarkImportsMypyOnlyVisitor.visit_func_def"
+      },
+      {
+        "code": "explicit-override",
+        "column": 4,
+        "message": "Method \"visit_overloaded_func_def\" is not using @override but is overriding a method in class \"mypy.traverser.TraverserVisitor\"",
+        "offset": 3,
+        "src": "def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:",
+        "target": "mypy.reachability.MarkImportsMypyOnlyVisitor.visit_overloaded_func_def"
       }
     ],
     "mypy/refinfo.py": [
@@ -17145,7 +17145,7 @@
         "code": "possibly-undefined",
         "column": 41,
         "message": "Name \"original_target\" may be undefined",
-        "offset": 68,
+        "offset": 71,
         "src": "if defn.info and original_target == defn.arguments[0].variable.name:",
         "target": "mypy.semanal"
       },
@@ -17177,15 +17177,15 @@
         "code": "redundant-expr",
         "column": 17,
         "message": "Condition is always true",
-        "offset": 137,
+        "offset": 138,
         "src": "elif isinstance(item, FuncDef):",
         "target": "mypy.semanal.SemanticAnalyzer.analyze_overload_sigs_and_impl"
       },
       {
         "code": "redundant-expr",
         "column": 17,
         "message": "Condition is always true",
-        "offset": 88,
+        "offset": 89,
         "src": "elif isinstance(item, FuncDef):",
         "target": "mypy.semanal.SemanticAnalyzer.process_static_or_class_method_in_overload"
       },
@@ -17281,7 +17281,7 @@
         "code": "no-any-expr",
         "column": 67,
         "message": "Expression type contains \"Any\" (has type \"set[Any]\")",
-        "offset": 162,
+        "offset": 164,
         "src": "alternatives = set(module.names.keys()).difference({source_id})",
         "target": "mypy.semanal.SemanticAnalyzer.report_missing_module_attribute"
       },
@@ -17569,7 +17569,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"visit_try_stmt\" is not using @override but is overriding a method in class \"mypy.visitor.NodeVisitor\"",
-        "offset": 8,
+        "offset": 16,
         "src": "def visit_try_stmt(self, s: TryStmt) -> None:",
         "target": "mypy.semanal.SemanticAnalyzer.visit_try_stmt"
       },
@@ -18249,7 +18249,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"class_type\" is not using @override but is overriding a method in class \"mypy.plugin.SemanticAnalyzerPluginInterface\"",
-        "offset": 66,
+        "offset": 68,
         "src": "def class_type(self, self_type: Type) -> Type:",
         "target": "mypy.semanal.SemanticAnalyzer.class_type"
       },
@@ -31721,7 +31721,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"visit_any\" is not using @override but is overriding a method in class \"mypy.type_visitor.TypeVisitor\"",
-        "offset": 692,
+        "offset": 693,
         "src": "def visit_any(self, t: AnyType) -> Type:",
         "target": "mypy.typeanal.TypeAnalyser.visit_any"
       },

CHANGELOG.md

@@ -4,6 +4,8 @@
 ### Added
 - Any parameter `_` will be inferred as `object` (#687)
 - `work_not_properly_function_names` made available to per module configuration (#699)
+- Support `BASEDMYPY_TYPE_CHECKING` (#702)
+- Enable stub mode within `TYPE_CHECKING` branches (#702)
 
 ## [2.5.0]
 ### Added

mypy/checker.py

@@ -4918,6 +4918,9 @@ def visit_if_stmt(self, s: IfStmt) -> None:
         # This frame records the knowledge from previous if/elif clauses not being taken.
         # Fall-through to the original frame is handled explicitly in each block.
         with self.binder.frame_context(can_skip=False, conditional_frame=True, fall_through=0):
+            is_stub = self.is_stub
+            if s.is_mypy_only:
+                self.is_stub = True
             for e, b in zip(s.expr, s.body):
                 t = get_proper_type(self.expr_checker.accept(e))
                 allow_redundant_expr = self.allow_redundant_expr
@@ -4944,10 +4947,14 @@ def visit_if_stmt(self, s: IfStmt) -> None:
                 ):
                     self.msg.fail("Condition is always true", e, code=codes.REDUNDANT_EXPR)
                 self.push_type_map(else_map)
-
+            if s.is_mypy_only is False:
+                self.is_stub = True
+            else:
+                self.is_stub = is_stub
             with self.binder.frame_context(can_skip=False, fall_through=2):
                 if s.else_body:
                     self.accept(s.else_body)
+            self.is_stub = is_stub
 
     def visit_while_stmt(self, s: WhileStmt) -> None:
         """Type check a while statement."""

mypy/dmypy_server.py

@@ -1022,7 +1022,7 @@ def get_meminfo() -> dict[str, Any]:
                 factor = 1
             else:
                 factor = 1024  # Linux
-            res["memory_maxrss_mib"] = rusage.ru_maxrss * factor / MiB
+            res["memory_maxrss_mib"] = rusage.ru_maxrss * factor / MiB  # type: ignore[no-any-expr, unused-ignore]
     return res
 
 

mypy/nodes.py

@@ -558,11 +558,12 @@ class OverloadedFuncDef(FuncBase, SymbolNode, Statement):
     Overloaded variants must be consecutive in the source file.
     """
 
-    __slots__ = ("items", "unanalyzed_items", "impl")
+    __slots__ = ("items", "unanalyzed_items", "impl", "is_mypy_only")
 
     items: list[OverloadPart]
     unanalyzed_items: list[OverloadPart]
     impl: OverloadPart | None
+    is_mypy_only: bool
 
     def __init__(self, items: list[OverloadPart]) -> None:
         super().__init__()
@@ -572,6 +573,7 @@ def __init__(self, items: list[OverloadPart]) -> None:
         if items:
             # TODO: figure out how to reliably set end position (we don't know the impl here).
             self.set_line(items[0].line, items[0].column)
+        self.is_mypy_only = False
 
     @property
     def name(self) -> str:
@@ -1475,19 +1477,27 @@ def accept(self, visitor: StatementVisitor[T]) -> T:
 
 
 class IfStmt(Statement):
-    __slots__ = ("expr", "body", "else_body")
+    __slots__ = ("expr", "body", "else_body", "is_mypy_only")
 
-    __match_args__ = ("expr", "body", "else_body")
+    __match_args__ = ("expr", "body", "else_body", "is_mypy_only")
 
     expr: list[Expression]
     body: list[Block]
     else_body: Block | None
+    is_mypy_only: bool | None
 
-    def __init__(self, expr: list[Expression], body: list[Block], else_body: Block | None) -> None:
+    def __init__(
+        self,
+        expr: list[Expression],
+        body: list[Block],
+        else_body: Block | None,
+        is_mypy_only: bool | None = None,
+    ) -> None:
         super().__init__()
         self.expr = expr
         self.body = body
         self.else_body = else_body
+        self.is_mypy_only = is_mypy_only
 
     def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_if_stmt(self)

mypy/reachability.py

@@ -23,6 +23,7 @@
     MemberExpr,
     NameExpr,
     OpExpr,
+    OverloadedFuncDef,
     SliceExpr,
     StrExpr,
     TupleExpr,
@@ -54,12 +55,15 @@ def infer_reachability_of_if_statement(s: IfStmt, options: Options) -> None:
     for i in range(len(s.expr)):
         result = infer_condition_value(s.expr[i], options)
         if result in (ALWAYS_FALSE, MYPY_FALSE):
+            if result == MYPY_FALSE:
+                s.is_mypy_only = False
             # The condition is considered always false, so we skip the if/elif body.
             mark_block_unreachable(s.body[i])
         elif result in (ALWAYS_TRUE, MYPY_TRUE):
             # This condition is considered always true, so all of the remaining
             # elif/else bodies should not be checked.
             if result == MYPY_TRUE:
+                s.is_mypy_only = True
                 # This condition is false at runtime; this will affect
                 # import priorities.
                 mark_block_mypy_only(s.body[i])
@@ -149,7 +153,7 @@ def infer_condition_value(expr: Expression, options: Options) -> int:
             result = ALWAYS_FALSE
         elif name == "PY3":
             result = ALWAYS_TRUE
-        elif name == "MYPY" or name == "TYPE_CHECKING":
+        elif name in {"BASEDMYPY_TYPE_CHECKING", "MYPY", "TYPE_CHECKING"}:
             result = MYPY_TRUE
         elif name in options.always_true:
             result = ALWAYS_TRUE
@@ -360,3 +364,6 @@ def visit_import_all(self, node: ImportAll) -> None:
 
     def visit_func_def(self, node: FuncDef) -> None:
         node.is_mypy_only = True
+
+    def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
+        o.is_mypy_only = True

mypy/semanal.py

@@ -907,6 +907,9 @@ def analyze_func_def(self, defn: FuncDef) -> None:
                 # Signature must be analyzed in the surrounding scope so that
                 # class-level imported names and type variables are in scope.
                 analyzer = self.type_analyzer()
+                analyzer.always_allow_new_syntax = (
+                    analyzer.always_allow_new_syntax or defn.is_mypy_only
+                )
                 tag = self.track_incomplete_refs()
                 result = analyzer.visit_callable_type(defn.type, nested=False)
                 # Don't store not ready types (including placeholders).
@@ -1189,7 +1192,8 @@ def setup_self_type(self) -> None:
     def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         self.statement = defn
         self.add_function_to_symbol_table(defn)
-
+        if self.is_stub_file:
+            defn.is_mypy_only = True
         if not self.recurse_into_functions:
             return
 
@@ -1369,7 +1373,7 @@ def handle_missing_overload_decorators(
 
     def handle_missing_overload_implementation(self, defn: OverloadedFuncDef) -> None:
         """Generate error about missing overload implementation (only if needed)."""
-        if not self.is_stub_file:
+        if not self.is_stub_file and not defn.is_mypy_only:
             if self.type and self.type.is_protocol and not self.is_func_scope():
                 # An overloaded protocol method doesn't need an implementation,
                 # but if it doesn't have one, then it is considered abstract.
@@ -1379,6 +1383,7 @@ def handle_missing_overload_implementation(self, defn: OverloadedFuncDef) -> Non
                     else:
                         item.abstract_status = IS_ABSTRACT
             else:
+
                 # TODO: also allow omitting an implementation for abstract methods in ABCs?
                 self.fail(
                     "An overloaded function outside a stub file must have an implementation",
@@ -2701,7 +2706,9 @@ def visit_import_from(self, imp: ImportFrom) -> None:
             # Modules imported in a stub file without using 'from Y import X as X' will
             # not get exported.
             # When implicit re-exporting is disabled, we have the same behavior as stubs.
-            use_implicit_reexport = not self.is_stub_file and self.options.implicit_reexport
+            # we recheck if it's a stub manually to avoid TYPE_CHECKING blocks
+            is_stub_file = self.cur_mod_node.path.lower().endswith(".pyi")
+            use_implicit_reexport = not is_stub_file and self.options.implicit_reexport
             module_public = use_implicit_reexport or (as_id is not None and id == as_id)
 
             # If the module does not contain a symbol with the name 'id',
@@ -5128,10 +5135,18 @@ def visit_continue_stmt(self, s: ContinueStmt) -> None:
     def visit_if_stmt(self, s: IfStmt) -> None:
         self.statement = s
         infer_reachability_of_if_statement(s, self.options)
+        is_stub_file = self.is_stub_file
+        if s.is_mypy_only:
+            self._is_stub_file = True
         for i in range(len(s.expr)):
             s.expr[i].accept(self)
             self.visit_block(s.body[i])
+        if s.is_mypy_only is False:
+            self._is_stub_file = True
+        else:
+            self._is_stub_file = is_stub_file
         self.visit_block_maybe(s.else_body)
+        self._is_stub_file = is_stub_file
 
     def visit_try_stmt(self, s: TryStmt) -> None:
         self.statement = s
@@ -7017,6 +7032,8 @@ def anal_type(
             a.always_allow_new_syntax = False
         if runtime is False:
             a.always_allow_new_syntax = True
+        if self.is_stub_file:
+            a.always_allow_new_syntax = True
         tag = self.track_incomplete_refs()
         typ = typ.accept(a)
         if self.found_incomplete_ref(tag):