diff --git a/pkg/front_end/lib/src/fasta/fasta_codes_generated.dart b/pkg/front_end/lib/src/fasta/fasta_codes_generated.dart
index 2e438f2..705d94e 100644
--- a/pkg/front_end/lib/src/fasta/fasta_codes_generated.dart
+++ b/pkg/front_end/lib/src/fasta/fasta_codes_generated.dart
@@ -6284,7 +6284,7 @@
 const MessageCode messageReturnFromVoidFunction = const MessageCode(
     "ReturnFromVoidFunction",
     analyzerCode: "RETURN_OF_INVALID_TYPE",
-    severity: Severity.warning,
+    severity: Severity.error,
     message: r"""Can't return a value from a void function.""");
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
@@ -6298,6 +6298,16 @@
     message: r"""A function expression can't have a return type.""");
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeReturnWithoutExpression = messageReturnWithoutExpression;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageReturnWithoutExpression = const MessageCode(
+    "ReturnWithoutExpression",
+    analyzerCode: "RETURN_WITHOUT_VALUE",
+    severity: Severity.warning,
+    message: r"""Must explicitly return a value from a non-void function.""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(Uri uri_)> templateSdkRootNotFound =
     const Template<Message Function(Uri uri_)>(
         messageTemplate: r"""SDK root directory not found: #uri.""",
@@ -7421,7 +7431,7 @@
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const MessageCode messageVoidExpression = const MessageCode("VoidExpression",
     analyzerCode: "USE_OF_VOID_RESULT",
-    severity: Severity.warning,
+    severity: Severity.error,
     message: r"""This expression has type 'void' and can't be used.""");
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart
index 8bf8245..c5e1b74 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart
@@ -2377,15 +2377,10 @@
           isVoidAllowed: true);
       inferredType = judgment.inferredType;
     } else {
-      inferredType = const VoidType();
+      inferredType = inferrer.coreTypes.nullClass.rawType;
     }
-    // Analyzer treats bare `return` statements as having no effect on the
-    // inferred type of the closure.  TODO(paulberry): is this what we want
-    // for Fasta?
-    if (judgment != null) {
-      closureContext.handleReturn(inferrer, inferredType, expression,
-          fileOffset, !identical(returnKeywordLexeme, "return"));
-    }
+    closureContext.handleReturn(inferrer, this, inferredType,
+        !identical(returnKeywordLexeme, "return"));
     inferrer.listener.returnStatement(this, fileOffset, tokens, null);
   }
 }
@@ -3134,7 +3129,8 @@
   DartType inferFieldTopLevel<Expression, Statement, Initializer, Type>(
       ShadowField field, bool typeNeeded) {
     if (field.initializer == null) return const DynamicType();
-    return inferExpression(field.initializer, const UnknownType(), typeNeeded);
+    return inferExpression(field.initializer, const UnknownType(), typeNeeded,
+        isVoidAllowed: true);
   }
 
   @override
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
index 0094a71..f0a84d7 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
@@ -36,6 +36,7 @@
         ProcedureKind,
         PropertyGet,
         PropertySet,
+        ReturnStatement,
         StaticGet,
         SuperMethodInvocation,
         SuperPropertyGet,
@@ -74,6 +75,7 @@
         Message,
         Template,
         messageReturnFromVoidFunction,
+        messageReturnWithoutExpression,
         messageVoidExpression,
         noLength,
         templateArgumentTypeNotAssignable,
@@ -203,10 +205,24 @@
   /// wrapping this type in `Stream` or `Iterator`, as appropriate.
   DartType _inferredUnwrappedReturnOrYieldType;
 
+  /// Whether the function is an arrow function.
+  bool isArrow;
+
+  /// A list of return statements in functions whose return type is being
+  /// inferred.
+  ///
+  /// The returns are checked for validity after the return type is inferred.
+  List<ReturnStatement> returnStatements;
+
+  /// A list of return expression types in functions whose return type is
+  /// being inferred.
+  List<DartType> returnExpressionTypes;
+
   factory ClosureContext(TypeInferrerImpl inferrer, AsyncMarker asyncMarker,
       DartType returnContext, bool needToInferReturnType) {
     assert(returnContext != null);
-    DartType declaredReturnType = returnContext;
+    DartType declaredReturnType =
+        greatestClosure(inferrer.coreTypes, returnContext);
     bool isAsync = asyncMarker == AsyncMarker.Async ||
         asyncMarker == AsyncMarker.AsyncStar;
     bool isGenerator = asyncMarker == AsyncMarker.SyncStar ||
@@ -228,23 +244,86 @@
   }
 
   ClosureContext._(this.isAsync, this.isGenerator, this.returnOrYieldContext,
-      this.declaredReturnType, this._needToInferReturnType) {}
+      this.declaredReturnType, this._needToInferReturnType) {
+    if (_needToInferReturnType) {
+      returnStatements = [];
+      returnExpressionTypes = [];
+    }
+  }
+
+  bool checkValidReturn(TypeInferrerImpl inferrer, DartType returnType,
+      ReturnStatement statement, DartType expressionType) {
+    if (statement.expression == null) {
+      if (isAsync) {
+        returnType = inferrer.typeSchemaEnvironment.unfutureType(returnType);
+      }
+      if (returnType is! VoidType &&
+          returnType is! DynamicType &&
+          returnType != inferrer.coreTypes.nullClass.rawType) {
+        statement.expression = inferrer.helper.wrapInProblem(
+            new NullLiteral()..fileOffset = statement.fileOffset,
+            messageReturnWithoutExpression,
+            noLength)
+          ..parent = statement;
+        return false;
+      }
+    } else {
+      if (isAsync) {
+        returnType = inferrer.typeSchemaEnvironment.unfutureType(returnType);
+        expressionType =
+            inferrer.typeSchemaEnvironment.unfutureType(expressionType);
+      }
+      if (!isArrow && returnType is VoidType) {
+        if (expressionType is! VoidType &&
+            expressionType is! DynamicType &&
+            expressionType != inferrer.coreTypes.nullClass.rawType) {
+          statement.expression = inferrer.helper.wrapInProblem(
+              statement.expression, messageReturnFromVoidFunction, noLength)
+            ..parent = statement;
+          return false;
+        }
+      } else if (expressionType is VoidType) {
+        if (returnType is! VoidType &&
+            returnType is! DynamicType &&
+            returnType != inferrer.coreTypes.nullClass.rawType) {
+          statement.expression = inferrer.helper.wrapInProblem(
+              statement.expression, messageVoidExpression, noLength)
+            ..parent = statement;
+          return false;
+        }
+      }
+    }
+    return true;
+  }
 
   /// Updates the inferred return type based on the presence of a return
   /// statement returning the given [type].
-  void handleReturn(TypeInferrerImpl inferrer, DartType type,
-      Expression expression, int fileOffset, bool isArrow) {
+  void handleReturn(TypeInferrerImpl inferrer, ReturnStatement statement,
+      DartType type, bool isArrow) {
     if (isGenerator) return;
-    if (inferrer.ensureAssignable(
-            returnOrYieldContext, type, expression, fileOffset,
-            isReturnFromAsync: isAsync,
-            isReturn: true,
-            declaredReturnType: declaredReturnType,
-            isArrow: isArrow) !=
-        null) {
-      type = greatestClosure(inferrer.coreTypes, returnOrYieldContext);
+    // The first return we see tells us if we have an arrow function.
+    if (this.isArrow == null) {
+      this.isArrow = isArrow;
+    } else {
+      assert(this.isArrow == isArrow);
     }
+
     if (_needToInferReturnType) {
+      // Add the return to a list to be checked for validity after we've
+      // inferred the return type.
+      returnStatements.add(statement);
+      returnExpressionTypes.add(type);
+
+      // The return expression has to be assignable to the return type
+      // expectation from the downwards inference context.
+      if (statement.expression != null &&
+          inferrer.ensureAssignable(returnOrYieldContext, type,
+                  statement.expression, statement.fileOffset,
+                  isReturnFromAsync: isAsync, isVoidAllowed: true) !=
+              null) {
+        // Not assignable, use the expectation.
+        type = greatestClosure(inferrer.coreTypes, returnOrYieldContext);
+      }
       var unwrappedType = type;
       if (isAsync) {
         unwrappedType = inferrer.typeSchemaEnvironment.unfutureType(type);
@@ -256,6 +335,16 @@
             .getStandardUpperBound(
                 _inferredUnwrappedReturnOrYieldType, unwrappedType);
       }
+      return;
+    }
+
+    // If we are not inferring a type we can immediately check that the return
+    // is valid.
+    if (checkValidReturn(inferrer, declaredReturnType, statement, type) &&
+        statement.expression != null) {
+      inferrer.ensureAssignable(returnOrYieldContext, type,
+          statement.expression, statement.fileOffset,
+          isReturnFromAsync: isAsync, isVoidAllowed: true);
     }
   }
 
@@ -294,13 +383,20 @@
     assert(_needToInferReturnType);
     DartType inferredType =
         inferrer.inferReturnType(_inferredUnwrappedReturnOrYieldType);
-    if (!_analyzerSubtypeOf(inferrer, inferredType, returnOrYieldContext)) {
+    if (!inferrer.typeSchemaEnvironment
+        .isSubtypeOf(inferredType, returnOrYieldContext)) {
       // If the inferred return type isn't a subtype of the context, we use the
       // context.
       inferredType = greatestClosure(inferrer.coreTypes, returnOrYieldContext);
     }
 
-    return _wrapAsyncOrGenerator(inferrer, inferredType);
+    inferredType = _wrapAsyncOrGenerator(inferrer, inferredType);
+    for (int i = 0; i < returnStatements.length; ++i) {
+      checkValidReturn(inferrer, inferredType, returnStatements[i],
+          returnExpressionTypes[i]);
+    }
+
+    return inferredType;
   }
 
   DartType _wrapAsyncOrGenerator(TypeInferrerImpl inferrer, DartType type) {
@@ -316,19 +412,6 @@
       return type;
     }
   }
-
-  static bool _analyzerSubtypeOf(
-      TypeInferrerImpl inferrer, DartType subtype, DartType supertype) {
-    if (supertype is VoidType) {
-      if (subtype is VoidType) return true;
-      if (subtype is InterfaceType &&
-          identical(subtype.classNode, inferrer.coreTypes.nullClass)) {
-        return true;
-      }
-      return false;
-    }
-    return inferrer.typeSchemaEnvironment.isSubtypeOf(subtype, supertype);
-  }
 }
 
 /// Enum denoting the kinds of contravariance check that might need to be
@@ -585,22 +668,9 @@
   Expression ensureAssignable(DartType expectedType, DartType actualType,
       Expression expression, int fileOffset,
       {bool isReturnFromAsync: false,
-      bool isReturn: false,
-      bool isVoidAllowed,
-      bool isArrow: false,
-      DartType declaredReturnType,
+      bool isVoidAllowed: false,
       Template<Message Function(DartType, DartType)> template}) {
-    isVoidAllowed ??= isArrow;
     assert(expectedType != null);
-    if (isReturn &&
-        !isArrow &&
-        !isValidReturn(declaredReturnType, actualType, isReturnFromAsync)) {
-      TreeNode parent = expression.parent;
-      Expression errorNode = helper.wrapInProblem(
-          expression, messageReturnFromVoidFunction, noLength);
-      parent?.replaceChild(expression, errorNode);
-      return errorNode;
-    }
     expectedType = greatestClosure(coreTypes, expectedType);
 
     DartType initialExpectedType = expectedType;
@@ -617,28 +687,6 @@
         expectedType = futuredExpectedType;
       }
     }
-    if (isReturn && !isArrow) {
-      if (expectedType is VoidType) {
-        isVoidAllowed = true;
-        if (actualType is! VoidType &&
-            actualType is! DynamicType &&
-            !isNull(actualType)) {
-          // Error: not assignable.  Perform error recovery.
-          TreeNode parent = expression.parent;
-          Expression errorNode = helper.wrapInProblem(
-              expression, messageReturnFromVoidFunction, noLength);
-          parent?.replaceChild(expression, errorNode);
-          return errorNode;
-        }
-      } else {
-        DartType flattened = typeSchemaEnvironment.unfutureType(expectedType);
-        if (flattened is VoidType) {
-          isVoidAllowed = true;
-        } else {
-          isVoidAllowed = expectedType is DynamicType;
-        }
-      }
-    }
 
     // We don't need to insert assignability checks when doing top level type
     // inference since top level type inference only cares about the type that
@@ -721,63 +769,6 @@
     }
   }
 
-  bool isValidReturn(
-      DartType returnType, DartType expressionType, bool isAsync) {
-    final DartType t = returnType;
-    final DartType s = expressionType;
-    if (!isAsync) {
-      if (t is DynamicType) {
-        // * `return exp;` where `exp` has static type `S` is a valid return if:
-        //   * `T` is `dynamic`
-        return true;
-      }
-
-      if (t is VoidType) {
-        // * `return exp;` where `exp` has static type `S` is a valid return if:
-        //   * `T` is `void`
-        //   * and `S` is `void` or `dynamic` or `Null`
-        return s is VoidType || s is DynamicType || isNull(s);
-      } else {
-        // * `return exp;` where `exp` has static type `S` is a valid return if:
-        //   * `T` is not `void`
-        //   * and `S` is not `void`
-        //   * and `S` is assignable to `T`
-        return s is! VoidType;
-      }
-    }
-    final DartType flattenT = typeSchemaEnvironment.unfutureType(t);
-
-    // * `return exp;` where `exp` has static type `S` is a valid return if:
-    //   * `flatten(T)` is `dynamic` or `Null`
-    if (flattenT is DynamicType || isNull(flattenT)) return true;
-
-    // * `return exp;` where `exp` has static type `S` is a valid return if:
-    //   * `T` is `void`
-    //   * and `S` is `void`, `dynamic` or `Null`
-    if (t is VoidType) {
-      if (s is VoidType || s is DynamicType || isNull(s)) return true;
-    } else {
-      final DartType flattenS = typeSchemaEnvironment.unfutureType(s);
-      // * `return exp;` where `exp` has static type `S` is a valid return if:
-      //   * `T` is not `void`
-      //   * `flatten(T)` is `void`
-      //   * and `flatten(S)` is `void`, `dynamic` or `Null`
-      if (flattenT is VoidType) {
-        if (flattenS is VoidType ||
-            flattenS is DynamicType ||
-            isNull(flattenS)) {
-          return true;
-        }
-      }
-
-      // * `return exp;` where `exp` has static type `S` is a valid return if:
-      //   * `T` is not `void`
-      //   * and `flatten(S)` is not `void`
-      if (flattenS is! VoidType) return true;
-    }
-    return false;
-  }
-
   bool isNull(DartType type) {
     return type is InterfaceType && type.classNode == coreTypes.nullClass;
   }
@@ -1215,10 +1206,12 @@
     assert(closureContext == null);
     this.helper = helper;
     var actualType = inferExpression(
-        initializer, declaredType ?? const UnknownType(), declaredType != null);
+        initializer, declaredType ?? const UnknownType(), declaredType != null,
+        isVoidAllowed: true);
     if (declaredType != null) {
       ensureAssignable(
-          declaredType, actualType, initializer, initializer.fileOffset);
+          declaredType, actualType, initializer, initializer.fileOffset,
+          isVoidAllowed: declaredType is VoidType);
     }
     this.helper = null;
   }
diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index f1df363..013e5f6 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -2697,7 +2697,7 @@
 
 VoidExpression:
   template: "This expression has type 'void' and can't be used."
-  severity: WARNING
+  severity: ERROR
   analyzerCode: USE_OF_VOID_RESULT
   statement: |
     {
@@ -2707,10 +2707,16 @@
 
 ReturnFromVoidFunction:
   template: "Can't return a value from a void function."
-  severity: WARNING
+  severity: ERROR
   analyzerCode: RETURN_OF_INVALID_TYPE
   declaration: "void foo() { return 1; }"
 
+ReturnWithoutExpression:
+  template: "Must explicitly return a value from a non-void function."
+  severity: WARNING
+  analyzerCode: RETURN_WITHOUT_VALUE
+  declaration: "int foo() { return; }"
+
 RethrowNotCatch:
   template: "'rethrow' can only be used in catch clauses."
   analyzerCode: RETHROW_OUTSIDE_CATCH
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart b/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart
index 852fb3f..e385138 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart
@@ -2,7 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-/*@testedFeatures=inference*/
+/*@testedFeatures=warning,inference*/
 library test;
 
 main() {
@@ -32,7 +32,7 @@
   };
   var /*@type=(bool) -> int*/ g = /*@returnType=int*/ (bool b) {
     if (b) {
-      return;
+      /*@warning=ReturnWithoutExpression*/ return;
     } else {
       return 0;
     }
@@ -62,7 +62,7 @@
     if (b) {
       return 0;
     } else {
-      return;
+      /*@warning=ReturnWithoutExpression*/ return;
     }
   };
   var /*@type=(bool) -> int*/ l = /*@returnType=int*/ (bool b) {
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart.strong.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart.strong.expect
index b0ec67b..5e2379c 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart.strong.expect
@@ -31,7 +31,7 @@
   };
   (core::bool) → core::int g = (core::bool b) → core::int {
     if(b) {
-      return;
+      return null;
     }
     else {
       return 0;
@@ -66,7 +66,7 @@
       return 0;
     }
     else {
-      return;
+      return null;
     }
   };
   (core::bool) → core::int l = (core::bool b) → core::int {
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart.strong.transformed.expect
index b0ec67b..5e2379c 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_returns.dart.strong.transformed.expect
@@ -31,7 +31,7 @@
   };
   (core::bool) → core::int g = (core::bool b) → core::int {
     if(b) {
-      return;
+      return null;
     }
     else {
       return 0;
@@ -66,7 +66,7 @@
       return 0;
     }
     else {
-      return;
+      return null;
     }
   };
   (core::bool) → core::int l = (core::bool b) → core::int {
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart b/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart
index d9f7677..23d2b4e 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart
@@ -8,7 +8,7 @@
 f() {
   List<int> o;
   o. /*@target=Iterable::forEach*/ forEach(
-      /*@returnType=void*/ (/*@type=int*/ i) {
+      /*@returnType=int*/ (/*@type=int*/ i) {
     return i /*@target=num::+*/ + 1;
   });
 }
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart.strong.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart.strong.expect
index bdd35f6..38ae920 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart.strong.expect
@@ -4,7 +4,7 @@
 
 static method f() → dynamic {
   core::List<core::int> o;
-  o.{core::Iterable::forEach}((core::int i) → void {
+  o.{core::Iterable::forEach}((core::int i) → core::int {
     return i.{core::num::+}(1);
   });
 }
diff --git a/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart.strong.transformed.expect
index bdd35f6..38ae920 100644
--- a/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/block_bodied_lambdas_void_context.dart.strong.transformed.expect
@@ -4,7 +4,7 @@
 
 static method f() → dynamic {
   core::List<core::int> o;
-  o.{core::Iterable::forEach}((core::int i) → void {
+  o.{core::Iterable::forEach}((core::int i) → core::int {
     return i.{core::num::+}(1);
   });
 }
diff --git a/pkg/front_end/testcases/inference/lambda_void_context.dart b/pkg/front_end/testcases/inference/lambda_void_context.dart
index 27bcadf..cf6ddfc 100644
--- a/pkg/front_end/testcases/inference/lambda_void_context.dart
+++ b/pkg/front_end/testcases/inference/lambda_void_context.dart
@@ -8,7 +8,7 @@
 f() {
   List<int> o;
   o. /*@target=Iterable::forEach*/ forEach(
-      /*@returnType=void*/ (/*@type=int*/ i) => i /*@target=num::+*/ + 1);
+      /*@returnType=int*/ (/*@type=int*/ i) => i /*@target=num::+*/ + 1);
 }
 
 main() {}
diff --git a/pkg/front_end/testcases/inference/lambda_void_context.dart.strong.expect b/pkg/front_end/testcases/inference/lambda_void_context.dart.strong.expect
index f46ab7c..13abe3f 100644
--- a/pkg/front_end/testcases/inference/lambda_void_context.dart.strong.expect
+++ b/pkg/front_end/testcases/inference/lambda_void_context.dart.strong.expect
@@ -4,6 +4,6 @@
 
 static method f() → dynamic {
   core::List<core::int> o;
-  o.{core::Iterable::forEach}((core::int i) → void => i.{core::num::+}(1));
+  o.{core::Iterable::forEach}((core::int i) → core::int => i.{core::num::+}(1));
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/inference/lambda_void_context.dart.strong.transformed.expect b/pkg/front_end/testcases/inference/lambda_void_context.dart.strong.transformed.expect
index f46ab7c..13abe3f 100644
--- a/pkg/front_end/testcases/inference/lambda_void_context.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/inference/lambda_void_context.dart.strong.transformed.expect
@@ -4,6 +4,6 @@
 
 static method f() → dynamic {
   core::List<core::int> o;
-  o.{core::Iterable::forEach}((core::int i) → void => i.{core::num::+}(1));
+  o.{core::Iterable::forEach}((core::int i) → core::int => i.{core::num::+}(1));
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/strong.status b/pkg/front_end/testcases/strong.status
index 4707dea..ec7d1bd 100644
--- a/pkg/front_end/testcases/strong.status
+++ b/pkg/front_end/testcases/strong.status
@@ -59,7 +59,7 @@
 redirecting_factory_typeparambounds_test: Fail # Missing support for RedirectingFactoryConstructor.
 statements: Fail
 stringliteral: Fail
-super_rasta_copy: TypeCheckError
+super_rasta_copy: Fail
 top_level_accessors: Fail
 type_variable_as_super: Fail
 type_variable_prefix: RuntimeError
@@ -176,7 +176,7 @@
 rasta/native_is_illegal: Fail
 rasta/parser_error: Fail
 rasta/static: Fail
-rasta/super: TypeCheckError
+rasta/super: Fail
 rasta/super_initializer: Fail
 rasta/super_mixin: TypeCheckError
 rasta/super_operator: Fail
diff --git a/tests/co19/co19-kernel.status b/tests/co19/co19-kernel.status
index 011875a..e53e8f7 100644
--- a/tests/co19/co19-kernel.status
+++ b/tests/co19/co19-kernel.status
@@ -578,6 +578,8 @@
 Language/Expressions/Lists/static_type_t05: CompileTimeError
 Language/Expressions/Lists/value_of_a_constant_list_t02: CompileTimeError
 Language/Expressions/Logical_Boolean_Expressions/evaluation_form_and_t01: CompileTimeError
+Language/Expressions/Logical_Boolean_Expressions/evaluation_form_and_t02: CompileTimeError
+Language/Expressions/Logical_Boolean_Expressions/evaluation_form_or_t02: CompileTimeError
 Language/Expressions/Logical_Boolean_Expressions/static_type_t02: CompileTimeError
 Language/Expressions/Logical_Boolean_Expressions/syntax_t01: CompileTimeError
 Language/Expressions/Logical_Boolean_Expressions/syntax_t10/01: CompileTimeError
@@ -889,6 +891,7 @@
 Language/Functions/async_return_type_t01: CompileTimeError
 Language/Functions/generator_return_type_t01: CompileTimeError
 Language/Functions/generator_return_type_t02: CompileTimeError
+Language/Functions/implicit_return_t01: CompileTimeError
 Language/Functions/syntax_t01: CompileTimeError
 Language/Functions/syntax_t36: CompileTimeError
 Language/Functions/syntax_t37: CompileTimeError
@@ -1017,6 +1020,7 @@
 Language/Statements/Continue/control_transfer_t09: CompileTimeError
 Language/Statements/Continue/label_t07: MissingCompileTimeError
 Language/Statements/Do/condition_type_t01: CompileTimeError
+Language/Statements/Do/condition_type_t02: CompileTimeError
 Language/Statements/Do/condition_type_t03: CompileTimeError
 Language/Statements/Do/execution_t03: CompileTimeError
 Language/Statements/Expression_Statements/syntax_t01: CompileTimeError
@@ -1111,8 +1115,14 @@
 Language/Types/Static_Types/malformed_type_t05: CompileTimeError
 Language/Types/Static_Types/malformed_type_t06: CompileTimeError
 Language/Types/Type_Declarations/Typedef/syntax_t01: CompileTimeError
+Language/Types/Type_Void/returning_t03: CompileTimeError
+Language/Types/Type_Void/returning_t04: CompileTimeError
+Language/Types/Type_Void/returning_t05: CompileTimeError
 Language/Types/Type_Void/syntax_t08: MissingCompileTimeError
 Language/Types/Type_Void/syntax_t09: MissingCompileTimeError
+Language/Types/Type_Void/syntax_t09: Pass
+Language/Types/Type_Void/using_t01: CompileTimeError
+Language/Types/Type_Void/using_t02: CompileTimeError
 Language/Variables/constant_variable_t01: CompileTimeError
 Language/Variables/constant_variable_t02: CompileTimeError
 Language/Variables/constant_variable_t03: CompileTimeError
@@ -1189,6 +1199,9 @@
 LibTest/async/Zone/registerBinaryCallback_A01_t01: CompileTimeError
 LibTest/async/Zone/registerCallback_A01_t01: CompileTimeError
 LibTest/async/Zone/registerUnaryCallback_A01_t01: CompileTimeError
+LibTest/async/Zone/runBinaryGuarded_A01_t01: CompileTimeError
+LibTest/async/Zone/runGuarded_A01_t01: CompileTimeError
+LibTest/async/Zone/runUnaryGuarded_A01_t01: CompileTimeError
 LibTest/collection/DoubleLinkedQueue/DoubleLinkedQueue_class_A01_t01: CompileTimeError
 LibTest/collection/DoubleLinkedQueue/firstWhere_A02_t01: CompileTimeError
 LibTest/collection/DoubleLinkedQueue/firstWhere_A03_t01: CompileTimeError
diff --git a/tests/co19_2/co19_2-kernel.status b/tests/co19_2/co19_2-kernel.status
index 388145f..1fdcfee1 100644
--- a/tests/co19_2/co19_2-kernel.status
+++ b/tests/co19_2/co19_2-kernel.status
@@ -164,11 +164,9 @@
 Language/Types/Static_Types/malformed_type_t01/04: MissingCompileTimeError # Issue 33308
 Language/Types/Static_Types/malformed_type_t01/05: MissingCompileTimeError # Issue 33308
 Language/Types/Static_Types/malformed_type_t01/06: MissingCompileTimeError # Issue 33308
-Language/Types/Type_Void/returning_t03: MissingCompileTimeError # Issue 30470
-Language/Types/Type_Void/returning_t04: MissingCompileTimeError # Issue 30470
-Language/Types/Type_Void/returning_t05: MissingCompileTimeError # Issue 30470
 Language/Types/Type_Void/syntax_t08: MissingCompileTimeError # Issue 33308
-Language/Types/Type_Void/using_t01: MissingCompileTimeError # Issue 30470
+Language/Types/Type_Void/syntax_t09: CompileTimeError # Test contains a compile-time error
+Language/Types/Type_Void/using_t02: CompileTimeError # Test contains a compile-time error
 LanguageFeatures/Instantiate-to-bound/Callable/Callable_ret_extends_neg_assign_l1_t01: MissingCompileTimeError
 LanguageFeatures/Instantiate-to-bound/Callable/Callable_ret_extends_neg_assign_l1_t03: MissingCompileTimeError
 LanguageFeatures/Instantiate-to-bound/Callable/Callable_ret_extends_neg_assign_l1_t04: MissingCompileTimeError
diff --git a/tests/language_2/language_2_kernel.status b/tests/language_2/language_2_kernel.status
index b3f8360..b65a22f 100644
--- a/tests/language_2/language_2_kernel.status
+++ b/tests/language_2/language_2_kernel.status
@@ -344,332 +344,11 @@
 [ $compiler != dart2analyzer && $fasta ]
 const_map2_test/00: MissingCompileTimeError # KernelVM bug: Constant evaluation.
 const_map3_test/00: MissingCompileTimeError # KernelVM bug: Constant evaluation.
-invalid_returns/async_invalid_return_05_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_06_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_07_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_08_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_09_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_10_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_11_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_12_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_13_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_14_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_15_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_16_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_17_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_18_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_19_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_20_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_21_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_22_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_23_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_24_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_25_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_26_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_27_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_28_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_29_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_30_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_31_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_32_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_33_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_34_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_35_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_36_test: MissingCompileTimeError
-invalid_returns/async_invalid_return_37_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_06_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_07_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_08_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_09_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_10_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_11_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_12_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_13_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_14_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_15_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_16_test: MissingCompileTimeError
-invalid_returns/sync_invalid_return_17_test: MissingCompileTimeError
 switch_bad_case_test/01: MissingCompileTimeError # KernelVM bug: Constant evaluation.
 switch_bad_case_test/02: MissingCompileTimeError # KernelVM bug: Constant evaluation.
 switch_case_test/00: MissingCompileTimeError # KernelVM bug: Constant evaluation.
 switch_case_test/01: MissingCompileTimeError # KernelVM bug: Constant evaluation.
 switch_case_test/02: MissingCompileTimeError # KernelVM bug: Constant evaluation.
-void/return_future_future_or_void_async_error0_test: MissingCompileTimeError
-void/return_future_future_or_void_sync_error0_test: MissingCompileTimeError
-void/return_future_or_future_or_void_sync_error1_test: MissingCompileTimeError
-void/return_future_or_void_sync_error3_test: MissingCompileTimeError
-void/return_void_async_error0_test: MissingCompileTimeError
-void/return_void_async_error1_test: MissingCompileTimeError
-void/return_void_async_error2_test: MissingCompileTimeError
-void/return_void_async_error4_test: MissingCompileTimeError
-void/return_void_sync_error0_test: MissingCompileTimeError
-void/return_void_sync_error1_test: MissingCompileTimeError
-void/return_void_sync_error2_test: MissingCompileTimeError
-void/void_block_return_test/00: MissingCompileTimeError
-void/void_type_callbacks_test/00: MissingCompileTimeError
-void/void_type_callbacks_test/01: MissingCompileTimeError
-void/void_type_usage_test/async_use_in_await_for: MissingCompileTimeError
-void/void_type_usage_test/async_use_in_yield: MissingCompileTimeError
-void/void_type_usage_test/async_use_in_yield_star: MissingCompileTimeError
-void/void_type_usage_test/call_addition: MissingCompileTimeError
-void/void_type_usage_test/call_argument: MissingCompileTimeError
-void/void_type_usage_test/call_boolean_and_left: MissingCompileTimeError
-void/void_type_usage_test/call_boolean_and_right: MissingCompileTimeError
-void/void_type_usage_test/call_boolean_negation: MissingCompileTimeError
-void/void_type_usage_test/call_boolean_or_left: MissingCompileTimeError
-void/void_type_usage_test/call_boolean_or_right: MissingCompileTimeError
-void/void_type_usage_test/call_cascade: MissingCompileTimeError
-void/void_type_usage_test/call_conditional_stmt: MissingCompileTimeError
-void/void_type_usage_test/call_do_while: MissingCompileTimeError
-void/void_type_usage_test/call_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/call_equals_left: MissingCompileTimeError
-void/void_type_usage_test/call_equals_right: MissingCompileTimeError
-void/void_type_usage_test/call_for_in: MissingCompileTimeError
-void/void_type_usage_test/call_identical: MissingCompileTimeError
-void/void_type_usage_test/call_is: MissingCompileTimeError
-void/void_type_usage_test/call_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/call_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/call_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/call_multiplication: MissingCompileTimeError
-void/void_type_usage_test/call_null_dot: MissingCompileTimeError
-void/void_type_usage_test/call_null_equals1: MissingCompileTimeError
-void/void_type_usage_test/call_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/call_throw: MissingCompileTimeError
-void/void_type_usage_test/call_toString: MissingCompileTimeError
-void/void_type_usage_test/call_use_in_conditional_assignment_right: MissingCompileTimeError
-void/void_type_usage_test/call_use_in_list_subscript: MissingCompileTimeError
-void/void_type_usage_test/call_use_in_map_lookup: MissingCompileTimeError
-void/void_type_usage_test/call_use_in_string_interpolation: MissingCompileTimeError
-void/void_type_usage_test/call_while: MissingCompileTimeError
-void/void_type_usage_test/conditional2_argument: MissingCompileTimeError
-void/void_type_usage_test/conditional2_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/conditional2_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/conditional2_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/conditional2_null_equals1: MissingCompileTimeError
-void/void_type_usage_test/conditional2_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/conditional2_throw: MissingCompileTimeError
-void/void_type_usage_test/conditional2do_while: MissingCompileTimeError
-void/void_type_usage_test/conditional2for_in: MissingCompileTimeError
-void/void_type_usage_test/conditional2while: MissingCompileTimeError
-void/void_type_usage_test/conditional3_argument: MissingCompileTimeError
-void/void_type_usage_test/conditional3_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/conditional3_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/conditional3_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/conditional3_null_equals1: MissingCompileTimeError
-void/void_type_usage_test/conditional3_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/conditional3_throw: MissingCompileTimeError
-void/void_type_usage_test/conditional_argument: MissingCompileTimeError
-void/void_type_usage_test/conditional_do_while: MissingCompileTimeError
-void/void_type_usage_test/conditional_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/conditional_for_in: MissingCompileTimeError
-void/void_type_usage_test/conditional_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/conditional_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/conditional_null_equals1: MissingCompileTimeError
-void/void_type_usage_test/conditional_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/conditional_throw: MissingCompileTimeError
-void/void_type_usage_test/conditional_while: MissingCompileTimeError
-void/void_type_usage_test/final_local_addition: MissingCompileTimeError
-void/void_type_usage_test/final_local_argument: MissingCompileTimeError
-void/void_type_usage_test/final_local_boolean_and_left: MissingCompileTimeError
-void/void_type_usage_test/final_local_boolean_and_right: MissingCompileTimeError
-void/void_type_usage_test/final_local_boolean_negation: MissingCompileTimeError
-void/void_type_usage_test/final_local_boolean_or_left: MissingCompileTimeError
-void/void_type_usage_test/final_local_boolean_or_right: MissingCompileTimeError
-void/void_type_usage_test/final_local_cascade: MissingCompileTimeError
-void/void_type_usage_test/final_local_conditional_stmt: MissingCompileTimeError
-void/void_type_usage_test/final_local_do_while: MissingCompileTimeError
-void/void_type_usage_test/final_local_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/final_local_equals_left: MissingCompileTimeError
-void/void_type_usage_test/final_local_equals_right: MissingCompileTimeError
-void/void_type_usage_test/final_local_for_in: MissingCompileTimeError
-void/void_type_usage_test/final_local_identical: MissingCompileTimeError
-void/void_type_usage_test/final_local_is: MissingCompileTimeError
-void/void_type_usage_test/final_local_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/final_local_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/final_local_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/final_local_multiplication: MissingCompileTimeError
-void/void_type_usage_test/final_local_null_dot: MissingCompileTimeError
-void/void_type_usage_test/final_local_null_equals1: MissingCompileTimeError
-void/void_type_usage_test/final_local_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/final_local_throw: MissingCompileTimeError
-void/void_type_usage_test/final_local_toString: MissingCompileTimeError
-void/void_type_usage_test/final_local_use_in_conditional_assignment_right: MissingCompileTimeError
-void/void_type_usage_test/final_local_use_in_list_subscript: MissingCompileTimeError
-void/void_type_usage_test/final_local_use_in_map_lookup: MissingCompileTimeError
-void/void_type_usage_test/final_local_use_in_string_interpolation: MissingCompileTimeError
-void/void_type_usage_test/final_local_while: MissingCompileTimeError
-void/void_type_usage_test/global_addition: MissingCompileTimeError
-void/void_type_usage_test/global_argument: MissingCompileTimeError
-void/void_type_usage_test/global_boolean_and_left: MissingCompileTimeError
-void/void_type_usage_test/global_boolean_and_right: MissingCompileTimeError
-void/void_type_usage_test/global_boolean_negation: MissingCompileTimeError
-void/void_type_usage_test/global_boolean_or_left: MissingCompileTimeError
-void/void_type_usage_test/global_boolean_or_right: MissingCompileTimeError
-void/void_type_usage_test/global_cascade: MissingCompileTimeError
-void/void_type_usage_test/global_conditional_stmt: MissingCompileTimeError
-void/void_type_usage_test/global_do_while: MissingCompileTimeError
-void/void_type_usage_test/global_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/global_equals_left: MissingCompileTimeError
-void/void_type_usage_test/global_equals_right: MissingCompileTimeError
-void/void_type_usage_test/global_for_in: MissingCompileTimeError
-void/void_type_usage_test/global_identical: MissingCompileTimeError
-void/void_type_usage_test/global_is: MissingCompileTimeError
-void/void_type_usage_test/global_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/global_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/global_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/global_multiplication: MissingCompileTimeError
-void/void_type_usage_test/global_null_dot: MissingCompileTimeError
-void/void_type_usage_test/global_null_equals2: MissingCompileTimeError
-void/void_type_usage_test/global_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/global_throw: MissingCompileTimeError
-void/void_type_usage_test/global_toString: MissingCompileTimeError
-void/void_type_usage_test/global_use_in_conditional_assignment_left: MissingCompileTimeError
-void/void_type_usage_test/global_use_in_conditional_assignment_right: MissingCompileTimeError
-void/void_type_usage_test/global_use_in_list_subscript: MissingCompileTimeError
-void/void_type_usage_test/global_use_in_map_lookup: MissingCompileTimeError
-void/void_type_usage_test/global_use_in_string_interpolation: MissingCompileTimeError
-void/void_type_usage_test/global_while: MissingCompileTimeError
-void/void_type_usage_test/instance2_argument: MissingCompileTimeError
-void/void_type_usage_test/instance2_cascade: MissingCompileTimeError
-void/void_type_usage_test/instance2_do_while: MissingCompileTimeError
-void/void_type_usage_test/instance2_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/instance2_for_in: MissingCompileTimeError
-void/void_type_usage_test/instance2_is: MissingCompileTimeError
-void/void_type_usage_test/instance2_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/instance2_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/instance2_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/instance2_null_dot: MissingCompileTimeError
-void/void_type_usage_test/instance2_null_equals2: MissingCompileTimeError
-void/void_type_usage_test/instance2_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/instance2_throw: MissingCompileTimeError
-void/void_type_usage_test/instance2_toString: MissingCompileTimeError
-void/void_type_usage_test/instance2_while: MissingCompileTimeError
-void/void_type_usage_test/instance3_argument: MissingCompileTimeError
-void/void_type_usage_test/instance3_cascade: MissingCompileTimeError
-void/void_type_usage_test/instance3_do_while: MissingCompileTimeError
-void/void_type_usage_test/instance3_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/instance3_for_in: MissingCompileTimeError
-void/void_type_usage_test/instance3_is: MissingCompileTimeError
-void/void_type_usage_test/instance3_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/instance3_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/instance3_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/instance3_null_dot: MissingCompileTimeError
-void/void_type_usage_test/instance3_null_equals2: MissingCompileTimeError
-void/void_type_usage_test/instance3_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/instance3_throw: MissingCompileTimeError
-void/void_type_usage_test/instance3_toString: MissingCompileTimeError
-void/void_type_usage_test/instance3_while: MissingCompileTimeError
-void/void_type_usage_test/instance_argument: MissingCompileTimeError
-void/void_type_usage_test/instance_cascade: MissingCompileTimeError
-void/void_type_usage_test/instance_do_while: MissingCompileTimeError
-void/void_type_usage_test/instance_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/instance_for_in: MissingCompileTimeError
-void/void_type_usage_test/instance_is: MissingCompileTimeError
-void/void_type_usage_test/instance_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/instance_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/instance_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/instance_null_dot: MissingCompileTimeError
-void/void_type_usage_test/instance_null_equals2: MissingCompileTimeError
-void/void_type_usage_test/instance_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/instance_throw: MissingCompileTimeError
-void/void_type_usage_test/instance_toString: MissingCompileTimeError
-void/void_type_usage_test/instance_while: MissingCompileTimeError
-void/void_type_usage_test/local_addition: MissingCompileTimeError
-void/void_type_usage_test/local_argument: MissingCompileTimeError
-void/void_type_usage_test/local_boolean_and_left: MissingCompileTimeError
-void/void_type_usage_test/local_boolean_and_right: MissingCompileTimeError
-void/void_type_usage_test/local_boolean_negation: MissingCompileTimeError
-void/void_type_usage_test/local_boolean_or_left: MissingCompileTimeError
-void/void_type_usage_test/local_boolean_or_right: MissingCompileTimeError
-void/void_type_usage_test/local_cascade: MissingCompileTimeError
-void/void_type_usage_test/local_conditional_stmt: MissingCompileTimeError
-void/void_type_usage_test/local_do_while: MissingCompileTimeError
-void/void_type_usage_test/local_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/local_equals_left: MissingCompileTimeError
-void/void_type_usage_test/local_equals_right: MissingCompileTimeError
-void/void_type_usage_test/local_for_in: MissingCompileTimeError
-void/void_type_usage_test/local_identical: MissingCompileTimeError
-void/void_type_usage_test/local_is: MissingCompileTimeError
-void/void_type_usage_test/local_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/local_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/local_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/local_multiplication: MissingCompileTimeError
-void/void_type_usage_test/local_null_dot: MissingCompileTimeError
-void/void_type_usage_test/local_null_equals1: MissingCompileTimeError
-void/void_type_usage_test/local_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/local_throw: MissingCompileTimeError
-void/void_type_usage_test/local_toString: MissingCompileTimeError
-void/void_type_usage_test/local_use_in_conditional_assignment_left: MissingCompileTimeError
-void/void_type_usage_test/local_use_in_conditional_assignment_right: MissingCompileTimeError
-void/void_type_usage_test/local_use_in_list_subscript: MissingCompileTimeError
-void/void_type_usage_test/local_use_in_map_lookup: MissingCompileTimeError
-void/void_type_usage_test/local_use_in_string_interpolation: MissingCompileTimeError
-void/void_type_usage_test/local_while: MissingCompileTimeError
-void/void_type_usage_test/param_addition: MissingCompileTimeError
-void/void_type_usage_test/param_argument: MissingCompileTimeError
-void/void_type_usage_test/param_boolean_and_left: MissingCompileTimeError
-void/void_type_usage_test/param_boolean_and_right: MissingCompileTimeError
-void/void_type_usage_test/param_boolean_negation: MissingCompileTimeError
-void/void_type_usage_test/param_boolean_or_left: MissingCompileTimeError
-void/void_type_usage_test/param_boolean_or_right: MissingCompileTimeError
-void/void_type_usage_test/param_cascade: MissingCompileTimeError
-void/void_type_usage_test/param_conditional_stmt: MissingCompileTimeError
-void/void_type_usage_test/param_do_while: MissingCompileTimeError
-void/void_type_usage_test/param_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/param_equals_left: MissingCompileTimeError
-void/void_type_usage_test/param_equals_right: MissingCompileTimeError
-void/void_type_usage_test/param_for_in: MissingCompileTimeError
-void/void_type_usage_test/param_identical: MissingCompileTimeError
-void/void_type_usage_test/param_is: MissingCompileTimeError
-void/void_type_usage_test/param_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/param_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/param_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/param_multiplication: MissingCompileTimeError
-void/void_type_usage_test/param_null_dot: MissingCompileTimeError
-void/void_type_usage_test/param_null_equals1: MissingCompileTimeError
-void/void_type_usage_test/param_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/param_throw: MissingCompileTimeError
-void/void_type_usage_test/param_toString: MissingCompileTimeError
-void/void_type_usage_test/param_use_in_conditional_assignment_left: MissingCompileTimeError
-void/void_type_usage_test/param_use_in_conditional_assignment_right: MissingCompileTimeError
-void/void_type_usage_test/param_use_in_list_subscript: MissingCompileTimeError
-void/void_type_usage_test/param_use_in_map_lookup: MissingCompileTimeError
-void/void_type_usage_test/param_use_in_string_interpolation: MissingCompileTimeError
-void/void_type_usage_test/param_while: MissingCompileTimeError
-void/void_type_usage_test/paren_addition: MissingCompileTimeError
-void/void_type_usage_test/paren_argument: MissingCompileTimeError
-void/void_type_usage_test/paren_boolean_and_left: MissingCompileTimeError
-void/void_type_usage_test/paren_boolean_and_right: MissingCompileTimeError
-void/void_type_usage_test/paren_boolean_negation: MissingCompileTimeError
-void/void_type_usage_test/paren_boolean_or_left: MissingCompileTimeError
-void/void_type_usage_test/paren_boolean_or_right: MissingCompileTimeError
-void/void_type_usage_test/paren_cascade: MissingCompileTimeError
-void/void_type_usage_test/paren_conditional_stmt: MissingCompileTimeError
-void/void_type_usage_test/paren_do_while: MissingCompileTimeError
-void/void_type_usage_test/paren_dynamic_init: MissingCompileTimeError
-void/void_type_usage_test/paren_equals_left: MissingCompileTimeError
-void/void_type_usage_test/paren_equals_right: MissingCompileTimeError
-void/void_type_usage_test/paren_for_in: MissingCompileTimeError
-void/void_type_usage_test/paren_identical: MissingCompileTimeError
-void/void_type_usage_test/paren_is: MissingCompileTimeError
-void/void_type_usage_test/paren_literal_list_init: MissingCompileTimeError
-void/void_type_usage_test/paren_literal_map_key_init2: MissingCompileTimeError
-void/void_type_usage_test/paren_literal_map_value_init2: MissingCompileTimeError
-void/void_type_usage_test/paren_multiplication: MissingCompileTimeError
-void/void_type_usage_test/paren_null_dot: MissingCompileTimeError
-void/void_type_usage_test/paren_null_equals1: MissingCompileTimeError
-void/void_type_usage_test/paren_return: MissingCompileTimeError # Issue 32804
-void/void_type_usage_test/paren_throw: MissingCompileTimeError
-void/void_type_usage_test/paren_toString: MissingCompileTimeError
-void/void_type_usage_test/paren_use_in_conditional_assignment_right: MissingCompileTimeError
-void/void_type_usage_test/paren_use_in_list_subscript: MissingCompileTimeError
-void/void_type_usage_test/paren_use_in_map_lookup: MissingCompileTimeError
-void/void_type_usage_test/paren_use_in_string_interpolation: MissingCompileTimeError
-void/void_type_usage_test/paren_while: MissingCompileTimeError
-void/void_type_usage_test/sync_use_in_yield: MissingCompileTimeError
-void/void_type_usage_test/sync_use_in_yield_star: MissingCompileTimeError
-void/void_type_usage_test/void_default_parameter_closure: MissingCompileTimeError
-void/void_type_usage_test/void_default_parameter_global: MissingCompileTimeError
 
 [ $compiler != dart2analyzer && $fasta && $strong ]
 map_literal3_test/03: MissingCompileTimeError
diff --git a/tests/lib_2/lib_2_kernel.status b/tests/lib_2/lib_2_kernel.status
index 94ddd5c..2c1250c 100644
--- a/tests/lib_2/lib_2_kernel.status
+++ b/tests/lib_2/lib_2_kernel.status
@@ -217,9 +217,6 @@
 [ $system == windows && ($compiler == dartk || $compiler == dartkb) ]
 isolate/ping_pause_test: Skip # Issues 32137 and 32138
 
-[ $fasta && $strong ]
-mirrors/top_level_accessors_test/01: MissingCompileTimeError
-
 [ $fasta && !$strong ]
 isolate/isolate_import_test/01: MissingCompileTimeError
 isolate/isolate_stress_test: CompileTimeError
@@ -293,7 +290,6 @@
 mirrors/redirecting_factory_different_type_test/02: MissingCompileTimeError
 mirrors/redirecting_factory_different_type_test/none: RuntimeError
 mirrors/redirecting_factory_reflection_test: RuntimeError
-mirrors/top_level_accessors_test/01: MissingCompileTimeError
 
 # ===== Skip dartk and darkp in !$strong mode ====
 [ !$strong && ($compiler == dartk || $compiler == dartkb) ]