Make semanal's side faster

Author: A5rocks

mypy/semanal.py

@@ -547,6 +547,7 @@ def __init__(
         self.transitive_submodule_imports: dict[str, set[str]] = {}
 
         self.delayed_errors: dict[tuple[str, int, int], list[ErrorInfo]] = {}
+        self.associated_node: Statement | None = None
 
     # mypyc doesn't properly handle implementing an abstractproperty
     # with a regular attribute so we make them properties
@@ -7554,7 +7555,7 @@ def fail(
             if code is None:
                 code = msg.code
             msg = msg.value
-        self.errors.report(
+        err_info = self.create_error_info(
             ctx.line,
             ctx.column,
             msg,
@@ -7563,11 +7564,86 @@ def fail(
             end_line=ctx.end_line,
             end_column=ctx.end_column,
         )
+        if self.errors._filter_error(self.errors.file, err_info):
+            return
+
+        if self.associated_node is None or self.options.semantic_analysis_only:
+            self.errors.add_error_info(err_info)
+        else:
+            node = self.associated_node
+            assign_to = (self.cur_mod_id, node.line, node.column)
+            self.delayed_errors.setdefault(assign_to, [])
+            self.delayed_errors[assign_to].append(err_info)
 
     def note(self, msg: str, ctx: Context, code: ErrorCode | None = None) -> None:
         if not self.in_checked_function():
             return
-        self.errors.report(ctx.line, ctx.column, msg, severity="note", code=code)
+        err_info = self.create_error_info(ctx.line, ctx.column, msg, severity="note", code=code)
+        if self.errors._filter_error(self.errors.file, err_info):
+            return
+
+        if self.associated_node is None or self.options.semantic_analysis_only:
+            self.errors.add_error_info(err_info)
+        else:
+            node = self.associated_node
+            assign_to = (self.cur_mod_id, node.line, node.column)
+            self.delayed_errors.setdefault(assign_to, [])
+            self.delayed_errors[assign_to].append(err_info)
+
+    def create_error_info(
+        self,
+        line: int,
+        column: int | None,
+        message: str,
+        code: ErrorCode | None = None,
+        *,
+        blocker: bool = False,
+        severity: str = "error",
+        end_line: int | None = None,
+        end_column: int | None = None,
+    ) -> ErrorInfo:
+        # TODO: move this into `errors.py`, probably
+        if self.errors.scope:
+            type = self.errors.scope.current_type_name()
+            if self.errors.scope.ignored > 0:
+                type = None  # Omit type context if nested function
+            function = self.errors.scope.current_function_name()
+        else:
+            type = None
+            function = None
+
+        if column is None:
+            column = -1
+        if end_column is None:
+            if column == -1:
+                end_column = -1
+            else:
+                end_column = column + 1
+
+        if end_line is None:
+            end_line = line
+
+        code = code or (codes.MISC if not blocker else None)
+
+        return ErrorInfo(
+            import_ctx=self.errors.import_context(),
+            file=self.errors.file,
+            module=self.errors.current_module(),
+            typ=type,
+            function_or_member=function,
+            line=line,
+            column=column,
+            end_line=end_line,
+            end_column=end_column,
+            severity=severity,
+            message=message,
+            code=code,
+            blocker=blocker,
+            only_once=False,
+            origin=(self.errors.file, [line]),
+            target=self.errors.current_target(),
+            parent_error=None,
+        )
 
     def incomplete_feature_enabled(self, feature: str, ctx: Context) -> bool:
         if feature not in self.options.enable_incomplete_feature:
@@ -7579,21 +7655,14 @@ def incomplete_feature_enabled(self, feature: str, ctx: Context) -> bool:
             return False
         return True
 
-    def accept_delaying_errors(self, node: Node) -> None:
-        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:
-            self.accept(node)
-
-        errors = msg.filtered_errors()
-        if errors:
-            # since nodes don't implement hash(), 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)
+    def accept_delaying_errors(self, node: Statement) -> None:
+        previously_associated = self.associated_node
+        self.associated_node = node
+        try:
+            node.accept(self)
+        except Exception as err:
+            report_internal_error(err, self.errors.file, node.line, self.errors, self.options)
+        self.associated_node = previously_associated
 
     def accept(self, node: Node) -> None:
         try: