Delay errors in semanal for proper unreachability information

Author: A5rocks

mypy/build.py

@@ -2554,6 +2554,7 @@ def type_checker(self) -> TypeChecker:
                 self.xpath,
                 manager.plugin,
                 self.per_line_checking_time_ns,
+                manager.semantic_analyzer.delayed_errors,
             )
         return self._type_checker
 

mypy/checker.py

@@ -409,6 +409,7 @@ def __init__(
         path: str,
         plugin: Plugin,
         per_line_checking_time_ns: dict[int, int],
+        semanal_delayed_errors: dict[tuple[str, int, int], list[ErrorInfo]],
     ) -> None:
         """Construct a type checker.
 
@@ -442,6 +443,7 @@ def __init__(
         self.inferred_attribute_types = None
         self.allow_constructor_cache = True
         self.local_type_map = LocalTypeMap(self)
+        self.semanal_delayed_errors = semanal_delayed_errors
 
         # If True, process function definitions. If False, don't. This is used
         # for processing module top levels in fine-grained incremental mode.
@@ -637,6 +639,12 @@ def handle_cannot_determine_type(self, name: str, context: Context) -> None:
 
     def accept(self, stmt: Statement) -> None:
         """Type check a node in the given type context."""
+        curr_module = self.scope.stack[0]
+        if isinstance(curr_module, MypyFile):
+            key = (curr_module.fullname, stmt.line, stmt.column)
+            if key in self.semanal_delayed_errors:
+                self.msg.add_errors(self.semanal_delayed_errors[key])
+
         try:
             stmt.accept(self)
         except Exception as err:
@@ -1227,6 +1235,16 @@ def check_func_item(
         """
         self.dynamic_funcs.append(defn.is_dynamic() and not type_override)
 
+        # top-level function definitions are one of the main
+        # things errors can be associated with, and are sometimes masked
+        # e.g. by a decorator. it's better to make sure to flush any errors
+        # just in case.
+        curr_module = self.scope.stack[0]
+        if isinstance(curr_module, MypyFile):
+            key = (curr_module.fullname, defn.line, defn.column)
+            if key in self.semanal_delayed_errors:
+                self.msg.add_errors(self.semanal_delayed_errors[key])
+
         enclosing_node_deferred = self.current_node_deferred
         with self.enter_partial_types(is_function=True):
             typ = self.function_type(defn)

mypy/checkexpr.py

@@ -5495,8 +5495,8 @@ def visit_lambda_expr(self, e: LambdaExpr) -> Type:
                 # Lambdas can have more than one element in body,
                 # when we add "fictional" AssignmentStatement nodes, like in:
                 # `lambda (a, b): a`
-                for stmt in e.body.body[:-1]:
-                    stmt.accept(self.chk)
+                for stmt in e.body.body:
+                    self.chk.accept(stmt)
                 # Only type check the return expression, not the return statement.
                 # There's no useful type context.
                 ret_type = self.accept(e.expr(), allow_none_return=True)

mypy/semanal.py

@@ -59,7 +59,7 @@
 from mypy import errorcodes as codes, message_registry
 from mypy.constant_fold import constant_fold_expr
 from mypy.errorcodes import PROPERTY_DECORATOR, ErrorCode
-from mypy.errors import Errors, report_internal_error
+from mypy.errors import ErrorInfo, Errors, report_internal_error
 from mypy.exprtotype import TypeTranslationError, expr_to_unanalyzed_type
 from mypy.message_registry import ErrorMessage
 from mypy.messages import (
@@ -546,6 +546,8 @@ def __init__(
         #     import foo.bar
         self.transitive_submodule_imports: dict[str, set[str]] = {}
 
+        self.delayed_errors: dict[tuple[str, int, int], list[ErrorInfo]] = {}
+
     # mypyc doesn't properly handle implementing an abstractproperty
     # with a regular attribute so we make them properties
     @property
@@ -7093,6 +7095,7 @@ def _get_node_for_class_scoped_import(
     ) -> SymbolNode | None:
         if symbol_node is None:
             return None
+        # TODO: remove supposedly unnecessary `f`
         # I promise this type checks; I'm just making mypyc issues go away.
         # mypyc is absolutely convinced that `symbol_node` narrows to a Var in the following,
         # when it can also be a FuncBase. Once fixed, `f` in the following can be removed.
@@ -7577,10 +7580,25 @@ def incomplete_feature_enabled(self, feature: str, ctx: Context) -> bool:
         return True
 
     def accept(self, node: Node) -> None:
-        try:
-            node.accept(self)
-        except Exception as err:
-            report_internal_error(err, self.errors.file, node.line, self.errors, self.options)
+        should_filter = isinstance(node, Statement) and not self.options.semantic_analysis_only
+        if should_filter:
+            filter_errors: bool | Callable[[str, ErrorInfo], bool] = lambda _, e: not e.blocker
+        else:
+            filter_errors = False
+        with self.msg.filter_errors(filter_errors=filter_errors, save_filtered_errors=True) as msg:
+            try:
+                node.accept(self)
+            except Exception as err:
+                report_internal_error(err, self.errors.file, node.line, self.errors, self.options)
+
+        errors = msg.filtered_errors()
+        if errors:
+            # since nodes aren't hashable, carry things through values
+            assign_to = (self.cur_mod_id, node.line, node.column)
+            self.delayed_errors.setdefault(assign_to, [])
+            self.delayed_errors[assign_to].extend(errors)
+
+            # print(node, [e.message for e in self.delayed_errors[node]])
 
     def expr_to_analyzed_type(
         self,

test-data/unit/check-generics.test

@@ -3100,11 +3100,11 @@ def dec4_bound(f: Callable[[I], List[T]]) -> Callable[[I], T]:
 reveal_type(dec1(lambda x: x))  # N: Revealed type is "def [T] (T`3) -> builtins.list[T`3]"
 reveal_type(dec2(lambda x: x))  # N: Revealed type is "def [S] (S`5) -> builtins.list[S`5]"
 reveal_type(dec3(lambda x: x[0]))  # N: Revealed type is "def [S] (S`8) -> S`8"
-reveal_type(dec4(lambda x: [x]))  # N: Revealed type is "def [S] (S`11) -> S`11"
+reveal_type(dec4(lambda x: [x]))  # N: Revealed type is "def [S] (S`12) -> S`12"
 reveal_type(dec1(lambda x: 1))  # N: Revealed type is "def (builtins.int) -> builtins.list[builtins.int]"
 reveal_type(dec5(lambda x: x))  # N: Revealed type is "def (builtins.int) -> builtins.list[builtins.int]"
-reveal_type(dec3(lambda x: x))  # N: Revealed type is "def [S] (S`19) -> builtins.list[S`19]"
-reveal_type(dec4(lambda x: x))  # N: Revealed type is "def [T] (builtins.list[T`23]) -> T`23"
+reveal_type(dec3(lambda x: x))  # N: Revealed type is "def [S] (S`20) -> builtins.list[S`20]"
+reveal_type(dec4(lambda x: x))  # N: Revealed type is "def [T] (builtins.list[T`24]) -> T`24"
 dec4_bound(lambda x: x)  # E: Value of type variable "I" of "dec4_bound" cannot be "list[T]"
 [builtins fixtures/list.pyi]
 

test-data/unit/check-type-aliases.test

@@ -1216,14 +1216,22 @@ reveal_type(x)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-full.pyi]
 
-[case testTypeAliasTypeNoUnpackInTypeParams311]
+[case testTypeAliasTypeNoUnpackInTypeParams1_311]
 # flags: --python-version 3.11
 from typing_extensions import TypeAliasType, TypeVar, TypeVarTuple, Unpack
 
-T = TypeVar("T")
 Ts = TypeVarTuple("Ts")
 
+# note that the following is a blocker, so the assignment after isn't checked
 Ta1 = TypeAliasType("Ta1", None, type_params=(*Ts,))  # E: can't use starred expression here
+[builtins fixtures/tuple.pyi]
+
+[case testTypeAliasTypeNoUnpackInTypeParams2_311]
+# flags: --python-version 3.11
+from typing_extensions import TypeAliasType, TypeVar, TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+
 Ta2 = TypeAliasType("Ta2", None, type_params=(Unpack[Ts],))  # E: Free type variable expected in type_params argument to TypeAliasType \
                                                              # N: Don't Unpack type variables in type_params