Opt out of unnecessary checks in checker.py

Note that there are a few places where unreachable code can happen where this still doesn't 
help. I'm not sure what to do about them.

Author: A5rocks

mypy/checker.py

@@ -529,7 +529,7 @@ def check_first_pass(self) -> None:
                                 self.msg.unreachable_statement(d)
                                 break
                         else:
-                            self.accept(d)
+                            self.accept_with_delayed_errors(d)
 
                 assert not self.current_node_deferred
 
@@ -637,14 +637,17 @@ def handle_cannot_determine_type(self, name: str, context: Context) -> None:
         else:
             self.msg.cannot_determine_type(name, context)
 
-    def accept(self, stmt: Statement) -> None:
-        """Type check a node in the given type context."""
+    def accept_with_delayed_errors(self, stmt: Statement) -> None:
         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])
 
+        self.accept(stmt)
+
+    def accept(self, stmt: Statement) -> None:
+        """Type check a node in the given type context."""
         try:
             stmt.accept(self)
         except Exception as err:
@@ -1235,16 +1238,6 @@ 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)
@@ -3174,7 +3167,7 @@ def visit_block(self, b: Block) -> None:
                     self.msg.unreachable_statement(s)
                     break
             else:
-                self.accept(s)
+                self.accept_with_delayed_errors(s)
                 # Clear expression cache after each statement to avoid unlimited growth.
                 self.expr_checker.expr_cache.clear()
 

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:
-                    self.chk.accept(stmt)
+                self.chk.accept(e.body)
+
                 # 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)