diff --git a/.dart_tool/package_config.json b/.dart_tool/package_config.json
index 81fe255..b6def05 100644
--- a/.dart_tool/package_config.json
+++ b/.dart_tool/package_config.json
@@ -11,7 +11,7 @@
     "constraint, update this by running tools/generate_package_config.dart."
   ],
   "configVersion": 2,
-  "generated": "2021-08-23T16:52:51.727804",
+  "generated": "2021-09-01T12:41:37.776425",
   "generator": "tools/generate_package_config.dart",
   "packages": [
     {
@@ -316,7 +316,7 @@
       "name": "front_end",
       "rootUri": "../pkg/front_end",
       "packageUri": "lib/",
-      "languageVersion": "2.12"
+      "languageVersion": "2.13"
     },
     {
       "name": "front_end_testcases",
diff --git a/pkg/front_end/analysis_options.yaml b/pkg/front_end/analysis_options.yaml
index 8a17b97..b82914b 100644
--- a/pkg/front_end/analysis_options.yaml
+++ b/pkg/front_end/analysis_options.yaml
@@ -19,4 +19,5 @@
     - lines_longer_than_80_chars
     - unrelated_type_equality_checks
     - annotate_overrides
+    - always_declare_return_types
     # - always_specify_types
diff --git a/pkg/front_end/benchmarks/ikg/dart2js.dart b/pkg/front_end/benchmarks/ikg/dart2js.dart
index 3877ff2..004709e 100644
--- a/pkg/front_end/benchmarks/ikg/dart2js.dart
+++ b/pkg/front_end/benchmarks/ikg/dart2js.dart
@@ -6,4 +6,4 @@
 
 import 'package:compiler/src/dart2js.dart' as dart2js;
 
-main(args) => dart2js.main(args);
+void main(args) => dart2js.main(args);
diff --git a/pkg/front_end/benchmarks/ikg/hello.dart b/pkg/front_end/benchmarks/ikg/hello.dart
index dca2fae..f4591c1 100644
--- a/pkg/front_end/benchmarks/ikg/hello.dart
+++ b/pkg/front_end/benchmarks/ikg/hello.dart
@@ -2,4 +2,4 @@
 // 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.
 
-main() => print('hello world');
+void main() => print('hello world');
diff --git a/pkg/front_end/lib/src/base/libraries_specification.dart b/pkg/front_end/lib/src/base/libraries_specification.dart
index bd2824f..ad345f4 100644
--- a/pkg/front_end/lib/src/base/libraries_specification.dart
+++ b/pkg/front_end/lib/src/base/libraries_specification.dart
@@ -137,20 +137,19 @@
       if (targetName.startsWith("comment:")) return null;
       Map<String, LibraryInfo> libraries = <String, LibraryInfo>{};
       if (targetData is! Map) {
-        return _reportError(
-            "target specification for '$targetName' is not a map");
+        _reportError("target specification for '$targetName' is not a map");
       }
       if (!targetData.containsKey("libraries")) {
-        return _reportError("target specification "
+        _reportError("target specification "
             "for '$targetName' doesn't have a libraries entry");
       }
       dynamic librariesData = targetData["libraries"];
       if (librariesData is! Map<String, dynamic>) {
-        return _reportError("libraries entry for '$targetName' is not a map");
+        _reportError("libraries entry for '$targetName' is not a map");
       }
       librariesData.forEach((String name, data) {
         if (data is! Map<String, dynamic>) {
-          return _reportError(
+          _reportError(
               "library data for '$name' in target '$targetName' is not a map");
         }
         Uri checkAndResolve(uriString) {
@@ -175,13 +174,12 @@
         } else if (data['patches'] == null) {
           patches = const [];
         } else {
-          return _reportError(
-              "patches entry for '$name' is not a list or a string");
+          _reportError("patches entry for '$name' is not a list or a string");
         }
 
         dynamic supported = data['supported'] ?? true;
         if (supported is! bool) {
-          return _reportError("\"supported\" entry: expected a 'bool' but "
+          _reportError("\"supported\" entry: expected a 'bool' but "
               "got a '${supported.runtimeType}' ('$supported')");
         }
         libraries[name] =
@@ -193,7 +191,7 @@
     return new LibrariesSpecification(targets);
   }
 
-  static _reportError(String error) =>
+  static Never _reportError(String error) =>
       throw new LibrariesSpecificationException(error);
 
   /// Serialize this specification to json.
diff --git a/pkg/front_end/lib/src/base/processed_options.dart b/pkg/front_end/lib/src/base/processed_options.dart
index 8b01e29..219a798 100644
--- a/pkg/front_end/lib/src/base/processed_options.dart
+++ b/pkg/front_end/lib/src/base/processed_options.dart
@@ -793,7 +793,7 @@
 
   String debugString() {
     StringBuffer sb = new StringBuffer();
-    writeList(String name, List elements) {
+    void writeList(String name, List elements) {
       if (elements.isEmpty) {
         sb.writeln('$name: <empty>');
         return;
diff --git a/pkg/front_end/lib/src/fasta/crash.dart b/pkg/front_end/lib/src/fasta/crash.dart
index c36cf76..c9a8700 100644
--- a/pkg/front_end/lib/src/fasta/crash.dart
+++ b/pkg/front_end/lib/src/fasta/crash.dart
@@ -50,7 +50,7 @@
 
 Future<T> reportCrash<T>(error, StackTrace trace,
     [Uri? uri, int? charOffset]) async {
-  note(String note) async {
+  Future<void> note(String note) async {
     stderr.write(note);
     await stderr.flush();
   }
diff --git a/pkg/front_end/lib/src/fasta/incremental_compiler.dart b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
index 7d5852e..6a57d1d 100644
--- a/pkg/front_end/lib/src/fasta/incremental_compiler.dart
+++ b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
@@ -2097,7 +2097,7 @@
       return false;
     }
 
-    addBuilderAndInvalidateUris(Uri uri, LibraryBuilder libraryBuilder) {
+    void addBuilderAndInvalidateUris(Uri uri, LibraryBuilder libraryBuilder) {
       if (uri.scheme == "dart" && !libraryBuilder.isSynthetic) {
         if (seenUris.add(libraryBuilder.importUri)) {
           reusedLibraries.add(libraryBuilder);
diff --git a/pkg/front_end/lib/src/fasta/incremental_serializer.dart b/pkg/front_end/lib/src/fasta/incremental_serializer.dart
index c9d9a0b..5803a9a 100644
--- a/pkg/front_end/lib/src/fasta/incremental_serializer.dart
+++ b/pkg/front_end/lib/src/fasta/incremental_serializer.dart
@@ -256,7 +256,7 @@
 
   /// Add the group but not its dependencies to the output if they weren't added
   /// already.
-  addDataButNotDependentData(SerializationGroup group,
+  void addDataButNotDependentData(SerializationGroup group,
       Set<SerializationGroup> cachedPackagesInOutput, Sink<List<int>> sink) {
     if (cachedPackagesInOutput.add(group)) {
       sink.add(group.serializedData);
@@ -265,7 +265,7 @@
 
   /// Add the group and its dependencies to the output if they weren't added
   /// already.
-  addDataAndDependentData(SerializationGroup group,
+  void addDataAndDependentData(SerializationGroup group,
       Set<SerializationGroup> cachedPackagesInOutput, Sink<List<int>> sink) {
     if (cachedPackagesInOutput.add(group)) {
       sink.add(group.serializedData);
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index 8ae41af..5bc202c 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -1859,7 +1859,7 @@
   }
 
   @override
-  /* Expression | Generator | Initializer */ finishSend(Object receiver,
+  Expression_Generator_Initializer finishSend(Object receiver,
       List<UnresolvedType>? typeArguments, Arguments arguments, int charOffset,
       {bool isTypeArgumentsInForest = false}) {
     if (receiver is Generator) {
@@ -2445,7 +2445,7 @@
   /// implies that it shouldn't be turned into a [ThisPropertyAccessGenerator]
   /// if the name doesn't resolve in the scope).
   @override
-  /*Generator|Expression|Builder*/ scopeLookup(
+  Expression_Generator_Builder scopeLookup(
       Scope scope, String name, Token token,
       {bool isQualified: false, PrefixBuilder? prefix}) {
     int charOffset = offsetForToken(token);
@@ -7444,7 +7444,7 @@
   _BodyBuilderCloner(this.bodyBuilder);
 
   @override
-  visitStaticInvocation(StaticInvocation node) {
+  TreeNode visitStaticInvocation(StaticInvocation node) {
     if (node is FactoryConstructorInvocation) {
       FactoryConstructorInvocation result = new FactoryConstructorInvocation(
           node.target, clone(node.arguments),
@@ -7464,7 +7464,7 @@
   }
 
   @override
-  visitConstructorInvocation(ConstructorInvocation node) {
+  TreeNode visitConstructorInvocation(ConstructorInvocation node) {
     if (node is TypeAliasedConstructorInvocation) {
       TypeAliasedConstructorInvocation result =
           new TypeAliasedConstructorInvocation(
@@ -7478,7 +7478,7 @@
   }
 
   @override
-  visitArguments(Arguments node) {
+  TreeNode visitArguments(Arguments node) {
     if (node is ArgumentsImpl) {
       return ArgumentsImpl.clone(node, node.positional.map(clone).toList(),
           node.named.map(clone).toList(), node.types.map(visitType).toList());
diff --git a/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart b/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
index a4161b0..de4d7ba 100644
--- a/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
@@ -215,11 +215,11 @@
   ///
   /// If the invocation has explicit type arguments
   /// [buildTypeWithResolvedArguments] called instead.
-  /* Expression | Generator | Initializer */ doInvocation(
+  Expression_Generator_Initializer doInvocation(
       int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false});
 
-  /* Expression | Generator */ buildSelectorAccess(
+  Expression_Generator buildSelectorAccess(
       Selector send, int operatorOffset, bool isNullAware) {
     if (send is InvocationSelector) {
       return _helper.buildMethodInvocation(buildSimpleRead(), send.name,
@@ -237,7 +237,7 @@
     }
   }
 
-  /*Expression | Generator*/ buildEqualsOperation(Token token, Expression right,
+  Expression_Generator buildEqualsOperation(Token token, Expression right,
       {required bool isNot}) {
     // ignore: unnecessary_null_comparison
     assert(isNot != null);
@@ -245,18 +245,18 @@
         isNot: isNot);
   }
 
-  /*Expression | Generator*/ buildBinaryOperation(
+  Expression_Generator buildBinaryOperation(
       Token token, Name binaryName, Expression right) {
     return _forest.createBinary(
         offsetForToken(token), buildSimpleRead(), binaryName, right);
   }
 
-  /*Expression | Generator*/ buildUnaryOperation(Token token, Name unaryName) {
+  Expression_Generator buildUnaryOperation(Token token, Name unaryName) {
     return _forest.createUnary(
         offsetForToken(token), unaryName, buildSimpleRead());
   }
 
-  /*Expression|Generator*/ applyTypeArguments(
+  Expression_Generator applyTypeArguments(
       int fileOffset, List<UnresolvedType>? typeArguments) {
     return new Instantiation(
         buildSimpleRead(), _helper.buildDartTypeArguments(typeArguments))
@@ -2625,8 +2625,9 @@
         isNullAware: isNullAware);
   }
 
-  /* Expression | Generator */ @override
-  buildSelectorAccess(Selector send, int operatorOffset, bool isNullAware) {
+  @override
+  Expression_Generator buildSelectorAccess(
+      Selector send, int operatorOffset, bool isNullAware) {
     if (_helper.constantContext != ConstantContext.none) {
       _helper.addProblem(
           messageNotAConstantExpression, fileOffset, token.length);
@@ -2643,7 +2644,8 @@
   }
 
   @override
-  buildBinaryOperation(Token token, Name binaryName, Expression right) {
+  Expression_Generator buildBinaryOperation(
+      Token token, Name binaryName, Expression right) {
     int fileOffset = offsetForToken(token);
     Generator generator = _createInstanceAccess(token, binaryName);
     return generator.doInvocation(fileOffset, null,
@@ -2651,7 +2653,7 @@
   }
 
   @override
-  buildUnaryOperation(Token token, Name unaryName) {
+  Expression_Generator buildUnaryOperation(Token token, Name unaryName) {
     int fileOffset = offsetForToken(token);
     Generator generator = _createInstanceAccess(token, unaryName);
     return generator.doInvocation(
@@ -2659,7 +2661,7 @@
   }
 
   @override
-  doInvocation(
+  Expression_Generator_Initializer doInvocation(
       int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false}) {
     Generator generator = _createInstanceAccess(token, callName);
@@ -2860,7 +2862,8 @@
   }
 
   @override
-  buildSelectorAccess(Selector send, int operatorOffset, bool isNullAware) {
+  Expression_Generator buildSelectorAccess(
+      Selector send, int operatorOffset, bool isNullAware) {
     Object propertyAccess =
         suffixGenerator.buildSelectorAccess(send, operatorOffset, isNullAware);
     if (propertyAccess is Generator) {
@@ -2914,7 +2917,7 @@
   }
 
   @override
-  doInvocation(
+  Expression_Generator_Initializer doInvocation(
       int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false}) {
     Object suffix = suffixGenerator.doInvocation(
@@ -3098,7 +3101,8 @@
   }
 
   @override
-  buildSelectorAccess(Selector send, int operatorOffset, bool isNullAware) {
+  Expression_Generator buildSelectorAccess(
+      Selector send, int operatorOffset, bool isNullAware) {
     int nameOffset = offsetForToken(send.token);
     Name name = send.name;
     Arguments? arguments = send.arguments;
@@ -3326,7 +3330,7 @@
   }
 
   @override
-  doInvocation(
+  Expression_Generator_Builder doInvocation(
       int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false}) {
     if (declaration.isExtension) {
@@ -3363,7 +3367,8 @@
   }
 
   @override
-  applyTypeArguments(int fileOffset, List<UnresolvedType>? typeArguments) {
+  Expression_Generator applyTypeArguments(
+      int fileOffset, List<UnresolvedType>? typeArguments) {
     return new TypeUseGenerator(_helper, token, declaration, targetName)
       ..typeArguments = typeArguments;
   }
@@ -3509,7 +3514,7 @@
   }
 
   @override
-  doInvocation(
+  Expression_Generator_Initializer doInvocation(
       int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false}) {
     return _helper.forest.createExpressionInvocation(
@@ -3564,7 +3569,7 @@
   }
 
   @override
-  doInvocation(
+  Expression_Generator_Initializer doInvocation(
       int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false}) {
     return buildError(arguments,
@@ -3572,7 +3577,8 @@
   }
 
   @override
-  buildSelectorAccess(Selector send, int operatorOffset, bool isNullAware) {
+  Expression_Generator buildSelectorAccess(
+      Selector send, int operatorOffset, bool isNullAware) {
     return send.withReceiver(buildSimpleRead(), operatorOffset,
         isNullAware: isNullAware);
   }
@@ -3765,7 +3771,7 @@
   }
 
   @override
-  Expression doInvocation(
+  Never doInvocation(
       int charOffset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false}) {
     return unhandled("${runtimeType}", "doInvocation", charOffset, _uri);
@@ -3804,7 +3810,7 @@
   }
 
   @override
-  _makeInvalidRead([UnresolvedKind? unresolvedKind]) {
+  Never _makeInvalidRead([UnresolvedKind? unresolvedKind]) {
     return unsupported("makeInvalidRead", token.charOffset, _helper.uri);
   }
 
@@ -4011,7 +4017,7 @@
   }
 
   @override
-  /* Expression | Generator | Initializer */ doInvocation(
+  Expression doInvocation(
       int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false}) {
     return _helper.wrapInLocatedProblem(
@@ -4022,7 +4028,7 @@
   }
 
   @override
-  /* Expression | Generator */ buildSelectorAccess(
+  Expression_Generator buildSelectorAccess(
       Selector send, int operatorOffset, bool isNullAware) {
     assert(send.name.text == send.token.lexeme,
         "'${send.name.text}' != ${send.token.lexeme}");
@@ -4400,7 +4406,8 @@
   }
 
   @override
-  buildSelectorAccess(Selector send, int operatorOffset, bool isNullAware) {
+  Expression_Generator buildSelectorAccess(
+      Selector send, int operatorOffset, bool isNullAware) {
     Name name = send.name;
     Arguments? arguments = send.arguments;
     int offset = offsetForToken(send.token);
@@ -4451,7 +4458,7 @@
   }
 
   @override
-  doInvocation(
+  Expression_Generator_Initializer doInvocation(
       int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
       {bool isTypeArgumentsInForest = false}) {
     if (isInitializer) {
@@ -4465,7 +4472,8 @@
   }
 
   @override
-  buildEqualsOperation(Token token, Expression right, {required bool isNot}) {
+  Expression_Generator buildEqualsOperation(Token token, Expression right,
+      {required bool isNot}) {
     // ignore: unnecessary_null_comparison
     assert(isNot != null);
     if (isSuper) {
@@ -4485,7 +4493,8 @@
   }
 
   @override
-  buildBinaryOperation(Token token, Name binaryName, Expression right) {
+  Expression_Generator buildBinaryOperation(
+      Token token, Name binaryName, Expression right) {
     if (isSuper) {
       int offset = offsetForToken(token);
       return _helper.buildMethodInvocation(
@@ -4499,7 +4508,7 @@
   }
 
   @override
-  buildUnaryOperation(Token token, Name unaryName) {
+  Expression_Generator buildUnaryOperation(Token token, Name unaryName) {
     if (isSuper) {
       int offset = offsetForToken(token);
       return _helper.buildMethodInvocation(
@@ -4650,7 +4659,7 @@
   }
 
   @override
-  doInvocation(
+  Generator doInvocation(
           int offset, List<UnresolvedType>? typeArguments, Arguments arguments,
           {bool isTypeArgumentsInForest = false}) =>
       this;
@@ -4705,8 +4714,9 @@
   @override
   String get _debugName => "ParenthesizedExpressionGenerator";
 
-  /* Expression | Generator */ @override
-  buildSelectorAccess(Selector send, int operatorOffset, bool isNullAware) {
+  @override
+  Expression_Generator buildSelectorAccess(
+      Selector send, int operatorOffset, bool isNullAware) {
     if (send is InvocationSelector) {
       return _helper.buildMethodInvocation(
           _createRead(), send.name, send.arguments, offsetForToken(send.token),
@@ -4763,8 +4773,7 @@
   Name get name;
 
   /// Applies this selector to [receiver].
-  /* Expression | Generator */ withReceiver(
-      Object? receiver, int operatorOffset,
+  Expression_Generator withReceiver(Object? receiver, int operatorOffset,
       {bool isNullAware: false});
 
   List<UnresolvedType>? get typeArguments => null;
@@ -4826,7 +4835,7 @@
   String get _debugName => 'InvocationSelector';
 
   @override
-  withReceiver(Object? receiver, int operatorOffset,
+  Expression_Generator withReceiver(Object? receiver, int operatorOffset,
       {bool isNullAware: false}) {
     if (receiver is Generator) {
       return receiver.buildSelectorAccess(this, operatorOffset, isNullAware);
@@ -4868,7 +4877,7 @@
   String get _debugName => 'PropertySelector';
 
   @override
-  withReceiver(Object? receiver, int operatorOffset,
+  Expression_Generator withReceiver(Object? receiver, int operatorOffset,
       {bool isNullAware: false}) {
     if (receiver is Generator) {
       return receiver.buildSelectorAccess(this, operatorOffset, isNullAware);
diff --git a/pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart b/pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart
index 70eb4d1..34a7c19 100644
--- a/pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart
@@ -44,6 +44,15 @@
         Typedef,
         VariableDeclaration;
 
+/// Alias for Expression | Generator
+typedef Expression_Generator = dynamic;
+
+/// Alias for Expression | Generator | Builder
+typedef Expression_Generator_Builder = dynamic;
+
+/// Alias for Expression | Generator | Initializer
+typedef Expression_Generator_Initializer = dynamic;
+
 abstract class ExpressionGeneratorHelper implements InferenceHelper {
   SourceLibraryBuilder get libraryBuilder;
 
@@ -66,11 +75,11 @@
 
   bool get enableConstructorTearOffsInLibrary;
 
-  /* Generator | Expression | Builder */ scopeLookup(
+  Expression_Generator_Builder scopeLookup(
       Scope scope, String name, Token token,
       {bool isQualified: false, PrefixBuilder? prefix});
 
-  /* Expression | Generator | Initializer */ finishSend(Object receiver,
+  Expression_Generator_Initializer finishSend(Object receiver,
       List<UnresolvedType>? typeArguments, Arguments arguments, int offset,
       {bool isTypeArgumentsInForest = false});
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/forest.dart b/pkg/front_end/lib/src/fasta/kernel/forest.dart
index 670c4bc..12ba226 100644
--- a/pkg/front_end/lib/src/fasta/kernel/forest.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/forest.dart
@@ -885,17 +885,17 @@
   }
 
   @override
-  visitChildren(v) {
+  Never visitChildren(v) {
     throw unsupported("visitChildren", fileOffset, uri);
   }
 
   @override
-  transformChildren(v) {
+  Never transformChildren(v) {
     throw unsupported("transformChildren", fileOffset, uri);
   }
 
   @override
-  transformOrRemoveChildren(v) {
+  Never transformOrRemoveChildren(v) {
     throw unsupported("transformOrRemoveChildren", fileOffset, uri);
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/implicit_field_type.dart b/pkg/front_end/lib/src/fasta/kernel/implicit_field_type.dart
index 3ea57a0..c4f1db7 100644
--- a/pkg/front_end/lib/src/fasta/kernel/implicit_field_type.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/implicit_field_type.dart
@@ -48,7 +48,7 @@
   }
 
   @override
-  visitChildren(Visitor<dynamic> v) {
+  Never visitChildren(Visitor<dynamic> v) {
     unsupported("visitChildren", fieldBuilder.charOffset, fieldBuilder.fileUri);
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/implicit_type_argument.dart b/pkg/front_end/lib/src/fasta/kernel/implicit_type_argument.dart
index 5582ac5..e30af66 100644
--- a/pkg/front_end/lib/src/fasta/kernel/implicit_type_argument.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/implicit_type_argument.dart
@@ -37,7 +37,7 @@
   }
 
   @override
-  visitChildren(Visitor v) {
+  Never visitChildren(Visitor v) {
     unhandled("$runtimeType", "${v.runtimeType}", -1, null);
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/verifier.dart b/pkg/front_end/lib/src/fasta/kernel/verifier.dart
index 0a3ac49..efc9de8 100644
--- a/pkg/front_end/lib/src/fasta/kernel/verifier.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/verifier.dart
@@ -179,7 +179,7 @@
   }
 
   @override
-  problem(TreeNode? node, String details,
+  void problem(TreeNode? node, String details,
       {TreeNode? context, TreeNode? origin}) {
     node ??= (context ?? currentClassOrExtensionOrMember);
     int offset = node?.fileOffset ?? -1;
@@ -446,7 +446,7 @@
   FastaVerifyGetStaticType(TypeEnvironment env, this.skipPlatform) : super(env);
 
   @override
-  visitLibrary(Library node) {
+  void visitLibrary(Library node) {
     // 'dart:test' is used in the unit tests and isn't an actual part of the
     // platform.
     if (skipPlatform &&
diff --git a/pkg/front_end/lib/src/fasta/modifier.dart b/pkg/front_end/lib/src/fasta/modifier.dart
index 8cee002..127ce5c 100644
--- a/pkg/front_end/lib/src/fasta/modifier.dart
+++ b/pkg/front_end/lib/src/fasta/modifier.dart
@@ -89,7 +89,7 @@
   }
 
   @override
-  toString() => "modifier(${'$kind'.substring('ModifierEnum.'.length)})";
+  String toString() => "modifier(${'$kind'.substring('ModifierEnum.'.length)})";
 
   static int toMask(List<Modifier>? modifiers) {
     int result = 0;
diff --git a/pkg/front_end/lib/src/fasta/problems.dart b/pkg/front_end/lib/src/fasta/problems.dart
index c373f2f..eea59f1 100644
--- a/pkg/front_end/lib/src/fasta/problems.dart
+++ b/pkg/front_end/lib/src/fasta/problems.dart
@@ -35,7 +35,7 @@
                 .withoutLocation();
 
   @override
-  toString() => "DebugAbort: ${message.message}";
+  String toString() => "DebugAbort: ${message.message}";
 }
 
 /// Used to report an internal error.
diff --git a/pkg/front_end/lib/src/fasta/scope.dart b/pkg/front_end/lib/src/fasta/scope.dart
index 6cf5051..f6e9a39 100644
--- a/pkg/front_end/lib/src/fasta/scope.dart
+++ b/pkg/front_end/lib/src/fasta/scope.dart
@@ -686,8 +686,6 @@
 
   ProblemBuilder(this.name, this.builder, this.charOffset, this.fileUri);
 
-  get target => null;
-
   @override
   bool get hasProblem => true;
 
diff --git a/pkg/front_end/lib/src/fasta/source/directive_listener.dart b/pkg/front_end/lib/src/fasta/source/directive_listener.dart
index a7915a4..ef44416 100644
--- a/pkg/front_end/lib/src/fasta/source/directive_listener.dart
+++ b/pkg/front_end/lib/src/fasta/source/directive_listener.dart
@@ -37,7 +37,7 @@
   DirectiveListener();
 
   @override
-  beginExport(Token export) {
+  void beginExport(Token export) {
     _combinators = <NamespaceCombinator>[];
   }
 
@@ -47,7 +47,7 @@
   }
 
   @override
-  beginImport(Token import) {
+  void beginImport(Token import) {
     _combinators = <NamespaceCombinator>[];
   }
 
@@ -59,7 +59,7 @@
   }
 
   @override
-  beginPart(Token part) {
+  void beginPart(Token part) {
     _inPart = true;
   }
 
@@ -69,7 +69,7 @@
   }
 
   @override
-  endExport(Token export, Token semicolon) {
+  void endExport(Token export, Token semicolon) {
     exports.add(new NamespaceDirective.export(_uri, _combinators));
     _uri = null;
     _combinators = null;
@@ -82,14 +82,14 @@
   }
 
   @override
-  endImport(Token? import, Token? semicolon) {
+  void endImport(Token? import, Token? semicolon) {
     imports.add(new NamespaceDirective.import(_uri, _combinators));
     _uri = null;
     _combinators = null;
   }
 
   @override
-  endPart(Token part, Token semicolon) {
+  void endPart(Token part, Token semicolon) {
     parts.add(_uri);
     _uri = null;
     _inPart = false;
diff --git a/pkg/front_end/lib/src/fasta/source/stack_listener_impl.dart b/pkg/front_end/lib/src/fasta/source/stack_listener_impl.dart
index 2a40803..fa89f68 100644
--- a/pkg/front_end/lib/src/fasta/source/stack_listener_impl.dart
+++ b/pkg/front_end/lib/src/fasta/source/stack_listener_impl.dart
@@ -63,7 +63,7 @@
 
   /// Used to report an internal error encountered in the stack listener.
   @override
-  internalProblem(Message message, int charOffset, Uri uri) {
+  Never internalProblem(Message message, int charOffset, Uri uri) {
     return problems.internalProblem(message, charOffset, uri);
   }
 
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_schema.dart b/pkg/front_end/lib/src/fasta/type_inference/type_schema.dart
index 9be3b48..acd6439 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_schema.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_schema.dart
@@ -47,7 +47,7 @@
             annotator: annotator);
 
   @override
-  defaultDartType(covariant UnknownType node) {
+  void defaultDartType(covariant UnknownType node) {
     writeWord('?');
   }
 }
diff --git a/pkg/front_end/lib/src/fasta/util/direct_parser_ast.dart b/pkg/front_end/lib/src/fasta/util/direct_parser_ast.dart
index dd6f52e..14d5e17 100644
--- a/pkg/front_end/lib/src/fasta/util/direct_parser_ast.dart
+++ b/pkg/front_end/lib/src/fasta/util/direct_parser_ast.dart
@@ -1152,7 +1152,7 @@
   }
 }
 
-main(List<String> args) {
+void main(List<String> args) {
   File f = new File(args[0]);
   Uint8List data = f.readAsBytesSync();
   DirectParserASTContent ast = getAST(data);
diff --git a/pkg/front_end/lib/src/fasta/util/textual_outline.dart b/pkg/front_end/lib/src/fasta/util/textual_outline.dart
index 0bd4b47..fe35178 100644
--- a/pkg/front_end/lib/src/fasta/util/textual_outline.dart
+++ b/pkg/front_end/lib/src/fasta/util/textual_outline.dart
@@ -656,7 +656,7 @@
   _currentUnknown.interimEnd = null;
 }
 
-main(List<String> args) {
+void main(List<String> args) {
   File f = new File(args[0]);
   Uint8List data = f.readAsBytesSync();
   ScannerConfiguration scannerConfiguration = new ScannerConfiguration();
@@ -822,12 +822,12 @@
   List<String>? _combinatorNames;
 
   @override
-  beginExport(Token export) {
+  void beginExport(Token export) {
     _combinators = <_NamespaceCombinator>[];
   }
 
   @override
-  beginImport(Token import) {
+  void beginImport(Token import) {
     _combinators = <_NamespaceCombinator>[];
   }
 
diff --git a/pkg/front_end/lib/src/testing/id_extractor.dart b/pkg/front_end/lib/src/testing/id_extractor.dart
index 705c783..0f7429d 100644
--- a/pkg/front_end/lib/src/testing/id_extractor.dart
+++ b/pkg/front_end/lib/src/testing/id_extractor.dart
@@ -167,19 +167,19 @@
   }
 
   @override
-  defaultNode(Node node) {
+  void defaultNode(Node node) {
     node.visitChildren(this);
   }
 
   @override
-  visitProcedure(Procedure node) {
+  void visitProcedure(Procedure node) {
     // Avoid visiting annotations.
     node.function.accept(this);
     computeForMember(node);
   }
 
   @override
-  visitConstructor(Constructor node) {
+  void visitConstructor(Constructor node) {
     // Avoid visiting annotations.
     visitList(node.initializers, this);
     node.function.accept(this);
@@ -187,13 +187,13 @@
   }
 
   @override
-  visitField(Field node) {
+  void visitField(Field node) {
     // Avoid visiting annotations.
     node.initializer?.accept(this);
     computeForMember(node);
   }
 
-  _visitInvocation(Expression node, Name name) {
+  void _visitInvocation(Expression node, Name name) {
     if (name.text == '[]') {
       computeForNode(node, computeDefaultNodeId(node));
     } else if (name.text == '[]=') {
@@ -208,31 +208,31 @@
   }
 
   @override
-  visitDynamicInvocation(DynamicInvocation node) {
+  void visitDynamicInvocation(DynamicInvocation node) {
     _visitInvocation(node, node.name);
     super.visitDynamicInvocation(node);
   }
 
   @override
-  visitFunctionInvocation(FunctionInvocation node) {
+  void visitFunctionInvocation(FunctionInvocation node) {
     _visitInvocation(node, node.name);
     super.visitFunctionInvocation(node);
   }
 
   @override
-  visitLocalFunctionInvocation(LocalFunctionInvocation node) {
+  void visitLocalFunctionInvocation(LocalFunctionInvocation node) {
     computeForNode(node, createInvokeId(node));
     super.visitLocalFunctionInvocation(node);
   }
 
   @override
-  visitEqualsCall(EqualsCall node) {
+  void visitEqualsCall(EqualsCall node) {
     _visitInvocation(node, Name.equalsName);
     super.visitEqualsCall(node);
   }
 
   @override
-  visitEqualsNull(EqualsNull node) {
+  void visitEqualsNull(EqualsNull node) {
     Expression receiver = node.expression;
     if (receiver is VariableGet && receiver.variable.name == null) {
       // This is a desugared `?.`.
@@ -243,48 +243,48 @@
   }
 
   @override
-  visitInstanceInvocation(InstanceInvocation node) {
+  void visitInstanceInvocation(InstanceInvocation node) {
     _visitInvocation(node, node.name);
     super.visitInstanceInvocation(node);
   }
 
   @override
-  visitInstanceGetterInvocation(InstanceGetterInvocation node) {
+  void visitInstanceGetterInvocation(InstanceGetterInvocation node) {
     _visitInvocation(node, node.name);
     super.visitInstanceGetterInvocation(node);
   }
 
   @override
-  visitLoadLibrary(LoadLibrary node) {
+  void visitLoadLibrary(LoadLibrary node) {
     computeForNode(node, createInvokeId(node));
   }
 
   @override
-  visitDynamicGet(DynamicGet node) {
+  void visitDynamicGet(DynamicGet node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitDynamicGet(node);
   }
 
   @override
-  visitFunctionTearOff(FunctionTearOff node) {
+  void visitFunctionTearOff(FunctionTearOff node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitFunctionTearOff(node);
   }
 
   @override
-  visitInstanceGet(InstanceGet node) {
+  void visitInstanceGet(InstanceGet node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitInstanceGet(node);
   }
 
   @override
-  visitInstanceTearOff(InstanceTearOff node) {
+  void visitInstanceTearOff(InstanceTearOff node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitInstanceTearOff(node);
   }
 
   @override
-  visitVariableDeclaration(VariableDeclaration node) {
+  void visitVariableDeclaration(VariableDeclaration node) {
     if (node.name != null && node.parent is! FunctionDeclaration) {
       // Skip synthetic variables and function declaration variables.
       computeForNode(node, computeDefaultNodeId(node));
@@ -294,7 +294,7 @@
   }
 
   @override
-  visitFunctionDeclaration(FunctionDeclaration node) {
+  void visitFunctionDeclaration(FunctionDeclaration node) {
     computeForNode(
         node,
         computeDefaultNodeId(node,
@@ -305,13 +305,13 @@
   }
 
   @override
-  visitFunctionExpression(FunctionExpression node) {
+  void visitFunctionExpression(FunctionExpression node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitFunctionExpression(node);
   }
 
   @override
-  visitVariableGet(VariableGet node) {
+  void visitVariableGet(VariableGet node) {
     if (node.variable.name != null && !node.variable.isFieldFormal) {
       // Skip use of synthetic variables.
       computeForNode(node, computeDefaultNodeId(node));
@@ -320,19 +320,19 @@
   }
 
   @override
-  visitDynamicSet(DynamicSet node) {
+  void visitDynamicSet(DynamicSet node) {
     computeForNode(node, createUpdateId(node));
     super.visitDynamicSet(node);
   }
 
   @override
-  visitInstanceSet(InstanceSet node) {
+  void visitInstanceSet(InstanceSet node) {
     computeForNode(node, createUpdateId(node));
     super.visitInstanceSet(node);
   }
 
   @override
-  visitVariableSet(VariableSet node) {
+  void visitVariableSet(VariableSet node) {
     if (node.variable.name != null) {
       // Skip use of synthetic variables.
       computeForNode(node, createUpdateId(node));
@@ -341,43 +341,43 @@
   }
 
   @override
-  visitExpressionStatement(ExpressionStatement node) {
+  void visitExpressionStatement(ExpressionStatement node) {
     computeForNode(node, createExpressionStatementId(node));
     return super.visitExpressionStatement(node);
   }
 
   @override
-  visitIfStatement(IfStatement node) {
+  void visitIfStatement(IfStatement node) {
     computeForNode(node, computeDefaultNodeId(node));
     return super.visitIfStatement(node);
   }
 
   @override
-  visitTryCatch(TryCatch node) {
+  void visitTryCatch(TryCatch node) {
     computeForNode(node, computeDefaultNodeId(node));
     return super.visitTryCatch(node);
   }
 
   @override
-  visitTryFinally(TryFinally node) {
+  void visitTryFinally(TryFinally node) {
     computeForNode(node, computeDefaultNodeId(node));
     return super.visitTryFinally(node);
   }
 
   @override
-  visitDoStatement(DoStatement node) {
+  void visitDoStatement(DoStatement node) {
     computeForNode(node, createLoopId(node));
     super.visitDoStatement(node);
   }
 
   @override
-  visitForStatement(ForStatement node) {
+  void visitForStatement(ForStatement node) {
     computeForNode(node, createLoopId(node));
     super.visitForStatement(node);
   }
 
   @override
-  visitForInStatement(ForInStatement node) {
+  void visitForInStatement(ForInStatement node) {
     computeForNode(node, createLoopId(node));
     computeForNode(node, createIteratorId(node));
     computeForNode(node, createCurrentId(node));
@@ -386,32 +386,32 @@
   }
 
   @override
-  visitWhileStatement(WhileStatement node) {
+  void visitWhileStatement(WhileStatement node) {
     computeForNode(node, createLoopId(node));
     super.visitWhileStatement(node);
   }
 
   @override
-  visitLabeledStatement(LabeledStatement node) {
+  void visitLabeledStatement(LabeledStatement node) {
     // TODO(johnniwinther): Call computeForNode for label statements that are
     // not placeholders for loop and switch targets.
     super.visitLabeledStatement(node);
   }
 
   @override
-  visitBreakStatement(BreakStatement node) {
+  void visitBreakStatement(BreakStatement node) {
     computeForNode(node, createGotoId(node));
     super.visitBreakStatement(node);
   }
 
   @override
-  visitSwitchStatement(SwitchStatement node) {
+  void visitSwitchStatement(SwitchStatement node) {
     computeForNode(node, createSwitchId(node));
     super.visitSwitchStatement(node);
   }
 
   @override
-  visitSwitchCase(SwitchCase node) {
+  void visitSwitchCase(SwitchCase node) {
     if (node.expressionOffsets.isNotEmpty) {
       computeForNode(node, createSwitchCaseId(node));
     }
@@ -419,13 +419,13 @@
   }
 
   @override
-  visitContinueSwitchStatement(ContinueSwitchStatement node) {
+  void visitContinueSwitchStatement(ContinueSwitchStatement node) {
     computeForNode(node, createGotoId(node));
     super.visitContinueSwitchStatement(node);
   }
 
   @override
-  visitConstantExpression(ConstantExpression node) {
+  void visitConstantExpression(ConstantExpression node) {
     // Implicit constants (for instance omitted field initializers, implicit
     // default values) and synthetic constants (for instance in noSuchMethod
     // forwarders) have no offset.
@@ -435,7 +435,7 @@
   }
 
   @override
-  visitNullLiteral(NullLiteral node) {
+  void visitNullLiteral(NullLiteral node) {
     // Synthetic null literals, for instance in locals and fields without
     // initializers, have no offset.
     computeForNode(
@@ -444,13 +444,13 @@
   }
 
   @override
-  visitBoolLiteral(BoolLiteral node) {
+  void visitBoolLiteral(BoolLiteral node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitBoolLiteral(node);
   }
 
   @override
-  visitIntLiteral(IntLiteral node) {
+  void visitIntLiteral(IntLiteral node) {
     // Synthetic ints literals, for instance in enum fields, have no offset.
     computeForNode(
         node, computeDefaultNodeId(node, skipNodeWithNoOffset: true));
@@ -458,13 +458,13 @@
   }
 
   @override
-  visitDoubleLiteral(DoubleLiteral node) {
+  void visitDoubleLiteral(DoubleLiteral node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitDoubleLiteral(node);
   }
 
   @override
-  visitStringLiteral(StringLiteral node) {
+  void visitStringLiteral(StringLiteral node) {
     // Synthetic string literals, for instance in enum fields, have no offset.
     computeForNode(
         node, computeDefaultNodeId(node, skipNodeWithNoOffset: true));
@@ -472,7 +472,7 @@
   }
 
   @override
-  visitListLiteral(ListLiteral node) {
+  void visitListLiteral(ListLiteral node) {
     // Synthetic list literals,for instance in noSuchMethod forwarders, have no
     // offset.
     computeForNode(
@@ -481,7 +481,7 @@
   }
 
   @override
-  visitMapLiteral(MapLiteral node) {
+  void visitMapLiteral(MapLiteral node) {
     // Synthetic map literals, for instance in noSuchMethod forwarders, have no
     // offset.
     computeForNode(
@@ -490,13 +490,13 @@
   }
 
   @override
-  visitSetLiteral(SetLiteral node) {
+  void visitSetLiteral(SetLiteral node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitSetLiteral(node);
   }
 
   @override
-  visitThisExpression(ThisExpression node) {
+  void visitThisExpression(ThisExpression node) {
     TreeNode parent = node.parent!;
     if (node.fileOffset == TreeNode.noOffset ||
         (parent is InstanceGet ||
@@ -511,13 +511,13 @@
   }
 
   @override
-  visitAwaitExpression(AwaitExpression node) {
+  void visitAwaitExpression(AwaitExpression node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitAwaitExpression(node);
   }
 
   @override
-  visitConstructorInvocation(ConstructorInvocation node) {
+  void visitConstructorInvocation(ConstructorInvocation node) {
     // Skip synthetic constructor invocations like for enum constants.
     // TODO(johnniwinther): Can [skipNodeWithNoOffset] be removed when dart2js
     // no longer test with cfe constants?
@@ -527,43 +527,43 @@
   }
 
   @override
-  visitStaticGet(StaticGet node) {
+  void visitStaticGet(StaticGet node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitStaticGet(node);
   }
 
   @override
-  visitStaticTearOff(StaticTearOff node) {
+  void visitStaticTearOff(StaticTearOff node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitStaticTearOff(node);
   }
 
   @override
-  visitStaticSet(StaticSet node) {
+  void visitStaticSet(StaticSet node) {
     computeForNode(node, createUpdateId(node));
     super.visitStaticSet(node);
   }
 
   @override
-  visitStaticInvocation(StaticInvocation node) {
+  void visitStaticInvocation(StaticInvocation node) {
     computeForNode(node, createInvokeId(node));
     super.visitStaticInvocation(node);
   }
 
   @override
-  visitThrow(Throw node) {
+  void visitThrow(Throw node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitThrow(node);
   }
 
   @override
-  visitRethrow(Rethrow node) {
+  void visitRethrow(Rethrow node) {
     computeForNode(node, computeDefaultNodeId(node));
     super.visitRethrow(node);
   }
 
   @override
-  visitAsExpression(AsExpression node) {
+  void visitAsExpression(AsExpression node) {
     if (node.isTypeError) {
       computeForNode(node, createImplicitAsId(node));
     } else {
@@ -573,33 +573,33 @@
   }
 
   @override
-  visitArguments(Arguments node) {
+  void visitArguments(Arguments node) {
     computeForNode(
         node, computeDefaultNodeId(node, skipNodeWithNoOffset: true));
     return super.visitArguments(node);
   }
 
   @override
-  visitBlock(Block node) {
+  void visitBlock(Block node) {
     computeForNode(
         node, computeDefaultNodeId(node, skipNodeWithNoOffset: true));
     return super.visitBlock(node);
   }
 
   @override
-  visitConditionalExpression(ConditionalExpression node) {
+  void visitConditionalExpression(ConditionalExpression node) {
     computeForNode(node, computeDefaultNodeId(node));
     return super.visitConditionalExpression(node);
   }
 
   @override
-  visitLogicalExpression(LogicalExpression node) {
+  void visitLogicalExpression(LogicalExpression node) {
     computeForNode(node, computeDefaultNodeId(node));
     return super.visitLogicalExpression(node);
   }
 
   @override
-  visitInvalidExpression(InvalidExpression node) {
+  void visitInvalidExpression(InvalidExpression node) {
     // Invalid expressions produced in the constant evaluator don't have a
     // file offset.
     computeForNode(
diff --git a/pkg/front_end/pubspec.yaml b/pkg/front_end/pubspec.yaml
index 6893010..9e67ea3 100644
--- a/pkg/front_end/pubspec.yaml
+++ b/pkg/front_end/pubspec.yaml
@@ -6,7 +6,7 @@
 publish_to: none
 
 environment:
-  sdk: '>=2.12.0 <3.0.0'
+  sdk: '>=2.13.0 <3.0.0'
 
 dependencies:
   _fe_analyzer_shared:
diff --git a/pkg/front_end/test/ast_nodes_has_to_string_test.dart b/pkg/front_end/test/ast_nodes_has_to_string_test.dart
index 9856c05..705ed30 100644
--- a/pkg/front_end/test/ast_nodes_has_to_string_test.dart
+++ b/pkg/front_end/test/ast_nodes_has_to_string_test.dart
@@ -10,7 +10,7 @@
 
 import 'incremental_suite.dart' as helper;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   exitCode = 1;
   Map<Uri, List<Class>> classMap = {};
   Map<Uri, List<Class>> classMapWithOne = {};
@@ -24,11 +24,8 @@
     Uri input = Platform.script.resolve("../tool/_fasta/compile.dart");
     CompilerOptions options = helper.getOptions();
     helper.TestIncrementalCompiler compiler =
-        new helper.TestIncrementalCompiler(
-            options,
-            input,
-            /*Uri initializeFrom*/ null,
-            /*bool outlineOnly*/ true);
+        new helper.TestIncrementalCompiler(options, input,
+            /*Uri initializeFrom*/ null, /*bool outlineOnly*/ true);
     c = await compiler.computeDelta();
     classHierarchy = compiler.getClassHierarchy()!;
     List<Library> libraries = c.libraries
diff --git a/pkg/front_end/test/binary_md_dill_reader.dart b/pkg/front_end/test/binary_md_dill_reader.dart
index f316b40..1a02047 100644
--- a/pkg/front_end/test/binary_md_dill_reader.dart
+++ b/pkg/front_end/test/binary_md_dill_reader.dart
@@ -167,7 +167,7 @@
   /// Initial setup of a "class definition" in the binary.md file.
   /// This includes parsing the name, setting up any "extends"-relationship,
   /// generics etc.
-  _binaryMdHandlePossibleClassStart(String s) {
+  void _binaryMdHandlePossibleClassStart(String s) {
     if (s.startsWith("type Byte =")) return;
     if (s.startsWith("type UInt32 =")) return;
 
diff --git a/pkg/front_end/test/binary_md_vm_tags_and_version_git_test.dart b/pkg/front_end/test/binary_md_vm_tags_and_version_git_test.dart
index 61cac8f..537c165 100644
--- a/pkg/front_end/test/binary_md_vm_tags_and_version_git_test.dart
+++ b/pkg/front_end/test/binary_md_vm_tags_and_version_git_test.dart
@@ -29,7 +29,7 @@
 // Match stuff like "kNullConstant = 0,"
 final RegExp constantTagParser = new RegExp(r"k(\w*)\s*=\s*(\d+)");
 
-main() async {
+void main() async {
   File binaryMd = new File("$repoDir/pkg/kernel/binary.md");
   String binaryMdContent = binaryMd.readAsStringSync();
 
diff --git a/pkg/front_end/test/class_hierarchy/class_hierarchy_test.dart b/pkg/front_end/test/class_hierarchy/class_hierarchy_test.dart
index 8608d6e..cf9ece3 100644
--- a/pkg/front_end/test/class_hierarchy/class_hierarchy_test.dart
+++ b/pkg/front_end/test/class_hierarchy/class_hierarchy_test.dart
@@ -13,7 +13,7 @@
 import 'package:front_end/src/testing/id_extractor.dart';
 import 'package:kernel/ast.dart';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
   await runTests<Features>(dataDir,
       args: args,
diff --git a/pkg/front_end/test/compile_benchmark.dart b/pkg/front_end/test/compile_benchmark.dart
index c731934..2ad309a 100644
--- a/pkg/front_end/test/compile_benchmark.dart
+++ b/pkg/front_end/test/compile_benchmark.dart
@@ -22,7 +22,7 @@
 final Uri benchmarkHelper =
     Platform.script.resolve("compile_benchmark_helper.dart");
 
-main(List<String> args) {
+void main(List<String> args) {
   List<String> arguments;
   bool tryToAnnotate = false;
   bool tryToSlowDown = false;
@@ -363,7 +363,7 @@
   List<Procedure> procedures = [];
 
   @override
-  visitLibrary(Library node) {
+  void visitLibrary(Library node) {
     if (node.importUri.scheme == "package" &&
         node.importUri.pathSegments.first == "front_end") {
       super.visitLibrary(node);
@@ -371,7 +371,7 @@
   }
 
   @override
-  visitProcedure(Procedure node) {
+  void visitProcedure(Procedure node) {
     if (node.function.body == null) return;
     int procedureNum = procedures.length;
     procedures.add(node);
@@ -395,7 +395,7 @@
   List<Procedure> procedures = [];
 
   @override
-  visitLibrary(Library node) {
+  void visitLibrary(Library node) {
     if (node.importUri.scheme == "package" &&
         node.importUri.pathSegments.first == "front_end") {
       super.visitLibrary(node);
@@ -403,7 +403,7 @@
   }
 
   @override
-  visitProcedure(Procedure node) {
+  void visitProcedure(Procedure node) {
     if (node.function.body == null) return;
     if (node.function.dartAsyncMarker != AsyncMarker.Sync) return;
     int procedureNum = procedures.length;
diff --git a/pkg/front_end/test/compile_benchmark_helper.dart b/pkg/front_end/test/compile_benchmark_helper.dart
index fa1c9fe..823a7bc 100644
--- a/pkg/front_end/test/compile_benchmark_helper.dart
+++ b/pkg/front_end/test/compile_benchmark_helper.dart
@@ -4,7 +4,7 @@
 
 import '../tool/_fasta/entry_points.dart' show compileEntryPoint;
 
-main(List<String> arguments) async {
+void main(List<String> arguments) async {
   await compileEntryPoint(arguments);
   if (numCalls.isNotEmpty) {
     print("[");
diff --git a/pkg/front_end/test/compile_dart2js_with_no_sdk_test.dart b/pkg/front_end/test/compile_dart2js_with_no_sdk_test.dart
index 1ec6b5e..74bafaa 100644
--- a/pkg/front_end/test/compile_dart2js_with_no_sdk_test.dart
+++ b/pkg/front_end/test/compile_dart2js_with_no_sdk_test.dart
@@ -6,7 +6,7 @@
 
 import 'incremental_suite.dart' show TestIncrementalCompiler, getOptions;
 
-main() async {
+void main() async {
   final Uri dart2jsUrl = Uri.base.resolve("pkg/compiler/bin/dart2js.dart");
   CompilerOptions options = getOptions();
   options.sdkSummary = options.sdkSummary!.resolve("nonexisting.dill");
diff --git a/pkg/front_end/test/compile_with_no_sdk_test.dart b/pkg/front_end/test/compile_with_no_sdk_test.dart
index 5f776e7..d8f45308 100644
--- a/pkg/front_end/test/compile_with_no_sdk_test.dart
+++ b/pkg/front_end/test/compile_with_no_sdk_test.dart
@@ -7,7 +7,7 @@
 
 import 'incremental_suite.dart' show TestIncrementalCompiler, getOptions;
 
-main() async {
+void main() async {
   await compile("import 'foo.dart' if (dart.library.bar) 'baz.dart';");
 }
 
diff --git a/pkg/front_end/test/constant_evaluator_benchmark.dart b/pkg/front_end/test/constant_evaluator_benchmark.dart
index 477c94c..11ff8c4 100644
--- a/pkg/front_end/test/constant_evaluator_benchmark.dart
+++ b/pkg/front_end/test/constant_evaluator_benchmark.dart
@@ -130,7 +130,7 @@
 
 late IncrementalCompiler incrementalCompiler;
 
-main(List<String> arguments) async {
+void main(List<String> arguments) async {
   Uri? platformUri;
   Uri mainUri;
   bool nnbd = false;
diff --git a/pkg/front_end/test/covariance_check/covariance_check_test.dart b/pkg/front_end/test/covariance_check/covariance_check_test.dart
index 440dab8..eb7cc24 100644
--- a/pkg/front_end/test/covariance_check/covariance_check_test.dart
+++ b/pkg/front_end/test/covariance_check/covariance_check_test.dart
@@ -11,7 +11,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
   await runTests<String>(dataDir,
       args: args,
diff --git a/pkg/front_end/test/crashing_test_case_minimizer.dart b/pkg/front_end/test/crashing_test_case_minimizer.dart
index 3460433..980721c 100644
--- a/pkg/front_end/test/crashing_test_case_minimizer.dart
+++ b/pkg/front_end/test/crashing_test_case_minimizer.dart
@@ -19,7 +19,7 @@
 // TODO(jensj): Add asserts or similar where - after each rewrite - we run the
 // parser on it and verifies that no syntax errors have been introduced.
 
-main(List<String> arguments) async {
+void main(List<String> arguments) async {
   String filename;
   Uri loadJson;
   for (String arg in arguments) {
diff --git a/pkg/front_end/test/crashing_test_case_minimizer_impl.dart b/pkg/front_end/test/crashing_test_case_minimizer_impl.dart
index 4615724..d77e84e 100644
--- a/pkg/front_end/test/crashing_test_case_minimizer_impl.dart
+++ b/pkg/front_end/test/crashing_test_case_minimizer_impl.dart
@@ -132,7 +132,7 @@
     };
   }
 
-  initializeFromJson(Map<String, dynamic> json) {
+  void initializeFromJson(Map<String, dynamic> json) {
     mainUri = Uri.parse(json["mainUri"]);
     platformUri = Uri.parse(json["platformUri"]);
     noPlatform = json["noPlatform"];
@@ -2109,7 +2109,7 @@
     return new _FakeFileSystemEntity(this, uri);
   }
 
-  initializeFromJson(Map<String, dynamic> json) {
+  void initializeFromJson(Map<String, dynamic> json) {
     _initialized = true;
     _redirectAndRecord = json['_redirectAndRecord'];
     data.clear();
diff --git a/pkg/front_end/test/dartdoc_test_test.dart b/pkg/front_end/test/dartdoc_test_test.dart
index 4070676..a3570f1 100644
--- a/pkg/front_end/test/dartdoc_test_test.dart
+++ b/pkg/front_end/test/dartdoc_test_test.dart
@@ -9,7 +9,7 @@
 
 import "../tool/dart_doctest_impl.dart" as impl;
 
-main() async {
+void main() async {
   expectCategory = "comment extraction";
   testCommentExtraction();
 
diff --git a/pkg/front_end/test/dartdoctest_suite.dart b/pkg/front_end/test/dartdoctest_suite.dart
index a6a2b8c..447ab20 100644
--- a/pkg/front_end/test/dartdoctest_suite.dart
+++ b/pkg/front_end/test/dartdoctest_suite.dart
@@ -9,7 +9,7 @@
 
 import '../tool/dart_doctest_impl.dart';
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<Context> createContext(
diff --git a/pkg/front_end/test/desugar_test.dart b/pkg/front_end/test/desugar_test.dart
index b74e0bd..5b7539b2 100644
--- a/pkg/front_end/test/desugar_test.dart
+++ b/pkg/front_end/test/desugar_test.dart
@@ -23,7 +23,7 @@
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/binary/ast_from_binary.dart' show BinaryBuilder;
 
-main() async {
+void main() async {
   await asyncTest(() async {
     await testRedirectingFactoryDirect();
     await testRedirectingFactorySerialized();
@@ -32,13 +32,13 @@
   });
 }
 
-testRedirectingFactoryDirect() async {
+Future<void> testRedirectingFactoryDirect() async {
   var component = await compileUnit(['a.dart'], {'a.dart': aSource});
   checkIsRedirectingFactory(component, 'a.dart', 'A', 'foo');
   checkIsRedirectingFactory(component, 'core', 'Uri', 'file');
 }
 
-testRedirectingFactorySerialized() async {
+Future<void> testRedirectingFactorySerialized() async {
   var component = await compileUnit(['a.dart'], {'a.dart': aSource});
   var bytes = serializeComponent(component);
   component = new ir.Component();
@@ -49,7 +49,7 @@
 
 // regression test: redirecting factories from patch files don't have the
 // redirecting-factory flag stored in kernel.
-testRedirectingFactoryPatchFile() async {
+Future<void> testRedirectingFactoryPatchFile() async {
   var componentUri =
       computePlatformBinariesLocation().resolve('dart2js_platform.dill');
   var component = new ir.Component();
@@ -81,7 +81,7 @@
 }
 ''';
 
-testExtensionMemberKind() async {
+Future<void> testExtensionMemberKind() async {
   var component = await compileUnit(['e.dart'], {'e.dart': extensionSource});
   var library = component.libraries
       .firstWhere((l) => l.importUri.path.endsWith('e.dart'));
diff --git a/pkg/front_end/test/dill_round_trip_test.dart b/pkg/front_end/test/dill_round_trip_test.dart
index 894d6d4..17bbe1d 100644
--- a/pkg/front_end/test/dill_round_trip_test.dart
+++ b/pkg/front_end/test/dill_round_trip_test.dart
@@ -15,7 +15,7 @@
 import 'incremental_suite.dart'
     show checkIsEqual, getOptions, normalCompilePlain;
 
-main() async {
+void main() async {
   final Uri dart2jsUrl = Uri.base.resolve("pkg/compiler/bin/dart2js.dart");
   Stopwatch stopwatch = new Stopwatch()..start();
   Component compiledComponent = await normalCompilePlain(dart2jsUrl,
diff --git a/pkg/front_end/test/enable_non_nullable/enable_non_nullable_test.dart b/pkg/front_end/test/enable_non_nullable/enable_non_nullable_test.dart
index 1440d83..b15d91f 100644
--- a/pkg/front_end/test/enable_non_nullable/enable_non_nullable_test.dart
+++ b/pkg/front_end/test/enable_non_nullable/enable_non_nullable_test.dart
@@ -20,7 +20,7 @@
 /// The version used in this test as the experiment enabled version.
 const Version experimentEnabledVersion = const Version(2, 10);
 
-main() async {
+void main() async {
   print('--------------------------------------------------------------------');
   print('Test off-by-default with command-line flag');
   print('--------------------------------------------------------------------');
@@ -58,7 +58,7 @@
       versionOptsInAllowed: experimentReleaseVersion);
 }
 
-test(
+void test(
     {bool enableNonNullableByDefault,
     bool enableNonNullableExplicitly,
     Version versionImpliesOptIn,
diff --git a/pkg/front_end/test/extensions/extensions_test.dart b/pkg/front_end/test/extensions/extensions_test.dart
index 44fb012..c811201 100644
--- a/pkg/front_end/test/extensions/extensions_test.dart
+++ b/pkg/front_end/test/extensions/extensions_test.dart
@@ -23,7 +23,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
   await runTests<Features>(dataDir,
       args: args,
diff --git a/pkg/front_end/test/fasta/ambiguous_export_test.dart b/pkg/front_end/test/fasta/ambiguous_export_test.dart
index 6fa366c..579a3f8 100644
--- a/pkg/front_end/test/fasta/ambiguous_export_test.dart
+++ b/pkg/front_end/test/fasta/ambiguous_export_test.dart
@@ -20,7 +20,7 @@
 import 'package:kernel/ast.dart'
     show Field, Library, Name, Component, StringLiteral;
 
-main() async {
+void main() async {
   await asyncTest(() async {
     Uri uri = Uri.parse("org.dartlang.fasta:library");
     Library library = new Library(uri, fileUri: uri);
diff --git a/pkg/front_end/test/fasta/analyze_git_test.dart b/pkg/front_end/test/fasta/analyze_git_test.dart
index 684f469..7ccff17 100644
--- a/pkg/front_end/test/fasta/analyze_git_test.dart
+++ b/pkg/front_end/test/fasta/analyze_git_test.dart
@@ -8,7 +8,7 @@
 
 import "package:testing/src/run_tests.dart" as testing show main;
 
-main() async {
+void main() async {
   // This method is async, but keeps a port open to prevent the VM from exiting
   // prematurely.
   // Note: if you change this file, also change
diff --git a/pkg/front_end/test/fasta/analyze_src_with_lints_git_test.dart b/pkg/front_end/test/fasta/analyze_src_with_lints_git_test.dart
index aba5e28..34ca1e2 100644
--- a/pkg/front_end/test/fasta/analyze_src_with_lints_git_test.dart
+++ b/pkg/front_end/test/fasta/analyze_src_with_lints_git_test.dart
@@ -8,7 +8,7 @@
 
 import "package:testing/src/run_tests.dart" as testing show main;
 
-main() async {
+void main() async {
   await testing.main(<String>[
     "--config=pkg/front_end/testing_with_lints.json",
     "--verbose",
diff --git a/pkg/front_end/test/fasta/assert_locations_test.dart b/pkg/front_end/test/fasta/assert_locations_test.dart
index 3ef159b..029196a 100644
--- a/pkg/front_end/test/fasta/assert_locations_test.dart
+++ b/pkg/front_end/test/fasta/assert_locations_test.dart
@@ -115,7 +115,7 @@
   VerifyingVisitor(this.test);
 
   @override
-  visitProcedure(Procedure node) {
+  void visitProcedure(Procedure node) {
     expectedSpan = test.spans[node.name.text];
     if (expectedSpan != null) {
       super.visitProcedure(node);
@@ -125,7 +125,7 @@
   }
 
   @override
-  visitAssertStatement(AssertStatement node) {
+  void visitAssertStatement(AssertStatement node) {
     Expect.equals(expectedSpan.startOffset, node.conditionStartOffset);
     Expect.equals(expectedSpan.endOffset, node.conditionEndOffset);
   }
diff --git a/pkg/front_end/test/fasta/bootstrap_test.dart b/pkg/front_end/test/fasta/bootstrap_test.dart
index 44651f3..fd49f77 100644
--- a/pkg/front_end/test/fasta/bootstrap_test.dart
+++ b/pkg/front_end/test/fasta/bootstrap_test.dart
@@ -107,5 +107,5 @@
   ComparisonFailed(this.a, this.b);
 
   @override
-  toString() => "Error: $a is different from $b";
+  String toString() => "Error: $a is different from $b";
 }
diff --git a/pkg/front_end/test/fasta/expression_suite.dart b/pkg/front_end/test/fasta/expression_suite.dart
index 90eae87..94cef6e 100644
--- a/pkg/front_end/test/fasta/expression_suite.dart
+++ b/pkg/front_end/test/fasta/expression_suite.dart
@@ -439,5 +439,5 @@
   return new Context(compilerContext, errors, updateExpectations);
 }
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../../testing.json");
diff --git a/pkg/front_end/test/fasta/generator_to_string_test.dart b/pkg/front_end/test/fasta/generator_to_string_test.dart
index 1f5559e..f59c8c3 100644
--- a/pkg/front_end/test/fasta/generator_to_string_test.dart
+++ b/pkg/front_end/test/fasta/generator_to_string_test.dart
@@ -66,7 +66,7 @@
   Expect.stringEquals(expected, "$generator");
 }
 
-main() async {
+void main() async {
   await CompilerContext.runWithDefaultOptions((CompilerContext c) async {
     Token token = scanString("    myToken").tokens;
     Uri uri = Uri.parse("org-dartlang-test:my_library.dart");
diff --git a/pkg/front_end/test/fasta/incremental_dartino_suite.dart b/pkg/front_end/test/fasta/incremental_dartino_suite.dart
index 35572e4..f3b354e 100644
--- a/pkg/front_end/test/fasta/incremental_dartino_suite.dart
+++ b/pkg/front_end/test/fasta/incremental_dartino_suite.dart
@@ -244,5 +244,5 @@
   return new Context(new CompilerContext(options), errors);
 }
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../../testing.json");
diff --git a/pkg/front_end/test/fasta/incremental_expectations.dart b/pkg/front_end/test/fasta/incremental_expectations.dart
index 943b405..7e9a45c 100644
--- a/pkg/front_end/test/fasta/incremental_expectations.dart
+++ b/pkg/front_end/test/fasta/incremental_expectations.dart
@@ -41,7 +41,7 @@
         hasCompileTimeError: extractHasCompileTimeError(data));
   }
 
-  toJson() {
+  dynamic toJson() {
     if (!commitChangesShouldFail && !hasCompileTimeError) {
       return messages.length == 1 ? messages.first : messages;
     }
diff --git a/pkg/front_end/test/fasta/incremental_hello_test.dart b/pkg/front_end/test/fasta/incremental_hello_test.dart
index 4e10f32..33d7d3a 100644
--- a/pkg/front_end/test/fasta/incremental_hello_test.dart
+++ b/pkg/front_end/test/fasta/incremental_hello_test.dart
@@ -34,7 +34,7 @@
   throw "Unexpected message: ${message.plainTextFormatted.join('\n')}";
 }
 
-test({bool sdkFromSource}) async {
+Future<void> test({bool sdkFromSource}) async {
   final CompilerOptions optionBuilder = new CompilerOptions()
     ..packagesFileUri = Uri.base.resolve(".packages")
     ..target = new VmTarget(new TargetFlags())
diff --git a/pkg/front_end/test/fasta/link_test.dart b/pkg/front_end/test/fasta/link_test.dart
index a0b7b06..d1029eb 100644
--- a/pkg/front_end/test/fasta/link_test.dart
+++ b/pkg/front_end/test/fasta/link_test.dart
@@ -8,12 +8,14 @@
 
 import 'package:expect/expect.dart' show Expect;
 
-main() {
+void main() {
   Link<String> strings = const Link<String>().prepend("B").prepend("A");
   Expect.stringEquals("[ A, B ]", "${strings}");
   Expect.stringEquals("[ B, A ]", "${strings.reverse(const Link<String>())}");
 
-  strings = (new LinkBuilder<String>()..addLast("A")..addLast("B"))
+  strings = (new LinkBuilder<String>()
+        ..addLast("A")
+        ..addLast("B"))
       .toLink(const Link<String>());
 
   Expect.stringEquals("[ A, B ]", "${strings}");
@@ -34,7 +36,9 @@
   Expect.stringEquals("[ A, B ]", "${strings}");
   Expect.stringEquals("[ B, A ]", "${strings.reverse(const Link<String>())}");
 
-  strings = (new LinkBuilder<String>()..addLast("A")..addLast("B"))
+  strings = (new LinkBuilder<String>()
+        ..addLast("A")
+        ..addLast("B"))
       .toLink(const Link<String>());
 
   Expect.stringEquals("[ A, B ]", "${strings}");
diff --git a/pkg/front_end/test/fasta/messages_suite.dart b/pkg/front_end/test/fasta/messages_suite.dart
index 0fa12e2..8e884da 100644
--- a/pkg/front_end/test/fasta/messages_suite.dart
+++ b/pkg/front_end/test/fasta/messages_suite.dart
@@ -876,5 +876,5 @@
   }
 }
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../../testing.json");
diff --git a/pkg/front_end/test/fasta/object_supertype_test.dart b/pkg/front_end/test/fasta/object_supertype_test.dart
index d6e0ae6..62b9210 100644
--- a/pkg/front_end/test/fasta/object_supertype_test.dart
+++ b/pkg/front_end/test/fasta/object_supertype_test.dart
@@ -75,12 +75,12 @@
   return messages;
 }
 
-test() async {
+Future<void> test() async {
   Set<String> normalErrors = (await outline("class Object {"))
       .map((DiagnosticMessage message) => getMessageCodeObject(message).name)
       .toSet();
 
-  check(String objectHeader, List<Code> expectedCodes) async {
+  void check(String objectHeader, List<Code> expectedCodes) async {
     List<DiagnosticMessage> messages = (await outline(objectHeader))
         .where((DiagnosticMessage message) =>
             !normalErrors.contains(getMessageCodeObject(message).name))
@@ -100,6 +100,6 @@
       <Code>[codeObjectExtends, codeObjectMixesIn]);
 }
 
-main() {
+void main() {
   asyncTest(test);
 }
diff --git a/pkg/front_end/test/fasta/outline_suite.dart b/pkg/front_end/test/fasta/outline_suite.dart
index 0c9fbfd..cb5f5a9 100644
--- a/pkg/front_end/test/fasta/outline_suite.dart
+++ b/pkg/front_end/test/fasta/outline_suite.dart
@@ -13,5 +13,5 @@
   return FastaContext.create(suite, environment);
 }
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../../testing.json");
diff --git a/pkg/front_end/test/fasta/parser/literal_entry_info_test.dart b/pkg/front_end/test/fasta/parser/literal_entry_info_test.dart
index 52120bf..c282670 100644
--- a/pkg/front_end/test/fasta/parser/literal_entry_info_test.dart
+++ b/pkg/front_end/test/fasta/parser/literal_entry_info_test.dart
@@ -12,7 +12,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(CollectionElementTest);
     defineReflectiveTests(MapElementTest);
@@ -21,7 +21,7 @@
 
 @reflectiveTest
 class CollectionElementTest {
-  test_closingBrace() {
+  void test_closingBrace() {
     parseEntry(
       '[ }',
       [
@@ -36,7 +36,7 @@
     );
   }
 
-  test_comma() {
+  void test_comma() {
     parseEntry(
       '[ ,',
       [
@@ -50,7 +50,7 @@
     );
   }
 
-  test_expression() {
+  void test_expression() {
     parseEntry(
       '[ x',
       [
@@ -63,7 +63,7 @@
     );
   }
 
-  test_for() {
+  void test_for() {
     parseEntry(
       '[ for (var i = 0; i < 10; ++i) 2',
       [
@@ -101,7 +101,7 @@
     );
   }
 
-  test_forForFor() {
+  void test_forForFor() {
     parseEntry(
       '[ for (var i = 0; i < 10; ++i) for (x in y) for (var a in [6]) 2',
       [
@@ -178,7 +178,7 @@
     );
   }
 
-  test_forIfForElse() {
+  void test_forIfForElse() {
     parseEntry(
       '[ await for (var x in y) if (a) for (b in c) 2 else 7',
       [
@@ -241,7 +241,7 @@
     );
   }
 
-  test_forIn() {
+  void test_forIn() {
     parseEntry(
       '[ await for (var x in y) 2',
       [
@@ -271,7 +271,7 @@
     );
   }
 
-  test_forInSpread() {
+  void test_forInSpread() {
     parseEntry(
       '[ for (var x in y) ...[2]',
       [
@@ -303,7 +303,7 @@
     );
   }
 
-  test_forSpreadQ() {
+  void test_forSpreadQ() {
     parseEntry(
       '[ for (i = 0; i < 10; ++i) ...[2]',
       [
@@ -339,7 +339,7 @@
     );
   }
 
-  test_if() {
+  void test_if() {
     parseEntry(
       '[ if (true) 2',
       [
@@ -354,7 +354,7 @@
     );
   }
 
-  test_ifElse() {
+  void test_ifElse() {
     parseEntry(
       '[ if (true) 2 else 5',
       [
@@ -371,7 +371,7 @@
     );
   }
 
-  test_ifFor() {
+  void test_ifFor() {
     parseEntry(
       '[ if (true) for (x in y) 2',
       [
@@ -405,7 +405,7 @@
     );
   }
 
-  test_ifForElseIfFor() {
+  void test_ifForElseIfFor() {
     parseEntry(
       '[ if (true) for (a in b) 2 else if (c) for (d in e) 5',
       [
@@ -469,7 +469,7 @@
     );
   }
 
-  test_ifSpreadQ() {
+  void test_ifSpreadQ() {
     parseEntry(
       '[ if (true) ...?[2]',
       [
@@ -487,7 +487,7 @@
     );
   }
 
-  test_ifElseSpreadQ() {
+  void test_ifElseSpreadQ() {
     parseEntry(
       '[ if (true) ...?[2] else ... const {5}',
       [
@@ -512,14 +512,14 @@
     );
   }
 
-  test_intLiteral() {
+  void test_intLiteral() {
     parseEntry('[ 1', [
       'handleLiteralInt 1',
       'handleLiteralList 1, [, null, ]',
     ]);
   }
 
-  test_spread() {
+  void test_spread() {
     parseEntry('[ ...[1]', [
       'handleNoTypeArguments [',
       'handleLiteralInt 1',
@@ -529,7 +529,7 @@
     ]);
   }
 
-  test_spreadQ() {
+  void test_spreadQ() {
     parseEntry('[ ...?[1]', [
       'handleNoTypeArguments [',
       'handleLiteralInt 1',
@@ -565,7 +565,7 @@
 
 @reflectiveTest
 class MapElementTest {
-  test_closingBrace() {
+  void test_closingBrace() {
     parseEntry(
       'before }',
       [
@@ -588,7 +588,7 @@
     );
   }
 
-  test_comma() {
+  void test_comma() {
     parseEntry(
       'before ,',
       [
@@ -611,7 +611,7 @@
     );
   }
 
-  test_expression() {
+  void test_expression() {
     parseEntry(
       'before x:y',
       [
@@ -628,7 +628,7 @@
     );
   }
 
-  test_for() {
+  void test_for() {
     parseEntry(
       'before for (var i = 0; i < 10; ++i) 2:3',
       [
@@ -667,7 +667,7 @@
     );
   }
 
-  test_forIn() {
+  void test_forIn() {
     parseEntry(
       'before await for (var x in y) 2:3',
       [
@@ -698,7 +698,7 @@
     );
   }
 
-  test_forInSpread() {
+  void test_forInSpread() {
     parseEntry(
       'before for (var x in y) ...{2:3}',
       [
@@ -731,7 +731,7 @@
     );
   }
 
-  test_forSpreadQ() {
+  void test_forSpreadQ() {
     parseEntry(
       'before for (i = 0; i < 10; ++i) ...?{2:7}',
       [
@@ -768,7 +768,7 @@
     );
   }
 
-  test_if() {
+  void test_if() {
     parseEntry(
       'before if (true) 2:3',
       [
@@ -784,7 +784,7 @@
     );
   }
 
-  test_ifSpread() {
+  void test_ifSpread() {
     parseEntry(
       'before if (true) ...{2:3}',
       [
@@ -803,7 +803,7 @@
     );
   }
 
-  test_intLiteral() {
+  void test_intLiteral() {
     parseEntry('before 1:2', [
       'handleLiteralInt 1',
       'handleLiteralInt 2',
@@ -811,7 +811,7 @@
     ]);
   }
 
-  test_spread() {
+  void test_spread() {
     parseEntry('before ...const {1:2}', [
       'beginConstLiteral {',
       'handleNoTypeArguments {',
@@ -824,7 +824,7 @@
     ]);
   }
 
-  test_spreadQ() {
+  void test_spreadQ() {
     parseEntry('before ...?const {1:3}', [
       'beginConstLiteral {',
       'handleNoTypeArguments {',
@@ -1101,7 +1101,7 @@
   }
 
   @override
-  noSuchMethod(Invocation invocation) {
+  dynamic noSuchMethod(Invocation invocation) {
     throw '${invocation.memberName} should not be called.';
   }
 }
diff --git a/pkg/front_end/test/fasta/parser/parser_suite.dart b/pkg/front_end/test/fasta/parser/parser_suite.dart
index 07a5487..5a920de 100644
--- a/pkg/front_end/test/fasta/parser/parser_suite.dart
+++ b/pkg/front_end/test/fasta/parser/parser_suite.dart
@@ -46,5 +46,5 @@
   }
 }
 
-main(List<String> arguments) =>
+void main(List<String> arguments) =>
     runMe(arguments, createContext, configurationPath: "../../../testing.json");
diff --git a/pkg/front_end/test/fasta/parser/token_stream_rewriter_test.dart b/pkg/front_end/test/fasta/parser/token_stream_rewriter_test.dart
index 2287d8e..24d01ca 100644
--- a/pkg/front_end/test/fasta/parser/token_stream_rewriter_test.dart
+++ b/pkg/front_end/test/fasta/parser/token_stream_rewriter_test.dart
@@ -13,7 +13,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TokenStreamRewriterTest_NoPrevious);
     defineReflectiveTests(TokenStreamRewriterTest_UsingPrevious);
diff --git a/pkg/front_end/test/fasta/parser/type_info_test.dart b/pkg/front_end/test/fasta/parser/type_info_test.dart
index a3fc5f0..29f59e7 100644
--- a/pkg/front_end/test/fasta/parser/type_info_test.dart
+++ b/pkg/front_end/test/fasta/parser/type_info_test.dart
@@ -15,7 +15,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(NoTypeInfoTest);
     defineReflectiveTests(PrefixedTypeInfoTest);
@@ -304,7 +304,7 @@
     expect(prefixedType.couldBeExpression, isTrue);
 
     TypeInfoListener listener;
-    assertResult(Token actualEnd) {
+    void assertResult(Token actualEnd) {
       expect(actualEnd, expectedEnd);
       expect(listener.calls, [
         'handleIdentifier C prefixedTypeReference',
@@ -380,7 +380,7 @@
     expect(simpleNullableType.couldBeExpression, isTrue);
 
     TypeInfoListener listener;
-    assertResult(Token actualEnd) {
+    void assertResult(Token actualEnd) {
       expect(actualEnd, expectedEnd);
       expect(listener.calls, [
         'handleIdentifier C typeReference',
@@ -431,7 +431,7 @@
     expect(simpleNullableTypeWith1Argument.couldBeExpression, isFalse);
 
     TypeInfoListener listener;
-    assertResult(Token actualEnd) {
+    void assertResult(Token actualEnd) {
       expect(actualEnd, expectedEnd);
       expect(listener.calls, [
         'handleIdentifier C typeReference',
@@ -501,7 +501,7 @@
     expect(simpleType.couldBeExpression, isTrue);
 
     TypeInfoListener listener;
-    assertResult(Token actualEnd) {
+    void assertResult(Token actualEnd) {
       expect(actualEnd, expectedEnd);
       expect(listener.calls, [
         'handleIdentifier C typeReference',
@@ -575,7 +575,7 @@
     expect(simpleTypeWith1Argument.couldBeExpression, isFalse);
 
     TypeInfoListener listener;
-    assertResult(Token actualEnd) {
+    void assertResult(Token actualEnd) {
       expect(actualEnd, expectedEnd);
       expect(listener.calls, [
         'handleIdentifier C typeReference',
@@ -619,7 +619,7 @@
     expect(simpleTypeWith1ArgumentGtEq.couldBeExpression, isFalse);
 
     TypeInfoListener listener;
-    assertResult(Token actualEnd) {
+    void assertResult(Token actualEnd) {
       expect(actualEnd.lexeme, '>');
       expect(actualEnd.next.lexeme, '=');
       expect(actualEnd.next.next, semicolon);
@@ -664,7 +664,7 @@
     expect(simpleTypeWith1ArgumentGtGt.couldBeExpression, isFalse);
 
     TypeInfoListener listener;
-    assertResult(Token actualEnd) {
+    void assertResult(Token actualEnd) {
       expect(actualEnd.lexeme, '>');
       expect(actualEnd.next.lexeme, '>');
       expect(actualEnd.next.next, semicolon);
@@ -3019,11 +3019,11 @@
   }
 
   @override
-  noSuchMethod(Invocation invocation) {
+  dynamic noSuchMethod(Invocation invocation) {
     throw '${invocation.memberName} should not be called.';
   }
 
-  assertTokenInStream(Token match) {
+  void assertTokenInStream(Token match) {
     if (firstToken != null && match != null && !match.isEof) {
       Token token = firstToken;
       while (!token.isEof) {
diff --git a/pkg/front_end/test/fasta/reexport_test.dart b/pkg/front_end/test/fasta/reexport_test.dart
index c754291..5972e6a 100644
--- a/pkg/front_end/test/fasta/reexport_test.dart
+++ b/pkg/front_end/test/fasta/reexport_test.dart
@@ -11,7 +11,7 @@
 import "package:front_end/src/api_prototype/front_end.dart"
     show CompilerOptions;
 
-main() {
+void main() {
   asyncTest(() async {
     var sources = <String, dynamic>{
       "a.dart": """
diff --git a/pkg/front_end/test/fasta/scanner/scanner_suite.dart b/pkg/front_end/test/fasta/scanner/scanner_suite.dart
index f3b49ed..7b89a9e 100644
--- a/pkg/front_end/test/fasta/scanner/scanner_suite.dart
+++ b/pkg/front_end/test/fasta/scanner/scanner_suite.dart
@@ -21,5 +21,5 @@
   ];
 }
 
-main(List<String> arguments) =>
+void main(List<String> arguments) =>
     runMe(arguments, createContext, configurationPath: "../../../testing.json");
diff --git a/pkg/front_end/test/fasta/sdk_test.dart b/pkg/front_end/test/fasta/sdk_test.dart
index 00d03a6..0ca3cd5 100644
--- a/pkg/front_end/test/fasta/sdk_test.dart
+++ b/pkg/front_end/test/fasta/sdk_test.dart
@@ -17,4 +17,5 @@
   return FastaContext.create(suite, environment);
 }
 
-main([List<String> arguments = const []]) => runMe(arguments, createContext);
+void main([List<String> arguments = const []]) =>
+    runMe(arguments, createContext);
diff --git a/pkg/front_end/test/fasta/strong_suite.dart b/pkg/front_end/test/fasta/strong_suite.dart
index 2d9b9a2..468ed23 100644
--- a/pkg/front_end/test/fasta/strong_suite.dart
+++ b/pkg/front_end/test/fasta/strong_suite.dart
@@ -15,11 +15,11 @@
   return FastaContext.create(suite, environment);
 }
 
-main(List<String> arguments) {
+void main(List<String> arguments) {
   internalMain(arguments: arguments);
 }
 
-internalMain(
+void internalMain(
     {List<String> arguments = const [], int shards = 1, int shard = 0}) {
   runMe(arguments, createContext,
       configurationPath: "../../testing.json", shards: shards, shard: shard);
diff --git a/pkg/front_end/test/fasta/super_mixins_test.dart b/pkg/front_end/test/fasta/super_mixins_test.dart
index ecfe1c9..8f97ec7 100644
--- a/pkg/front_end/test/fasta/super_mixins_test.dart
+++ b/pkg/front_end/test/fasta/super_mixins_test.dart
@@ -90,7 +90,7 @@
 /// Check that by default an error is reported for all unresolved super
 /// invocations: independently of weather they target abstract super members
 /// or nonexistent targets.
-testDisabledSuperMixins() async {
+Future<void> testDisabledSuperMixins() async {
   var missingSuperMethodNames = new Set<String>();
   var options = new CompilerOptions()
     ..onDiagnostic = _makeDiagnosticMessageHandler(missingSuperMethodNames);
@@ -103,7 +103,7 @@
 /// super-invocation that targets an non-existent method, a super-invocation
 /// that targets an abstract member of the super-class should not be reported.
 /// In non-abstract class we should report both cases as an error.
-testEnabledSuperMixins() async {
+Future<void> testEnabledSuperMixins() async {
   var missingSuperMethodNames = new Set<String>();
   var options = new CompilerOptions()
     ..onDiagnostic = _makeDiagnosticMessageHandler(missingSuperMethodNames)
diff --git a/pkg/front_end/test/fasta/testing/suite.dart b/pkg/front_end/test/fasta/testing/suite.dart
index 1ab048a..f38eaff 100644
--- a/pkg/front_end/test/fasta/testing/suite.dart
+++ b/pkg/front_end/test/fasta/testing/suite.dart
@@ -2059,6 +2059,7 @@
 }
 
 class TestVmTarget extends VmTarget with TestTarget, TestTargetMixin {
+  @override
   final TestTargetFlags flags;
 
   TestVmTarget(this.flags) : super(flags);
@@ -2136,6 +2137,7 @@
 }
 
 class TestDart2jsTarget extends Dart2jsTarget with TestTarget, TestTargetMixin {
+  @override
   final TestTargetFlags flags;
 
   TestDart2jsTarget(String name, this.flags) : super(name, flags);
@@ -2143,6 +2145,7 @@
 
 class TestDevCompilerTarget extends DevCompilerTarget
     with TestTarget, TestTargetMixin {
+  @override
   final TestTargetFlags flags;
 
   TestDevCompilerTarget(this.flags) : super(flags);
diff --git a/pkg/front_end/test/fasta/text_serialization_suite.dart b/pkg/front_end/test/fasta/text_serialization_suite.dart
index a7018eb..eaeb88a 100644
--- a/pkg/front_end/test/fasta/text_serialization_suite.dart
+++ b/pkg/front_end/test/fasta/text_serialization_suite.dart
@@ -15,11 +15,11 @@
   return FastaContext.create(suite, environment);
 }
 
-main(List<String> arguments) {
+void main(List<String> arguments) {
   internalMain(arguments: arguments);
 }
 
-internalMain(
+void internalMain(
     {List<String> arguments = const [], int shards = 1, int shard = 0}) {
   runMe(arguments, createContext,
       configurationPath: "../../testing.json", shards: shards, shard: shard);
diff --git a/pkg/front_end/test/fasta/textual_outline_suite.dart b/pkg/front_end/test/fasta/textual_outline_suite.dart
index 8cdfe57..09f3387 100644
--- a/pkg/front_end/test/fasta/textual_outline_suite.dart
+++ b/pkg/front_end/test/fasta/textual_outline_suite.dart
@@ -52,7 +52,7 @@
   return new Context(environment["updateExpectations"] == "true");
 }
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../../testing.json");
 
 class Context extends ChainContext with MatchContext {
diff --git a/pkg/front_end/test/fasta/tool_git_test.dart b/pkg/front_end/test/fasta/tool_git_test.dart
index 6f77ade..fde2e4e 100644
--- a/pkg/front_end/test/fasta/tool_git_test.dart
+++ b/pkg/front_end/test/fasta/tool_git_test.dart
@@ -47,7 +47,7 @@
   "testing",
 ];
 
-main() {
+void main() {
   if (!Platform.isMacOS && !Platform.isLinux) {
     // The tool is a shell script and only works on Mac and Linux.
     return;
diff --git a/pkg/front_end/test/fasta/type_inference/factor_type_test.dart b/pkg/front_end/test/fasta/type_inference/factor_type_test.dart
index aec0ef1..65243ed 100644
--- a/pkg/front_end/test/fasta/type_inference/factor_type_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/factor_type_test.dart
@@ -102,7 +102,7 @@
       typeToText(type, TypeRepresentation.analyzerNonNullableByDefault);
 }
 
-main() async {
+void main() async {
   CompilerOptions options = new CompilerOptions()
     ..explicitExperimentalFlags[ExperimentalFlag.nonNullable] = true;
   InternalCompilerResult result = await compileScript('',
diff --git a/pkg/front_end/test/fasta/type_inference/type_constraint_gatherer_nnbd_test.dart b/pkg/front_end/test/fasta/type_inference/type_constraint_gatherer_nnbd_test.dart
index 889f6c6..7bf3df7 100644
--- a/pkg/front_end/test/fasta/type_inference/type_constraint_gatherer_nnbd_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/type_constraint_gatherer_nnbd_test.dart
@@ -14,7 +14,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TypeConstraintGathererTest);
   });
diff --git a/pkg/front_end/test/fasta/type_inference/type_constraint_gatherer_test.dart b/pkg/front_end/test/fasta/type_inference/type_constraint_gatherer_test.dart
index ec32ecf..16df20d 100644
--- a/pkg/front_end/test/fasta/type_inference/type_constraint_gatherer_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/type_constraint_gatherer_test.dart
@@ -14,7 +14,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TypeConstraintGathererTest);
   });
diff --git a/pkg/front_end/test/fasta/type_inference/type_inference_engine_test.dart b/pkg/front_end/test/fasta/type_inference/type_inference_engine_test.dart
index 83ba5fd..0588e94 100644
--- a/pkg/front_end/test/fasta/type_inference/type_inference_engine_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/type_inference_engine_test.dart
@@ -9,7 +9,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(IncludesTypeParametersCovariantlyTest);
   });
diff --git a/pkg/front_end/test/fasta/type_inference/type_schema_elimination_nnbd_test.dart b/pkg/front_end/test/fasta/type_inference/type_schema_elimination_nnbd_test.dart
index d50b5c6..dc5b7cb 100644
--- a/pkg/front_end/test/fasta/type_inference/type_schema_elimination_nnbd_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/type_schema_elimination_nnbd_test.dart
@@ -12,7 +12,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TypeSchemaEliminationTest);
   });
diff --git a/pkg/front_end/test/fasta/type_inference/type_schema_elimination_test.dart b/pkg/front_end/test/fasta/type_inference/type_schema_elimination_test.dart
index 55e7235..36f0c1a 100644
--- a/pkg/front_end/test/fasta/type_inference/type_schema_elimination_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/type_schema_elimination_test.dart
@@ -12,7 +12,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TypeSchemaEliminationTest);
   });
diff --git a/pkg/front_end/test/fasta/type_inference/type_schema_environment_nnbd_test.dart b/pkg/front_end/test/fasta/type_inference/type_schema_environment_nnbd_test.dart
index a1448b7..20d575a 100644
--- a/pkg/front_end/test/fasta/type_inference/type_schema_environment_nnbd_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/type_schema_environment_nnbd_test.dart
@@ -13,7 +13,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TypeSchemaEnvironmentTest);
   });
diff --git a/pkg/front_end/test/fasta/type_inference/type_schema_environment_test.dart b/pkg/front_end/test/fasta/type_inference/type_schema_environment_test.dart
index 027bac2..6945778 100644
--- a/pkg/front_end/test/fasta/type_inference/type_schema_environment_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/type_schema_environment_test.dart
@@ -13,7 +13,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TypeSchemaEnvironmentTest);
   });
diff --git a/pkg/front_end/test/fasta/type_inference/type_schema_test.dart b/pkg/front_end/test/fasta/type_inference/type_schema_test.dart
index 5aa934b..eff2502 100644
--- a/pkg/front_end/test/fasta/type_inference/type_schema_test.dart
+++ b/pkg/front_end/test/fasta/type_inference/type_schema_test.dart
@@ -9,7 +9,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(UnknownTypeTest);
   });
diff --git a/pkg/front_end/test/fasta/types/dart2js_benchmark.dart b/pkg/front_end/test/fasta/types/dart2js_benchmark.dart
index 7ef67e3..b302938 100644
--- a/pkg/front_end/test/fasta/types/dart2js_benchmark.dart
+++ b/pkg/front_end/test/fasta/types/dart2js_benchmark.dart
@@ -8,5 +8,5 @@
 
 import "subtypes_benchmark.dart" show run;
 
-main() =>
+void main() =>
     run(Platform.script.resolve("benchmark_data/dart2js.json.gz"), "Dart2js");
diff --git a/pkg/front_end/test/fasta/types/dart2js_benchmark_test.dart b/pkg/front_end/test/fasta/types/dart2js_benchmark_test.dart
index b3084ea..590937d 100644
--- a/pkg/front_end/test/fasta/types/dart2js_benchmark_test.dart
+++ b/pkg/front_end/test/fasta/types/dart2js_benchmark_test.dart
@@ -6,4 +6,4 @@
 
 import "dart2js_benchmark.dart" as bench show main;
 
-main() => bench.main();
+void main() => bench.main();
diff --git a/pkg/front_end/test/fasta/types/dill_hierachy_test.dart b/pkg/front_end/test/fasta/types/dill_hierachy_test.dart
index a5bd0e4..fb95755 100644
--- a/pkg/front_end/test/fasta/types/dill_hierachy_test.dart
+++ b/pkg/front_end/test/fasta/types/dill_hierachy_test.dart
@@ -14,7 +14,8 @@
 
 import "package:kernel/target/targets.dart" show NoneTarget, TargetFlags;
 
-import 'package:kernel/testing/type_parser_environment.dart' show parseComponent;
+import 'package:kernel/testing/type_parser_environment.dart'
+    show parseComponent;
 
 import "package:front_end/src/api_prototype/compiler_options.dart"
     show CompilerOptions;
@@ -100,7 +101,7 @@
   interfaceSetters:
 """;
 
-main() {
+void main() {
   final Ticker ticker = new Ticker(isVerbose: false);
   final Component component = parseComponent("""
 class A;
diff --git a/pkg/front_end/test/fasta/types/fasta_legacy_upper_bound_test.dart b/pkg/front_end/test/fasta/types/fasta_legacy_upper_bound_test.dart
index 653a912..2852925 100644
--- a/pkg/front_end/test/fasta/types/fasta_legacy_upper_bound_test.dart
+++ b/pkg/front_end/test/fasta/types/fasta_legacy_upper_bound_test.dart
@@ -63,7 +63,7 @@
   }
 }
 
-main() {
+void main() {
   final Ticker ticker = new Ticker();
   final CompilerContext context = new CompilerContext(new ProcessedOptions(
       options: new CompilerOptions()
diff --git a/pkg/front_end/test/fasta/types/fasta_types_test.dart b/pkg/front_end/test/fasta/types/fasta_types_test.dart
index 6e86bf6..c5be9a4 100644
--- a/pkg/front_end/test/fasta/types/fasta_types_test.dart
+++ b/pkg/front_end/test/fasta/types/fasta_types_test.dart
@@ -40,7 +40,7 @@
 
 import "shared_type_tests.dart" show SubtypeTest;
 
-main() {
+void main() {
   final Ticker ticker = new Ticker(isVerbose: false);
   final CompilerContext context = new CompilerContext(new ProcessedOptions(
       options: new CompilerOptions()
diff --git a/pkg/front_end/test/fasta/types/hashcode_test.dart b/pkg/front_end/test/fasta/types/hashcode_test.dart
index e27c2fe..0c1fbfe 100644
--- a/pkg/front_end/test/fasta/types/hashcode_test.dart
+++ b/pkg/front_end/test/fasta/types/hashcode_test.dart
@@ -21,7 +21,7 @@
       typeParameters: [T]);
 }
 
-test1() {
+void test1() {
   DartType voidToR1 = createVoidToR();
   DartType voidToR2 = createVoidToR();
   DartType voidToR3 = createTTo_VoidToR().returnType;
@@ -48,7 +48,7 @@
       typeParameters: [R]);
 }
 
-test2() {
+void test2() {
   FunctionType outer1 = createVoidTo_VoidToR();
   FunctionType outer2 = createVoidTo_VoidToR();
   DartType voidToR1 = outer1.returnType;
@@ -61,6 +61,6 @@
       "Hash code mismatch for outer1 vs outer2."); // false, on no!
 }
 
-main() {
+void main() {
   test2();
 }
diff --git a/pkg/front_end/test/fasta/types/kernel_legacy_upper_bound_test.dart b/pkg/front_end/test/fasta/types/kernel_legacy_upper_bound_test.dart
index cddafb7..aeffa98 100644
--- a/pkg/front_end/test/fasta/types/kernel_legacy_upper_bound_test.dart
+++ b/pkg/front_end/test/fasta/types/kernel_legacy_upper_bound_test.dart
@@ -30,6 +30,6 @@
   }
 }
 
-main() {
+void main() {
   new KernelLegacyUpperBoundTest().test();
 }
diff --git a/pkg/front_end/test/fasta/types/kernel_type_parser_test.dart b/pkg/front_end/test/fasta/types/kernel_type_parser_test.dart
index a830713..edae38a 100644
--- a/pkg/front_end/test/fasta/types/kernel_type_parser_test.dart
+++ b/pkg/front_end/test/fasta/types/kernel_type_parser_test.dart
@@ -114,7 +114,7 @@
   return new Component(libraries: <Library>[library]);
 }
 
-main() {
+void main() {
   Uri uri = Uri.parse("dart:core");
   TypeParserEnvironment environment = new TypeParserEnvironment(uri, uri);
   Component component = parseSdk(uri, environment);
diff --git a/pkg/front_end/test/fasta/types/large_app_benchmark.dart b/pkg/front_end/test/fasta/types/large_app_benchmark.dart
index 45e9417..28c653f 100644
--- a/pkg/front_end/test/fasta/types/large_app_benchmark.dart
+++ b/pkg/front_end/test/fasta/types/large_app_benchmark.dart
@@ -8,5 +8,5 @@
 
 import "subtypes_benchmark.dart" show run;
 
-main() => run(
+void main() => run(
     Platform.script.resolve("benchmark_data/large_app.json.gz"), "LargeApp");
diff --git a/pkg/front_end/test/fasta/types/large_app_benchmark_test.dart b/pkg/front_end/test/fasta/types/large_app_benchmark_test.dart
index 4dc83be..3037003 100644
--- a/pkg/front_end/test/fasta/types/large_app_benchmark_test.dart
+++ b/pkg/front_end/test/fasta/types/large_app_benchmark_test.dart
@@ -6,4 +6,4 @@
 
 import "large_app_benchmark.dart" as bench show main;
 
-main() => bench.main();
+void main() => bench.main();
diff --git a/pkg/front_end/test/fasta/types/subtypes_benchmark.dart b/pkg/front_end/test/fasta/types/subtypes_benchmark.dart
index 99087fd..aa23ed4 100644
--- a/pkg/front_end/test/fasta/types/subtypes_benchmark.dart
+++ b/pkg/front_end/test/fasta/types/subtypes_benchmark.dart
@@ -178,4 +178,4 @@
       "${fastaWatch.elapsedMilliseconds / runs} ms");
 }
 
-main() => run(Uri.base.resolve("type_checks.json"), "***");
+void main() => run(Uri.base.resolve("type_checks.json"), "***");
diff --git a/pkg/front_end/test/fasta/uri_translator_test.dart b/pkg/front_end/test/fasta/uri_translator_test.dart
index 15733f8..d186bea 100644
--- a/pkg/front_end/test/fasta/uri_translator_test.dart
+++ b/pkg/front_end/test/fasta/uri_translator_test.dart
@@ -10,7 +10,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(UriTranslatorImplTest);
   });
diff --git a/pkg/front_end/test/fasta/util/direct_parser_ast_test.dart b/pkg/front_end/test/fasta/util/direct_parser_ast_test.dart
index c50e360..a393a6d 100644
--- a/pkg/front_end/test/fasta/util/direct_parser_ast_test.dart
+++ b/pkg/front_end/test/fasta/util/direct_parser_ast_test.dart
@@ -12,7 +12,7 @@
 
 Uri base;
 
-main(List<String> args) {
+void main(List<String> args) {
   File script = new File.fromUri(Platform.script);
   base = script.parent.uri;
 
diff --git a/pkg/front_end/test/fasta/weak_suite.dart b/pkg/front_end/test/fasta/weak_suite.dart
index 4fb7c3a..384baab 100644
--- a/pkg/front_end/test/fasta/weak_suite.dart
+++ b/pkg/front_end/test/fasta/weak_suite.dart
@@ -14,11 +14,11 @@
   return FastaContext.create(suite, environment);
 }
 
-main(List<String> arguments) {
+void main(List<String> arguments) {
   internalMain(arguments: arguments);
 }
 
-internalMain(
+void internalMain(
         {List<String> arguments = const [], int shards = 1, int shard = 0}) =>
     runMe(arguments, createContext,
         configurationPath: "../../testing.json", shard: shard, shards: shards);
diff --git a/pkg/front_end/test/ffi_test.dart b/pkg/front_end/test/ffi_test.dart
index b617fa0..02cc7fbf 100644
--- a/pkg/front_end/test/ffi_test.dart
+++ b/pkg/front_end/test/ffi_test.dart
@@ -6,7 +6,7 @@
 
 import 'package:expect/expect.dart';
 
-main() {
+void main() {
   // TODO(dacoharkes): implement dart:ffi tests
   Expect.isTrue(true);
 }
diff --git a/pkg/front_end/test/flutter_gallery_leak_tester.dart b/pkg/front_end/test/flutter_gallery_leak_tester.dart
index 1e25c00..1b5e46b 100644
--- a/pkg/front_end/test/flutter_gallery_leak_tester.dart
+++ b/pkg/front_end/test/flutter_gallery_leak_tester.dart
@@ -26,7 +26,7 @@
 // but assumes that flutter has been setup as by the script
 // `tools/bots/flutter/compile_flutter.sh`.
 
-main(List<String> args) async {
+void main(List<String> args) async {
   if (Platform.isWindows) {
     throw "This script cannot run on Windows as it uses non-Windows "
         "assumptions both for the placement of pub packages and the presence "
diff --git a/pkg/front_end/test/generated_files_up_to_date_git_test.dart b/pkg/front_end/test/generated_files_up_to_date_git_test.dart
index cb38e6a..17773be 100644
--- a/pkg/front_end/test/generated_files_up_to_date_git_test.dart
+++ b/pkg/front_end/test/generated_files_up_to_date_git_test.dart
@@ -20,7 +20,7 @@
 
 final Uri repoDir = computeRepoDirUri();
 
-main() async {
+void main() async {
   messages();
   experimentalFlags();
   directParserAstHelper();
diff --git a/pkg/front_end/test/hot_reload_e2e_test.dart b/pkg/front_end/test/hot_reload_e2e_test.dart
index 419354b..9a2a0b9 100644
--- a/pkg/front_end/test/hot_reload_e2e_test.dart
+++ b/pkg/front_end/test/hot_reload_e2e_test.dart
@@ -66,7 +66,7 @@
     }
   }
 
-  setUp() async {
+  Future<void> setUp() async {
     outDir = Directory.systemTemp.createTempSync('hotreload_test');
     outputUri = outDir.uri.resolve('test.dill');
     var root = Uri.parse('org-dartlang-test:///');
@@ -81,7 +81,7 @@
     await rebuild(compiler, outputUri); // this is a full compile.
   }
 
-  tearDown() async {
+  Future<void> tearDown() async {
     outDir.deleteSync(recursive: true);
     lines = null;
   }
@@ -102,7 +102,7 @@
 
   /// Start the VM with the first version of the program compiled by the
   /// incremental compiler.
-  startProgram(int reloadCount) async {
+  Future<void> startProgram(int reloadCount) async {
     var vmArgs = [
       '--enable-vm-service=0', // Note: use 0 to avoid port collisions.
       '--pause_isolates_on_start',
@@ -289,7 +289,7 @@
   }
 }
 
-main() {
+void main() {
   asyncTest(() async {
     await new InitialProgramIsValid().test();
     await new ReloadAfterLeafLibraryModification().test();
diff --git a/pkg/front_end/test/id_testing/id_testing_test.dart b/pkg/front_end/test/id_testing/id_testing_test.dart
index 04049e1..c7c8b83 100644
--- a/pkg/front_end/test/id_testing/id_testing_test.dart
+++ b/pkg/front_end/test/id_testing/id_testing_test.dart
@@ -30,7 +30,7 @@
         Library,
         TreeNode;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
   await runTests<String>(dataDir,
       args: args,
diff --git a/pkg/front_end/test/id_tests/assigned_variables_test.dart b/pkg/front_end/test/id_tests/assigned_variables_test.dart
index 6b8c228..8a54a08 100644
--- a/pkg/front_end/test/id_tests/assigned_variables_test.dart
+++ b/pkg/front_end/test/id_tests/assigned_variables_test.dart
@@ -19,7 +19,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart' hide Variance;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve(
       '../../../_fe_analyzer_shared/test/flow_analysis/assigned_variables/'
       'data'));
diff --git a/pkg/front_end/test/id_tests/constant_test.dart b/pkg/front_end/test/id_tests/constant_test.dart
index 07d9ed9..0b2db7e 100644
--- a/pkg/front_end/test/id_tests/constant_test.dart
+++ b/pkg/front_end/test/id_tests/constant_test.dart
@@ -23,7 +23,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script
       .resolve('../../../_fe_analyzer_shared/test/constants/data'));
   await runTests<String>(dataDir,
diff --git a/pkg/front_end/test/id_tests/definite_assignment_test.dart b/pkg/front_end/test/id_tests/definite_assignment_test.dart
index 11ad085..09b7584 100644
--- a/pkg/front_end/test/id_tests/definite_assignment_test.dart
+++ b/pkg/front_end/test/id_tests/definite_assignment_test.dart
@@ -14,7 +14,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart' hide Variance;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve(
       '../../../_fe_analyzer_shared/test/flow_analysis/definite_assignment/'
       'data'));
diff --git a/pkg/front_end/test/id_tests/definite_unassignment_test.dart b/pkg/front_end/test/id_tests/definite_unassignment_test.dart
index 1f0520c..2d25641 100644
--- a/pkg/front_end/test/id_tests/definite_unassignment_test.dart
+++ b/pkg/front_end/test/id_tests/definite_unassignment_test.dart
@@ -14,7 +14,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart' hide Variance;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve(
       '../../../_fe_analyzer_shared/test/flow_analysis/definite_unassignment/'
       'data'));
diff --git a/pkg/front_end/test/id_tests/inferred_type_arguments_test.dart b/pkg/front_end/test/id_tests/inferred_type_arguments_test.dart
index f5ad80ad..0670441 100644
--- a/pkg/front_end/test/id_tests/inferred_type_arguments_test.dart
+++ b/pkg/front_end/test/id_tests/inferred_type_arguments_test.dart
@@ -15,7 +15,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart' hide Variance;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(
       Platform.script.resolve('../../../_fe_analyzer_shared/test/'
           'inference/inferred_type_arguments/data'));
diff --git a/pkg/front_end/test/id_tests/inferred_variable_types_test.dart b/pkg/front_end/test/id_tests/inferred_variable_types_test.dart
index f5cbdfb..8403ae5 100644
--- a/pkg/front_end/test/id_tests/inferred_variable_types_test.dart
+++ b/pkg/front_end/test/id_tests/inferred_variable_types_test.dart
@@ -15,7 +15,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart' hide Variance;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(
       Platform.script.resolve('../../../_fe_analyzer_shared/test/'
           'inference/inferred_variable_types/data'));
diff --git a/pkg/front_end/test/id_tests/inheritance_test.dart b/pkg/front_end/test/id_tests/inheritance_test.dart
index 29df835..40a5ae9 100644
--- a/pkg/front_end/test/id_tests/inheritance_test.dart
+++ b/pkg/front_end/test/id_tests/inheritance_test.dart
@@ -18,7 +18,7 @@
 
 const String cfeFromBuilderMarker = 'cfe:builder';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script
       .resolve('../../../_fe_analyzer_shared/test/inheritance/data'));
   await runTests<String>(dataDir,
diff --git a/pkg/front_end/test/id_tests/nullability_test.dart b/pkg/front_end/test/id_tests/nullability_test.dart
index 222eb29..de14982 100644
--- a/pkg/front_end/test/id_tests/nullability_test.dart
+++ b/pkg/front_end/test/id_tests/nullability_test.dart
@@ -10,7 +10,7 @@
 import 'package:front_end/src/testing/id_testing_helper.dart';
 import 'package:kernel/ast.dart' hide Variance;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve(
       '../../../_fe_analyzer_shared/test/flow_analysis/nullability/data'));
   await runTests<String>(dataDir,
diff --git a/pkg/front_end/test/id_tests/reachability_test.dart b/pkg/front_end/test/id_tests/reachability_test.dart
index 7e0e1e8..7cd2ab7 100644
--- a/pkg/front_end/test/id_tests/reachability_test.dart
+++ b/pkg/front_end/test/id_tests/reachability_test.dart
@@ -16,7 +16,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart' hide Variance;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve(
       '../../../_fe_analyzer_shared/test/flow_analysis/reachability/data'));
   await runTests<Set<_ReachabilityAssertion>>(dataDir,
diff --git a/pkg/front_end/test/id_tests/type_promotion_test.dart b/pkg/front_end/test/id_tests/type_promotion_test.dart
index 1f37b47..87d3d38 100644
--- a/pkg/front_end/test/id_tests/type_promotion_test.dart
+++ b/pkg/front_end/test/id_tests/type_promotion_test.dart
@@ -13,7 +13,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart' hide Variance;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script
       .resolve('../../../_fe_analyzer_shared/test/flow_analysis/type_promotion/'
           'data'));
diff --git a/pkg/front_end/test/id_tests/why_not_promoted_test.dart b/pkg/front_end/test/id_tests/why_not_promoted_test.dart
index 0303df9..603cd8c 100644
--- a/pkg/front_end/test/id_tests/why_not_promoted_test.dart
+++ b/pkg/front_end/test/id_tests/why_not_promoted_test.dart
@@ -16,7 +16,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart' hide Variance, MapLiteralEntry;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(
       Platform.script.resolve('../../../_fe_analyzer_shared/test/flow_analysis/'
           'why_not_promoted/data'));
diff --git a/pkg/front_end/test/incremental_bulk_compiler_full.dart b/pkg/front_end/test/incremental_bulk_compiler_full.dart
index 64ecbaa..61b3899 100644
--- a/pkg/front_end/test/incremental_bulk_compiler_full.dart
+++ b/pkg/front_end/test/incremental_bulk_compiler_full.dart
@@ -28,7 +28,7 @@
 
 import 'incremental_utils.dart' as util;
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<Context> createContext(
diff --git a/pkg/front_end/test/incremental_bulk_compiler_smoke_suite.dart b/pkg/front_end/test/incremental_bulk_compiler_smoke_suite.dart
index 98f1f3b..03993a7 100644
--- a/pkg/front_end/test/incremental_bulk_compiler_smoke_suite.dart
+++ b/pkg/front_end/test/incremental_bulk_compiler_smoke_suite.dart
@@ -8,7 +8,7 @@
 
 import 'incremental_bulk_compiler_full.dart' show Context;
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<Context> createContext(
diff --git a/pkg/front_end/test/incremental_compiler_leak_test.dart b/pkg/front_end/test/incremental_compiler_leak_test.dart
index 11c65f7..675bee9 100644
--- a/pkg/front_end/test/incremental_compiler_leak_test.dart
+++ b/pkg/front_end/test/incremental_compiler_leak_test.dart
@@ -12,7 +12,7 @@
 
 const int limit = 10;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   LeakFinder heapHelper = new LeakFinder();
 
   heapHelper.start([
diff --git a/pkg/front_end/test/incremental_dart2js_load_from_dill_test.dart b/pkg/front_end/test/incremental_dart2js_load_from_dill_test.dart
index 4320981..d335bf9 100644
--- a/pkg/front_end/test/incremental_dart2js_load_from_dill_test.dart
+++ b/pkg/front_end/test/incremental_dart2js_load_from_dill_test.dart
@@ -22,7 +22,7 @@
 
 Directory outDir;
 
-main() async {
+void main() async {
   outDir =
       Directory.systemTemp.createTempSync("incremental_load_from_dill_test");
   try {
diff --git a/pkg/front_end/test/incremental_dart2js_test.dart b/pkg/front_end/test/incremental_dart2js_test.dart
index 5fef9dc..be9f6f5 100644
--- a/pkg/front_end/test/incremental_dart2js_test.dart
+++ b/pkg/front_end/test/incremental_dart2js_test.dart
@@ -6,7 +6,7 @@
 
 import "incremental_dart2js_tester.dart";
 
-main(List<String> args) async {
+void main(List<String> args) async {
   bool fast = true;
   bool useExperimentalInvalidation = true;
   bool addDebugBreaks = false;
diff --git a/pkg/front_end/test/incremental_dart2js_tester.dart b/pkg/front_end/test/incremental_dart2js_tester.dart
index 11f7783..8837c39 100644
--- a/pkg/front_end/test/incremental_dart2js_tester.dart
+++ b/pkg/front_end/test/incremental_dart2js_tester.dart
@@ -18,7 +18,7 @@
 
 import "incremental_utils.dart" as util;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   bool fast = false;
   bool useExperimentalInvalidation = false;
   bool addDebugBreaks = false;
diff --git a/pkg/front_end/test/incremental_flutter_tester.dart b/pkg/front_end/test/incremental_flutter_tester.dart
index 27ca233..5ebaf9a 100644
--- a/pkg/front_end/test/incremental_flutter_tester.dart
+++ b/pkg/front_end/test/incremental_flutter_tester.dart
@@ -46,7 +46,7 @@
   exit(1);
 }
 
-main(List<String> args) async {
+void main(List<String> args) async {
   bool fast = false;
   bool useExperimentalInvalidation = false;
   File inputFile;
diff --git a/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart b/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
index 3f2d28b..5fd461d 100644
--- a/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
+++ b/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
@@ -124,7 +124,7 @@
     return component;
   }
 
-  initialize() async {
+  Future<void> initialize() async {
     sdkRoot = computePlatformBinariesLocation(forceBuildDir: true);
     base = Uri.parse("org-dartlang-test:///");
     sdkSummary = base.resolve("vm_platform.dill");
diff --git a/pkg/front_end/test/incremental_suite.dart b/pkg/front_end/test/incremental_suite.dart
index 377d68e..51801fd 100644
--- a/pkg/front_end/test/incremental_suite.dart
+++ b/pkg/front_end/test/incremental_suite.dart
@@ -83,7 +83,7 @@
 
 import 'utils/io_utils.dart' show computeRepoDir;
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 const Expectation ExpectationFileMismatch =
@@ -916,7 +916,7 @@
       Set<String> prevFormattedErrors = formattedErrors.toSet();
       Set<String> prevFormattedWarnings = formattedWarnings.toSet();
 
-      clearPrevErrorsEtc() {
+      void clearPrevErrorsEtc() {
         gotError = false;
         formattedErrors.clear();
         gotWarning = false;
diff --git a/pkg/front_end/test/incremental_utils.dart b/pkg/front_end/test/incremental_utils.dart
index 38f97ad..8a46cd6 100644
--- a/pkg/front_end/test/incremental_utils.dart
+++ b/pkg/front_end/test/incremental_utils.dart
@@ -110,7 +110,7 @@
 class UriFinder extends RecursiveVisitor {
   Set<Uri> seenUris = new Set<Uri>();
   @override
-  defaultNode(Node node) {
+  void defaultNode(Node node) {
     super.defaultNode(node);
     if (node is FileUriNode) {
       seenUris.add(node.fileUri);
diff --git a/pkg/front_end/test/issue_34856_test.dart b/pkg/front_end/test/issue_34856_test.dart
index 396a0bb..d291270 100644
--- a/pkg/front_end/test/issue_34856_test.dart
+++ b/pkg/front_end/test/issue_34856_test.dart
@@ -106,6 +106,6 @@
   }
 }
 
-main() {
+void main() {
   asyncTest(test);
 }
diff --git a/pkg/front_end/test/kernel_generator_test.dart b/pkg/front_end/test/kernel_generator_test.dart
index 209e853..cf8ce12 100644
--- a/pkg/front_end/test/kernel_generator_test.dart
+++ b/pkg/front_end/test/kernel_generator_test.dart
@@ -34,7 +34,7 @@
         invalidCoreLibsSpecUri,
         isDartCoreLibrary;
 
-main() {
+void main() {
   group('kernelForProgram', () {
     test('compiler fails if it cannot find sdk sources', () async {
       var errors = [];
diff --git a/pkg/front_end/test/language_versioning/language_versioning_test.dart b/pkg/front_end/test/language_versioning/language_versioning_test.dart
index e8efa59..c1a9f1c 100644
--- a/pkg/front_end/test/language_versioning/language_versioning_test.dart
+++ b/pkg/front_end/test/language_versioning/language_versioning_test.dart
@@ -26,7 +26,7 @@
 
 import 'package:kernel/ast.dart' show Component, Library, Version;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   // Fix default/max major and minor version so we can test it.
   // This config sets it to 2.8.
   TestConfigWithLanguageVersion cfeConfig =
diff --git a/pkg/front_end/test/language_versioning/language_versioning_up_to_date_git_test.dart b/pkg/front_end/test/language_versioning/language_versioning_up_to_date_git_test.dart
index d79b1fd..09ddce5 100644
--- a/pkg/front_end/test/language_versioning/language_versioning_up_to_date_git_test.dart
+++ b/pkg/front_end/test/language_versioning/language_versioning_up_to_date_git_test.dart
@@ -16,7 +16,7 @@
 
 String get dartVm => Platform.executable;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   ProcessResult result = await Process.run(
       "python3", ["tools/make_version.py", "--no_git", "-q"],
       workingDirectory: repoDir);
diff --git a/pkg/front_end/test/lint_suite.dart b/pkg/front_end/test/lint_suite.dart
index d1c67db..8e11c97 100644
--- a/pkg/front_end/test/lint_suite.dart
+++ b/pkg/front_end/test/lint_suite.dart
@@ -34,7 +34,7 @@
 
 import 'testing_utils.dart' show checkEnvironment, getGitFiles;
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<Context> createContext(
@@ -210,7 +210,7 @@
   @override
   Uri uri;
 
-  onProblem(int offset, int squigglyLength, String message) {
+  void onProblem(int offset, int squigglyLength, String message) {
     problems.add(description.getErrorMessage(offset, squigglyLength, message));
   }
 }
diff --git a/pkg/front_end/test/member_covariance_test.dart b/pkg/front_end/test/member_covariance_test.dart
index aadc962..93ff6e4 100644
--- a/pkg/front_end/test/member_covariance_test.dart
+++ b/pkg/front_end/test/member_covariance_test.dart
@@ -8,7 +8,7 @@
 import 'package:kernel/ast.dart';
 import 'package:front_end/src/fasta/kernel/member_covariance.dart';
 
-main() {
+void main() {
   void checkEquals(Covariance a, Covariance b) {
     Expect.equals(a, b);
     Expect.equals(a.hashCode, b.hashCode);
diff --git a/pkg/front_end/test/memory_file_system_test.dart b/pkg/front_end/test/memory_file_system_test.dart
index 3e23b79..c5a743f 100644
--- a/pkg/front_end/test/memory_file_system_test.dart
+++ b/pkg/front_end/test/memory_file_system_test.dart
@@ -18,7 +18,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(MemoryFileSystemTestNative);
     defineReflectiveTests(MemoryFileSystemTestPosix);
@@ -35,108 +35,108 @@
   String path;
   MemoryFileSystemEntity file;
 
-  setUp() {
+  void setUp() {
     _baseSetUp();
     path = join(tempPath, 'file.txt');
     file = entityForPath(path);
   }
 
-  test_createDirectory_doesNotExist() async {
+  void test_createDirectory_doesNotExist() async {
     file.createDirectory();
     expect(await file.exists(), true);
   }
 
-  test_createDirectory_exists_asDirectory() async {
+  void test_createDirectory_exists_asDirectory() async {
     file.createDirectory();
     file.createDirectory();
     expect(await file.exists(), true);
   }
 
-  test_createDirectory_exists_asFile() async {
+  void test_createDirectory_exists_asFile() async {
     file.writeAsStringSync('');
     expect(() => file.createDirectory(), _throwsFileSystemException);
   }
 
-  test_equals_differentPaths() {
+  void test_equals_differentPaths() {
     expect(file == entityForPath(join(tempPath, 'file2.txt')), isFalse);
   }
 
-  test_equals_samePath() {
+  void test_equals_samePath() {
     expect(file == entityForPath(join(tempPath, 'file.txt')), isTrue);
   }
 
-  test_exists_directory_exists() async {
+  void test_exists_directory_exists() async {
     file.createDirectory();
     expect(await file.exists(), true);
   }
 
-  test_exists_doesNotExist() async {
+  void test_exists_doesNotExist() async {
     expect(await file.exists(), false);
   }
 
-  test_exists_file_exists() async {
+  void test_exists_file_exists() async {
     file.writeAsStringSync('x');
     expect(await file.exists(), true);
   }
 
-  test_hashCode_samePath() {
+  void test_hashCode_samePath() {
     expect(file.hashCode, entityForPath(join(tempPath, 'file.txt')).hashCode);
   }
 
-  test_path() {
+  void test_path() {
     expect(file.uri, context.toUri(path));
   }
 
-  test_readAsBytes_badUtf8() async {
+  void test_readAsBytes_badUtf8() async {
     // A file containing invalid UTF-8 can still be read as raw bytes.
     List<int> bytes = [0xc0, 0x40]; // Invalid UTF-8
     file.writeAsBytesSync(bytes);
     expect(await file.readAsBytes(), bytes);
   }
 
-  test_readAsBytes_doesNotExist() {
+  void test_readAsBytes_doesNotExist() {
     expect(file.readAsBytes(), _throwsFileSystemException);
   }
 
-  test_readAsBytes_exists() async {
+  void test_readAsBytes_exists() async {
     var s = 'contents';
     file.writeAsStringSync(s);
     expect(await file.readAsBytes(), utf8.encode(s));
   }
 
-  test_readAsString_badUtf8() {
+  void test_readAsString_badUtf8() {
     file.writeAsBytesSync([0xc0, 0x40]); // Invalid UTF-8
     expect(file.readAsString(), _throwsFileSystemException);
   }
 
-  test_readAsString_doesNotExist() {
+  void test_readAsString_doesNotExist() {
     expect(file.readAsString(), _throwsFileSystemException);
   }
 
-  test_readAsString_exists() async {
+  void test_readAsString_exists() async {
     var s = 'contents';
     file.writeAsStringSync(s);
     expect(await file.readAsString(), s);
   }
 
-  test_readAsString_utf8() async {
+  void test_readAsString_utf8() async {
     file.writeAsBytesSync([0xe2, 0x82, 0xac]); // Unicode € symbol, in UTF-8
     expect(await file.readAsString(), '\u20ac');
   }
 
-  test_writeAsBytesSync_directory() async {
+  void test_writeAsBytesSync_directory() async {
     file.createDirectory();
     expect(() => file.writeAsBytesSync([0]), _throwsFileSystemException);
   }
 
-  test_writeAsBytesSync_modifyAfterRead() async {
+  void test_writeAsBytesSync_modifyAfterRead() async {
     // For efficiency we do not make defensive copies.
     file.writeAsBytesSync([1]);
     (await file.readAsBytes())[0] = 2;
     expect(await file.readAsBytes(), [2]);
   }
 
-  test_writeAsBytesSync_modifyAfterWrite_Uint8List() async {
+  void test_writeAsBytesSync_modifyAfterWrite_Uint8List() async {
     // For efficiency we do not make defensive copies.
     var bytes = new Uint8List.fromList([1]);
     file.writeAsBytesSync(bytes);
@@ -144,7 +144,7 @@
     expect(await file.readAsBytes(), [2]);
   }
 
-  test_writeAsBytesSync_modifyAfterWrite() async {
+  void test_writeAsBytesSync_modifyAfterWrite() async {
     // For efficiency we generally do not make defensive copies, but on the
     // other hrand we keep everything as `Uint8List`s internally, so in this
     // case a copy is actually made.
@@ -154,24 +154,24 @@
     expect(await file.readAsBytes(), [1]);
   }
 
-  test_writeAsBytesSync_overwrite() async {
+  void test_writeAsBytesSync_overwrite() async {
     file.writeAsBytesSync([1]);
     file.writeAsBytesSync([2]);
     expect(await file.readAsBytes(), [2]);
   }
 
-  test_writeAsStringSync_directory() async {
+  void test_writeAsStringSync_directory() async {
     file.createDirectory();
     expect(() => file.writeAsStringSync(''), _throwsFileSystemException);
   }
 
-  test_writeAsStringSync_overwrite() async {
+  void test_writeAsStringSync_overwrite() async {
     file.writeAsStringSync('first');
     file.writeAsStringSync('second');
     expect(await file.readAsString(), 'second');
   }
 
-  test_writeAsStringSync_utf8() async {
+  void test_writeAsStringSync_utf8() async {
     file.writeAsStringSync('\u20ac'); // Unicode € symbol
     expect(await file.readAsBytes(), [0xe2, 0x82, 0xac]);
   }
@@ -180,12 +180,12 @@
 abstract class MemoryFileSystemTestMixin implements _BaseTest {
   Uri tempUri;
 
-  setUp() {
+  void setUp() {
     _baseSetUp();
     tempUri = context.toUri(tempPath);
   }
 
-  test_currentDirectory_trailingSlash() {
+  void test_currentDirectory_trailingSlash() {
     // The currentDirectory should already end in a trailing slash.
     expect(fileSystem.currentDirectory.path, endsWith('/'));
     // A trailing slash should automatically be appended when creating a
@@ -201,27 +201,27 @@
         fileSystem.currentDirectory);
   }
 
-  test_entityForPath_absolutize() {
+  void test_entityForPath_absolutize() {
     expect(entityForPath('file.txt').uri,
         fileSystem.currentDirectory.resolve('file.txt'));
   }
 
-  test_entityForPath_normalize_dot() {
+  void test_entityForPath_normalize_dot() {
     expect(entityForPath(join(tempPath, '.', 'file.txt')).uri,
         Uri.parse('$tempUri/file.txt'));
   }
 
-  test_entityForPath_normalize_dotDot() {
+  void test_entityForPath_normalize_dotDot() {
     expect(entityForPath(join(tempPath, 'foo', '..', 'file.txt')).uri,
         Uri.parse('$tempUri/file.txt'));
   }
 
-  test_entityForUri() {
+  void test_entityForUri() {
     expect(fileSystem.entityForUri(Uri.parse('$tempUri/file.txt')).uri,
         Uri.parse('$tempUri/file.txt'));
   }
 
-  test_entityForUri_fileUri_relative() {
+  void test_entityForUri_fileUri_relative() {
     // A weird quirk of the Uri class is that it doesn't seem possible to create
     // a `file:` uri with a relative path, no matter how many slashes you use or
     // if you populate the fields directly.  But just to be certain, try to do
@@ -240,17 +240,17 @@
     }
   }
 
-  test_entityForUri_nonFileUri() {
+  void test_entityForUri_nonFileUri() {
     var uri = Uri.parse('package:foo/bar.dart');
     expect(fileSystem.entityForUri(uri).uri, uri);
   }
 
-  test_entityForUri_normalize_dot() {
+  void test_entityForUri_normalize_dot() {
     expect(fileSystem.entityForUri(Uri.parse('$tempUri/./file.txt')).uri,
         Uri.parse('$tempUri/file.txt'));
   }
 
-  test_entityForUri_normalize_dotDot() {
+  void test_entityForUri_normalize_dotDot() {
     expect(fileSystem.entityForUri(Uri.parse('$tempUri/foo/../file.txt')).uri,
         Uri.parse('$tempUri/file.txt'));
   }
@@ -295,7 +295,7 @@
       pathos.join(path1, path2, path3, path4);
 
   @override
-  _baseSetUp() {
+  void _baseSetUp() {
     tempPath = pathos.join(io.Directory.systemTemp.path, 'test_file_system');
     fileSystem = new MemoryFileSystem(pathos.toUri(io.Directory.current.path));
   }
diff --git a/pkg/front_end/test/messages_json_test.dart b/pkg/front_end/test/messages_json_test.dart
index 7f87ca4..dff07bd 100644
--- a/pkg/front_end/test/messages_json_test.dart
+++ b/pkg/front_end/test/messages_json_test.dart
@@ -19,7 +19,7 @@
 
 /// Test that turning a message into json and back again retains the wanted
 /// information.
-main() {
+void main() {
   for (int i = 0; i < Severity.values.length; i++) {
     Severity severity = Severity.values[i];
     Code code = new Code("MyCodeName");
diff --git a/pkg/front_end/test/mixin_export_test.dart b/pkg/front_end/test/mixin_export_test.dart
index 6b75f19..ff1f579 100644
--- a/pkg/front_end/test/mixin_export_test.dart
+++ b/pkg/front_end/test/mixin_export_test.dart
@@ -9,7 +9,7 @@
 import 'package:front_end/src/testing/compiler_common.dart';
 import 'package:front_end/src/api_prototype/front_end.dart';
 
-main() {
+void main() {
   asyncTest(() async {
     var sources = <String, dynamic>{
       'a.dart': 'class A extends Object with M {}  class M {}',
diff --git a/pkg/front_end/test/multiple_simultaneous_compiles_test.dart b/pkg/front_end/test/multiple_simultaneous_compiles_test.dart
index 3e5d055..e09aae3 100644
--- a/pkg/front_end/test/multiple_simultaneous_compiles_test.dart
+++ b/pkg/front_end/test/multiple_simultaneous_compiles_test.dart
@@ -18,7 +18,7 @@
 
 import 'incremental_suite.dart' show getOptions;
 
-main() async {
+void main() async {
   Uri compileTarget = Platform.script.resolve("binary_md_dill_reader.dart");
   if (!(new File.fromUri(compileTarget)).existsSync()) {
     throw "$compileTarget doesn't exist";
diff --git a/pkg/front_end/test/packages_format_error_test.dart b/pkg/front_end/test/packages_format_error_test.dart
index 7514228..a9fa5f3 100644
--- a/pkg/front_end/test/packages_format_error_test.dart
+++ b/pkg/front_end/test/packages_format_error_test.dart
@@ -25,7 +25,7 @@
 import 'package:front_end/src/fasta/messages.dart'
     show codeCantReadFile, codePackagesFileFormat;
 
-main() {
+void main() {
   Uri root = Uri.parse("org-dartlang-test:///");
   MemoryFileSystem fs = new MemoryFileSystem(root);
   Uri packages = root.resolve(".packages");
diff --git a/pkg/front_end/test/parser_all_suite.dart b/pkg/front_end/test/parser_all_suite.dart
index 837567f..9aab3a5 100644
--- a/pkg/front_end/test/parser_all_suite.dart
+++ b/pkg/front_end/test/parser_all_suite.dart
@@ -8,7 +8,7 @@
 
 import 'parser_suite.dart';
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<ChainContext> createContext(
diff --git a/pkg/front_end/test/parser_equivalence_suite.dart b/pkg/front_end/test/parser_equivalence_suite.dart
index 3369a16..5e4d772 100644
--- a/pkg/front_end/test/parser_equivalence_suite.dart
+++ b/pkg/front_end/test/parser_equivalence_suite.dart
@@ -16,7 +16,7 @@
 import 'parser_suite.dart'
     show ListenerStep, ParserTestListenerWithMessageFormatting;
 
-main([List<String> arguments = const []]) => runMe(
+void main([List<String> arguments = const []]) => runMe(
       arguments,
       createContext,
       configurationPath: "../testing.json",
diff --git a/pkg/front_end/test/parser_suite.dart b/pkg/front_end/test/parser_suite.dart
index cebf5f7..cdb9645 100644
--- a/pkg/front_end/test/parser_suite.dart
+++ b/pkg/front_end/test/parser_suite.dart
@@ -66,7 +66,7 @@
 ]
 ''';
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<Context> createContext(
diff --git a/pkg/front_end/test/parser_test_listener_creator.dart b/pkg/front_end/test/parser_test_listener_creator.dart
index 648b5e0..508e479 100644
--- a/pkg/front_end/test/parser_test_listener_creator.dart
+++ b/pkg/front_end/test/parser_test_listener_creator.dart
@@ -15,7 +15,7 @@
 
 import 'utils/io_utils.dart' show computeRepoDirUri;
 
-main(List<String> args) {
+void main(List<String> args) {
   final Uri repoDir = computeRepoDirUri();
   String generated = generateTestListener(repoDir);
   new File.fromUri(computeTestListenerUri(repoDir))
diff --git a/pkg/front_end/test/parser_test_parser_creator.dart b/pkg/front_end/test/parser_test_parser_creator.dart
index 0a4d4d7..ccc24c3 100644
--- a/pkg/front_end/test/parser_test_parser_creator.dart
+++ b/pkg/front_end/test/parser_test_parser_creator.dart
@@ -14,7 +14,7 @@
 
 import 'utils/io_utils.dart' show computeRepoDirUri;
 
-main(List<String> args) {
+void main(List<String> args) {
   final Uri repoDir = computeRepoDirUri();
   String generated = generateTestParser(repoDir);
   new File.fromUri(computeTestParserUri(repoDir))
diff --git a/pkg/front_end/test/patching/patching_test.dart b/pkg/front_end/test/patching/patching_test.dart
index 3389f04..8ad7d4e 100644
--- a/pkg/front_end/test/patching/patching_test.dart
+++ b/pkg/front_end/test/patching/patching_test.dart
@@ -19,7 +19,7 @@
 import 'package:front_end/src/testing/id_testing_utils.dart';
 import 'package:kernel/ast.dart';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
   await runTests<Features>(dataDir,
       args: args,
diff --git a/pkg/front_end/test/precedence_info_test.dart b/pkg/front_end/test/precedence_info_test.dart
index fd88c3e..cce5241 100644
--- a/pkg/front_end/test/precedence_info_test.dart
+++ b/pkg/front_end/test/precedence_info_test.dart
@@ -12,7 +12,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(PrecedenceInfoTest);
   });
diff --git a/pkg/front_end/test/predicates/predicate_test.dart b/pkg/front_end/test/predicates/predicate_test.dart
index 8398984..98ed0cb 100644
--- a/pkg/front_end/test/predicates/predicate_test.dart
+++ b/pkg/front_end/test/predicates/predicate_test.dart
@@ -23,7 +23,7 @@
 const String isNullMarker = 'is-null';
 const String sentinelMarker = 'sentinel';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
   await runTests<Features>(dataDir,
       args: args,
diff --git a/pkg/front_end/test/read_dill_from_binary_md_git_test.dart b/pkg/front_end/test/read_dill_from_binary_md_git_test.dart
index fb6ccaf..7d2da16 100644
--- a/pkg/front_end/test/read_dill_from_binary_md_git_test.dart
+++ b/pkg/front_end/test/read_dill_from_binary_md_git_test.dart
@@ -14,7 +14,7 @@
 
 import 'utils/io_utils.dart' show computeRepoDir;
 
-main() async {
+void main() async {
   await testDart2jsCompile();
 }
 
diff --git a/pkg/front_end/test/relativize_test.dart b/pkg/front_end/test/relativize_test.dart
index 28c4acc..c42fac6 100644
--- a/pkg/front_end/test/relativize_test.dart
+++ b/pkg/front_end/test/relativize_test.dart
@@ -16,7 +16,7 @@
         return;
       }
 
-      test(Uri base, Uri uri) {
+      void test(Uri base, Uri uri) {
         String r = relativizeUri(base, uri, isWindows);
         Uri resolved = base.resolve(r);
         expect(resolved.scheme.toLowerCase(), uri.scheme.toLowerCase());
diff --git a/pkg/front_end/test/scanner_fasta_test.dart b/pkg/front_end/test/scanner_fasta_test.dart
index 8f02119..b5c55b5 100644
--- a/pkg/front_end/test/scanner_fasta_test.dart
+++ b/pkg/front_end/test/scanner_fasta_test.dart
@@ -20,7 +20,7 @@
 
 import 'scanner_test.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ScannerTest_Fasta);
     defineReflectiveTests(ScannerTest_Fasta_FuzzTestAPI);
@@ -32,7 +32,7 @@
 
 @reflectiveTest
 class ScannerTest_Fasta_FuzzTestAPI {
-  test_API() {
+  void test_API() {
     // These two API are used when fuzz testing the scanner.
     String source = 'class A { }';
 
@@ -76,8 +76,8 @@
     return token;
   }
 
-  test_invalid_utf8() {
-    printBytes(List<int> bytes) {
+  void test_invalid_utf8() {
+    void printBytes(List<int> bytes) {
       var hex = bytes.map((b) => '0x${b.toRadixString(16).toUpperCase()}');
       print('$bytes\n[${hex.join(', ')}]');
       try {
@@ -88,7 +88,7 @@
       }
     }
 
-    scanBytes(List<int> bytes) {
+    ScannerResult scanBytes(List<int> bytes) {
       try {
         return usedForFuzzTesting.scan(bytes);
       } catch (e) {
@@ -373,7 +373,7 @@
 abstract class ScannerTest_Fasta_Base {
   Token scan(String source);
 
-  expectToken(Token token, TokenType type, int offset, int length,
+  void expectToken(Token token, TokenType type, int offset, int length,
       {bool isSynthetic: false, String lexeme}) {
     String description = '${token.type} $token';
     expect(token.type, type, reason: description);
diff --git a/pkg/front_end/test/scanner_replacement_test.dart b/pkg/front_end/test/scanner_replacement_test.dart
index 9666738..dff9d26 100644
--- a/pkg/front_end/test/scanner_replacement_test.dart
+++ b/pkg/front_end/test/scanner_replacement_test.dart
@@ -14,7 +14,7 @@
 
 import 'scanner_test.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ScannerTest_Replacement);
   });
diff --git a/pkg/front_end/test/scanner_test.dart b/pkg/front_end/test/scanner_test.dart
index 4a62db4..cbf28bc 100644
--- a/pkg/front_end/test/scanner_test.dart
+++ b/pkg/front_end/test/scanner_test.dart
@@ -13,7 +13,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(CharSequenceReaderTest);
     defineReflectiveTests(TokenTypeTest);
@@ -1544,7 +1544,7 @@
   TestError(this.offset, this.errorCode, this.arguments);
 
   @override
-  get hashCode {
+  int get hashCode {
     int h = combineHash(combineHash(0, offset), errorCode.hashCode);
     if (arguments != null) {
       for (Object argument in arguments) {
@@ -1555,7 +1555,7 @@
   }
 
   @override
-  operator ==(Object other) {
+  bool operator ==(Object other) {
     if (other is TestError &&
         offset == other.offset &&
         errorCode == other.errorCode) {
@@ -1571,7 +1571,7 @@
   }
 
   @override
-  toString() {
+  String toString() {
     var argString = arguments == null ? '' : '(${arguments.join(', ')})';
     return 'Error($offset, $errorCode$argString)';
   }
diff --git a/pkg/front_end/test/scheme_based_file_system_test.dart b/pkg/front_end/test/scheme_based_file_system_test.dart
index 35ae1bf..2cbe46e 100644
--- a/pkg/front_end/test/scheme_based_file_system_test.dart
+++ b/pkg/front_end/test/scheme_based_file_system_test.dart
@@ -9,7 +9,7 @@
 
 import 'package:test/test.dart';
 
-main() {
+void main() {
   test('lookup of registered schemes is handled', () {
     var fs1 = new MockFileSystem('scheme1');
     var fs2 = new MockFileSystem('scheme2');
@@ -50,5 +50,5 @@
   MockFileSystemEntity(this.uri, this.fileSystem);
 
   @override
-  noSuchMethod(m) => super.noSuchMethod(m);
+  dynamic noSuchMethod(m) => super.noSuchMethod(m);
 }
diff --git a/pkg/front_end/test/severity_index_test.dart b/pkg/front_end/test/severity_index_test.dart
index 8dc6f14..105e46b 100644
--- a/pkg/front_end/test/severity_index_test.dart
+++ b/pkg/front_end/test/severity_index_test.dart
@@ -8,7 +8,7 @@
 
 /// Test that Severity has the expected indexes. Note that this is important
 /// and shouldn't be changed lightly because we use it in serialization!
-main() {
+void main() {
   expect(Severity.context.index, 0);
   expect(Severity.error.index, 1);
   expect(Severity.internalProblem.index, 3);
diff --git a/pkg/front_end/test/spell_checking_cleanup_lists.dart b/pkg/front_end/test/spell_checking_cleanup_lists.dart
index 6f38991..ea44732 100644
--- a/pkg/front_end/test/spell_checking_cleanup_lists.dart
+++ b/pkg/front_end/test/spell_checking_cleanup_lists.dart
@@ -8,7 +8,7 @@
 
 import 'spell_checking_utils.dart' as spell;
 
-main() {
+void main() {
   {
     spell.ensureDictionariesLoaded([spell.Dictionaries.common]);
     Set<String> commonWords =
diff --git a/pkg/front_end/test/spelling_test_external_targets.dart b/pkg/front_end/test/spelling_test_external_targets.dart
index 0c48782..952f4b3 100644
--- a/pkg/front_end/test/spelling_test_external_targets.dart
+++ b/pkg/front_end/test/spelling_test_external_targets.dart
@@ -15,7 +15,7 @@
 
 import 'testing_utils.dart' show checkEnvironment;
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<SpellContext> createContext(
diff --git a/pkg/front_end/test/spelling_test_not_src_suite.dart b/pkg/front_end/test/spelling_test_not_src_suite.dart
index 6504052..9eb9921e 100644
--- a/pkg/front_end/test/spelling_test_not_src_suite.dart
+++ b/pkg/front_end/test/spelling_test_not_src_suite.dart
@@ -12,7 +12,7 @@
 
 import 'testing_utils.dart' show checkEnvironment;
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<SpellContext> createContext(
diff --git a/pkg/front_end/test/spelling_test_src_suite.dart b/pkg/front_end/test/spelling_test_src_suite.dart
index 4ea5bb0..f77e918 100644
--- a/pkg/front_end/test/spelling_test_src_suite.dart
+++ b/pkg/front_end/test/spelling_test_src_suite.dart
@@ -12,7 +12,7 @@
 
 import 'testing_utils.dart' show checkEnvironment;
 
-main([List<String> arguments = const []]) =>
+void main([List<String> arguments = const []]) =>
     runMe(arguments, createContext, configurationPath: "../testing.json");
 
 Future<SpellContext> createContext(
diff --git a/pkg/front_end/test/split_dill_test.dart b/pkg/front_end/test/split_dill_test.dart
index 59d1d91..f4ebb71 100644
--- a/pkg/front_end/test/split_dill_test.dart
+++ b/pkg/front_end/test/split_dill_test.dart
@@ -22,7 +22,7 @@
 
 import 'utils/io_utils.dart' show computeRepoDir;
 
-main() async {
+void main() async {
   final Uri dart2jsUrl = Uri.base.resolve("pkg/compiler/bin/dart2js.dart");
   Stopwatch stopwatch = new Stopwatch()..start();
   Component component = await normalCompileToComponent(dart2jsUrl,
diff --git a/pkg/front_end/test/src/base/libraries_specification_test.dart b/pkg/front_end/test/src/base/libraries_specification_test.dart
index 14cbae1..033a877 100644
--- a/pkg/front_end/test/src/base/libraries_specification_test.dart
+++ b/pkg/front_end/test/src/base/libraries_specification_test.dart
@@ -7,7 +7,7 @@
 import 'package:front_end/src/base/libraries_specification.dart';
 import 'package:test/test.dart';
 
-main() {
+void main() {
   group('parse', () {
     test('top-level must be a map', () async {
       var jsonString = '[]';
diff --git a/pkg/front_end/test/src/base/processed_options_test.dart b/pkg/front_end/test/src/base/processed_options_test.dart
index 9da4fd3..529e56b 100644
--- a/pkg/front_end/test/src/base/processed_options_test.dart
+++ b/pkg/front_end/test/src/base/processed_options_test.dart
@@ -22,7 +22,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   CompilerContext.runWithDefaultOptions((_) {
     defineReflectiveSuite(() {
       defineReflectiveTests(ProcessedOptionsTest);
@@ -45,7 +45,7 @@
         ..setMainMethodAndMode(
             null, false, NonNullableByDefaultCompiledMode.Weak);
 
-  test_compileSdk_false() {
+  void test_compileSdk_false() {
     for (var value in [false, true]) {
       var raw = new CompilerOptions()..compileSdk = value;
       var processed = new ProcessedOptions(options: raw);
@@ -53,7 +53,7 @@
     }
   }
 
-  test_sdk_summary_inferred() {
+  void test_sdk_summary_inferred() {
     // The sdk-summary is inferred by default form sdk-root, when compile-sdk is
     // false
     var raw = new CompilerOptions()
@@ -69,7 +69,7 @@
     expect(new ProcessedOptions(options: raw).sdkSummary, null);
   }
 
-  test_fileSystem_noBazelRoots() {
+  void test_fileSystem_noBazelRoots() {
     // When no bazel roots are specified, the filesystem should be passed
     // through unmodified.
     var raw = new CompilerOptions()..fileSystem = fileSystem;
@@ -77,7 +77,7 @@
     expect(processed.fileSystem, same(fileSystem));
   }
 
-  test_getSdkSummaryBytes_summaryLocationProvided() async {
+  void test_getSdkSummaryBytes_summaryLocationProvided() async {
     var uri = Uri.parse('org-dartlang-test:///sdkSummary');
 
     writeMockSummaryTo(uri);
@@ -95,7 +95,7 @@
         mockSummary.libraries.single.importUri);
   }
 
-  test_getSdkSummary_summaryLocationProvided() async {
+  void test_getSdkSummary_summaryLocationProvided() async {
     var uri = Uri.parse('org-dartlang-test:///sdkSummary');
     writeMockSummaryTo(uri);
     await checkMockSummary(new CompilerOptions()
@@ -116,7 +116,7 @@
         mockSummary.libraries.single.importUri);
   }
 
-  test_getUriTranslator_explicitLibrariesSpec() async {
+  void test_getUriTranslator_explicitLibrariesSpec() async {
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///.packages'))
         .writeAsStringSync('');
@@ -134,7 +134,7 @@
         '/bar.dart');
   }
 
-  test_getUriTranslator_inferredLibrariesSpec() async {
+  void test_getUriTranslator_inferredLibrariesSpec() async {
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///.packages'))
         .writeAsStringSync('');
@@ -153,7 +153,7 @@
         '/mysdk/lib/bar.dart');
   }
 
-  test_getUriTranslator_notInferredLibrariesSpec() async {
+  void test_getUriTranslator_notInferredLibrariesSpec() async {
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///.packages'))
         .writeAsStringSync('');
@@ -171,14 +171,14 @@
     expect(uriTranslator.dartLibraries.libraryInfoFor('foo'), isNull);
   }
 
-  checkPackageExpansion(
+  void checkPackageExpansion(
       String packageName, String packageDir, PackageConfig packages) {
     var input = Uri.parse('package:$packageName/a.dart');
     var expected = Uri.parse('org-dartlang-test:///$packageDir/a.dart');
     expect(packages.resolve(input), expected);
   }
 
-  test_getUriTranslator_explicitPackagesFile() async {
+  void test_getUriTranslator_explicitPackagesFile() async {
     // This .packages file should be ignored.
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///.packages'))
@@ -195,7 +195,7 @@
     checkPackageExpansion('foo', 'baz', uriTranslator.packages);
   }
 
-  test_getUriTranslator_explicitPackagesFile_withBaseLocation() async {
+  void test_getUriTranslator_explicitPackagesFile_withBaseLocation() async {
     // This .packages file should be ignored.
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///.packages'))
@@ -214,7 +214,7 @@
     checkPackageExpansion('foo', 'base/location/baz', uriTranslator.packages);
   }
 
-  test_getUriTranslator_implicitPackagesFile_ambiguous() async {
+  void test_getUriTranslator_implicitPackagesFile_ambiguous() async {
     // This .packages file should be ignored.
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///.packages'))
@@ -231,7 +231,7 @@
     checkPackageExpansion('foo', 'baz', uriTranslator.packages);
   }
 
-  test_getUriTranslator_implicitPackagesFile_nextToScript() async {
+  void test_getUriTranslator_implicitPackagesFile_nextToScript() async {
     // Create the base directory.
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///base/location/'))
@@ -256,7 +256,7 @@
     checkPackageExpansion('foo', 'base/location/baz', uriTranslator.packages);
   }
 
-  test_getUriTranslator_implicitPackagesFile_searchAbove() async {
+  void test_getUriTranslator_implicitPackagesFile_searchAbove() async {
     // Create the base directory.
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///base/location/'))
@@ -277,7 +277,7 @@
     checkPackageExpansion('foo', 'base/baz', uriTranslator.packages);
   }
 
-  test_getUriTranslator_implicitPackagesFile_packagesDirectory() async {
+  void test_getUriTranslator_implicitPackagesFile_packagesDirectory() async {
     // Create the base directory.
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///base/location/'))
@@ -302,7 +302,7 @@
     checkPackageExpansion('foo', 'base/baz', uriTranslator.packages);
   }
 
-  test_getUriTranslator_implicitPackagesFile_noPackages() async {
+  void test_getUriTranslator_implicitPackagesFile_noPackages() async {
     // Create the base directory.
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///base/location/'))
@@ -320,7 +320,7 @@
     expect(uriTranslator.packages.packages, isEmpty);
   }
 
-  test_getUriTranslator_noPackages() async {
+  void test_getUriTranslator_noPackages() async {
     var errors = [];
     // .packages file should be ignored.
     fileSystem
@@ -337,7 +337,7 @@
         startsWith(_stringPrefixOf(templateCantReadFile)));
   }
 
-  test_validateOptions_noInputs() async {
+  void test_validateOptions_noInputs() async {
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///foo.dart'))
         .writeAsStringSync('main(){}\n');
@@ -351,7 +351,7 @@
     expect(result, isFalse);
   }
 
-  test_validateOptions_input_doesnt_exist() async {
+  void test_validateOptions_input_doesnt_exist() async {
     var errors = [];
     var raw = new CompilerOptions()
       ..fileSystem = fileSystem
@@ -363,7 +363,7 @@
     expect(result, isTrue);
   }
 
-  test_validateOptions_root_exists() async {
+  void test_validateOptions_root_exists() async {
     var sdkRoot = Uri.parse('org-dartlang-test:///sdk/root/');
     fileSystem
         // Note: this test is a bit hackish because the memory file system
@@ -390,7 +390,7 @@
     expect(result, isTrue);
   }
 
-  test_validateOptions_root_doesnt_exists() async {
+  void test_validateOptions_root_doesnt_exists() async {
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///foo.dart'))
         .writeAsStringSync('main(){}\n');
@@ -407,7 +407,7 @@
         startsWith(_stringPrefixOf(templateSdkRootNotFound)));
   }
 
-  test_validateOptions_summary_exists() async {
+  void test_validateOptions_summary_exists() async {
     var sdkSummary = Uri.parse('org-dartlang-test:///sdk/root/outline.dill');
     fileSystem.entityForUri(sdkSummary).writeAsStringSync('\n');
     fileSystem
@@ -426,7 +426,7 @@
     expect(result, isTrue);
   }
 
-  test_validateOptions_summary_doesnt_exists() async {
+  void test_validateOptions_summary_doesnt_exists() async {
     fileSystem
         .entityForUri(Uri.parse('org-dartlang-test:///foo.dart'))
         .writeAsStringSync('main(){}\n');
@@ -443,7 +443,7 @@
         startsWith(_stringPrefixOf(templateSdkSummaryNotFound)));
   }
 
-  test_validateOptions_inferred_summary_exists() async {
+  void test_validateOptions_inferred_summary_exists() async {
     var sdkRoot = Uri.parse('org-dartlang-test:///sdk/root/');
     var sdkSummary =
         Uri.parse('org-dartlang-test:///sdk/root/vm_platform_strong.dill');
@@ -465,7 +465,7 @@
     expect(result, isTrue);
   }
 
-  test_validateOptions_inferred_summary_doesnt_exists() async {
+  void test_validateOptions_inferred_summary_doesnt_exists() async {
     var sdkRoot = Uri.parse('org-dartlang-test:///sdk/root/');
     var sdkSummary = Uri.parse('org-dartlang-test:///sdk/root/outline.dill');
     fileSystem.entityForUri(sdkRoot).writeAsStringSync('\n');
@@ -486,7 +486,7 @@
 
   /// Returns the longest prefix of the text in a message template that doesn't
   /// mention a template argument.
-  _stringPrefixOf(Template template) {
+  String _stringPrefixOf(Template template) {
     var messageTemplate = template.messageTemplate;
     var index = messageTemplate.indexOf('#');
     var prefix = messageTemplate.substring(0, index - 1);
diff --git a/pkg/front_end/test/standard_file_system_test.dart b/pkg/front_end/test/standard_file_system_test.dart
index 2e2d1eb..dce6675 100644
--- a/pkg/front_end/test/standard_file_system_test.dart
+++ b/pkg/front_end/test/standard_file_system_test.dart
@@ -17,7 +17,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(StandardFileSystemTest);
     defineReflectiveTests(FileTest);
@@ -35,35 +35,35 @@
   FileSystemEntity dir;
 
   @override
-  setUp() {
+  void setUp() {
     super.setUp();
     path = p.join(tempPath, 'dir');
     dir = StandardFileSystem.instance.entityForUri(p.toUri(path));
   }
 
-  test_equals_differentPaths() {
+  void test_equals_differentPaths() {
     expect(dir == entityForPath(p.join(tempPath, 'dir2')), isFalse);
   }
 
-  test_equals_samePath() {
+  void test_equals_samePath() {
     expect(dir == entityForPath(p.join(tempPath, 'dir')), isTrue);
   }
 
-  test_exists_directoryExists() async {
+  void test_exists_directoryExists() async {
     await new io.Directory(path).create();
     expect(await dir.exists(), isTrue);
   }
 
-  test_exists_doesNotExist() async {
+  void test_exists_doesNotExist() async {
     expect(await dir.exists(), isFalse);
   }
 
-  test_readAsBytes() async {
+  void test_readAsBytes() async {
     await new io.Directory(path).create();
     expect(dir.readAsBytes(), _throwsFileSystemException);
   }
 
-  test_uri() {
+  void test_uri() {
     expect(dir.uri, p.toUri(path));
   }
 }
@@ -74,72 +74,72 @@
   FileSystemEntity file;
 
   @override
-  setUp() {
+  void setUp() {
     super.setUp();
     path = p.join(tempPath, 'file.txt');
     file = StandardFileSystem.instance.entityForUri(p.toUri(path));
   }
 
-  test_equals_differentPaths() {
+  void test_equals_differentPaths() {
     expect(file == entityForPath(p.join(tempPath, 'file2.txt')), isFalse);
   }
 
-  test_equals_samePath() {
+  void test_equals_samePath() {
     expect(file == entityForPath(p.join(tempPath, 'file.txt')), isTrue);
   }
 
-  test_exists_doesNotExist() async {
+  void test_exists_doesNotExist() async {
     expect(await file.exists(), isFalse);
   }
 
-  test_exists_fileExists() async {
+  void test_exists_fileExists() async {
     new io.File(path).writeAsStringSync('contents');
     expect(await file.exists(), isTrue);
   }
 
-  test_hashCode_samePath() {
+  void test_hashCode_samePath() {
     expect(file.hashCode, entityForPath(p.join(tempPath, 'file.txt')).hashCode);
   }
 
-  test_readAsBytes_badUtf8() async {
+  void test_readAsBytes_badUtf8() async {
     // A file containing invalid UTF-8 can still be read as raw bytes.
     List<int> bytes = [0xc0, 0x40]; // Invalid UTF-8
     new io.File(path).writeAsBytesSync(bytes);
     expect(await file.readAsBytes(), bytes);
   }
 
-  test_readAsBytes_doesNotExist() {
+  void test_readAsBytes_doesNotExist() {
     expect(file.readAsBytes(), _throwsFileSystemException);
   }
 
-  test_readAsBytes_exists() async {
+  void test_readAsBytes_exists() async {
     var s = 'contents';
     new io.File(path).writeAsStringSync(s);
     expect(await file.readAsBytes(), utf8.encode(s));
   }
 
-  test_readAsString_badUtf8() {
+  void test_readAsString_badUtf8() {
     new io.File(path).writeAsBytesSync([0xc0, 0x40]); // Invalid UTF-8
     expect(file.readAsString(), _throwsFileSystemException);
   }
 
-  test_readAsString_doesNotExist() {
+  void test_readAsString_doesNotExist() {
     expect(file.readAsString(), _throwsFileSystemException);
   }
 
-  test_readAsString_exists() async {
+  void test_readAsString_exists() async {
     var s = 'contents';
     new io.File(path).writeAsStringSync(s);
     expect(await file.readAsString(), s);
   }
 
-  test_readAsString_utf8() async {
+  void test_readAsString_utf8() async {
     var bytes = [0xe2, 0x82, 0xac]; // Unicode € symbol (in UTF-8)
     new io.File(path).writeAsBytesSync(bytes);
     expect(await file.readAsString(), '\u20ac');
   }
 
-  test_uri() {
+  void test_uri() {
     expect(file.uri, p.toUri(path));
   }
 }
@@ -149,32 +149,32 @@
   Uri tempUri;
 
   @override
-  setUp() {
+  void setUp() {
     super.setUp();
     tempUri = new Uri.directory(tempPath);
   }
 
-  test_entityForPath() {
+  void test_entityForPath() {
     var path = p.join(tempPath, 'file.txt');
     expect(entityForPath(path).uri, p.toUri(path));
   }
 
-  test_entityForPath_absolutize() {
+  void test_entityForPath_absolutize() {
     expect(entityForPath('file.txt').uri,
         p.toUri(new io.File('file.txt').absolute.path));
   }
 
-  test_entityForPath_normalize_dot() {
+  void test_entityForPath_normalize_dot() {
     expect(entityForPath(p.join(tempPath, '.', 'file.txt')).uri,
         p.toUri(p.join(tempPath, 'file.txt')));
   }
 
-  test_entityForPath_normalize_dotDot() {
+  void test_entityForPath_normalize_dotDot() {
     expect(entityForPath(p.join(tempPath, 'foo', '..', 'file.txt')).uri,
         p.toUri(p.join(tempPath, 'file.txt')));
   }
 
-  test_entityForUri() {
+  void test_entityForUri() {
     expect(
         StandardFileSystem.instance
             .entityForUri(Uri.parse('${tempUri}file.txt'))
@@ -182,12 +182,12 @@
         p.toUri(p.join(tempPath, 'file.txt')));
   }
 
-  test_entityForUri_bareUri_absolute() {
+  void test_entityForUri_bareUri_absolute() {
     expect(StandardFileSystem.instance.entityForUri(Uri.parse('/file.txt')).uri,
         Uri.parse('file:///file.txt'));
   }
 
-  test_entityForUri_fileUri_relative() {
+  void test_entityForUri_fileUri_relative() {
     // A weird quirk of the Uri class is that it doesn't seem possible to create
     // a `file:` uri with a relative path, no matter how many slashes you use or
     // if you populate the fields directly.  But just to be certain, try to do
@@ -206,14 +206,14 @@
     }
   }
 
-  test_entityForUri_nonFileUri() {
+  void test_entityForUri_nonFileUri() {
     expect(
         () => StandardFileSystem.instance
             .entityForUri(Uri.parse('package:foo/bar.dart')),
         _throwsFileSystemException);
   }
 
-  test_entityForUri_normalize_dot() {
+  void test_entityForUri_normalize_dot() {
     expect(
         StandardFileSystem.instance
             .entityForUri(Uri.parse('${tempUri}./file.txt'))
@@ -221,7 +221,7 @@
         p.toUri(p.join(tempPath, 'file.txt')));
   }
 
-  test_entityForUri_normalize_dotDot() {
+  void test_entityForUri_normalize_dotDot() {
     expect(
         StandardFileSystem.instance
             .entityForUri(Uri.parse('${tempUri}foo/../file.txt'))
@@ -237,12 +237,12 @@
   FileSystemEntity entityForPath(String path) =>
       StandardFileSystem.instance.entityForUri(p.toUri(path));
 
-  setUp() {
+  void setUp() {
     tempDirectory = io.Directory.systemTemp.createTempSync('test_file_system');
     tempPath = tempDirectory.absolute.path;
   }
 
-  tearDown() async {
+  void tearDown() async {
     try {
       tempDirectory.deleteSync(recursive: true);
     } on io.FileSystemException {
@@ -257,7 +257,7 @@
 
 @reflectiveTest
 class DataTest {
-  test_Data_URIs() async {
+  void test_Data_URIs() async {
     String string = "<{[DART]}>";
     Uri string_uri = new Uri.dataFromString(string, base64: false);
     Uri string_uri_base64 = new Uri.dataFromString(string, base64: true);
diff --git a/pkg/front_end/test/static_types/analysis_helper.dart b/pkg/front_end/test/static_types/analysis_helper.dart
index 2091112..6b41b38 100644
--- a/pkg/front_end/test/static_types/analysis_helper.dart
+++ b/pkg/front_end/test/static_types/analysis_helper.dart
@@ -22,7 +22,7 @@
 import 'package:kernel/core_types.dart';
 import 'package:kernel/type_environment.dart';
 
-run(Uri entryPoint, String allowedListPath,
+void run(Uri entryPoint, String allowedListPath,
     {bool verbose = false,
     bool generate = false,
     bool analyzedUrisFilter(Uri uri)}) async {
diff --git a/pkg/front_end/test/static_types/cfe_dynamic_test.dart b/pkg/front_end/test/static_types/cfe_dynamic_test.dart
index 672ff9d..cda9ff6 100644
--- a/pkg/front_end/test/static_types/cfe_dynamic_test.dart
+++ b/pkg/front_end/test/static_types/cfe_dynamic_test.dart
@@ -21,7 +21,7 @@
   return false;
 }
 
-main(List<String> args) async {
+void main(List<String> args) async {
   await run(Uri.base.resolve('pkg/front_end/tool/_fasta/compile.dart'),
       'pkg/front_end/test/static_types/cfe_allowed.json',
       analyzedUrisFilter: cfeOnly,
diff --git a/pkg/front_end/test/static_types/static_type_test.dart b/pkg/front_end/test/static_types/static_type_test.dart
index 69adbea..7c2d21e 100644
--- a/pkg/front_end/test/static_types/static_type_test.dart
+++ b/pkg/front_end/test/static_types/static_type_test.dart
@@ -12,7 +12,7 @@
 import 'package:kernel/ast.dart';
 import 'package:kernel/type_environment.dart';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
   await runTests<String>(dataDir,
       args: args,
@@ -76,21 +76,21 @@
         super(compilerResult, actualMap);
 
   @override
-  visitField(Field node) {
+  void visitField(Field node) {
     _staticTypeContext = new StaticTypeContext(node, _environment);
     super.visitField(node);
     _staticTypeContext = null;
   }
 
   @override
-  visitConstructor(Constructor node) {
+  void visitConstructor(Constructor node) {
     _staticTypeContext = new StaticTypeContext(node, _environment);
     super.visitConstructor(node);
     _staticTypeContext = null;
   }
 
   @override
-  visitProcedure(Procedure node) {
+  void visitProcedure(Procedure node) {
     _staticTypeContext = new StaticTypeContext(node, _environment);
     super.visitProcedure(node);
     _staticTypeContext = null;
diff --git a/pkg/front_end/test/summary_generator_test.dart b/pkg/front_end/test/summary_generator_test.dart
index 5a66026..f3178d6 100644
--- a/pkg/front_end/test/summary_generator_test.dart
+++ b/pkg/front_end/test/summary_generator_test.dart
@@ -10,7 +10,7 @@
 
 import 'package:test/test.dart';
 
-main() {
+void main() {
   test('summary has no source-info by default', () async {
     var summary = await summarize(['a.dart'], allSources);
     var component = loadComponentFromBytes(summary);
@@ -114,7 +114,7 @@
 };
 
 /// Helper function to check that some expectations from the summary of D.
-checkDSummary(List<int> summary) {
+void checkDSummary(List<int> summary) {
   var component = loadComponentFromBytes(summary);
   var aLib = findLibrary(component, 'a.dart');
   var bLib = findLibrary(component, 'b.dart');
diff --git a/pkg/front_end/test/test_generator_test.dart b/pkg/front_end/test/test_generator_test.dart
index e08987a..f873a70 100644
--- a/pkg/front_end/test/test_generator_test.dart
+++ b/pkg/front_end/test/test_generator_test.dart
@@ -17,7 +17,7 @@
 
 import 'incremental_suite.dart' as helper;
 
-main() async {
+void main() async {
   CompilerAndOptions compilerAndOptions = TestCompiler.initialize();
   TestCompiler compiler = compilerAndOptions.compiler;
   bool hasNewline = true;
diff --git a/pkg/front_end/test/text_representation/empty_reference_test.dart b/pkg/front_end/test/text_representation/empty_reference_test.dart
index 0e36da8..bd30c00 100644
--- a/pkg/front_end/test/text_representation/empty_reference_test.dart
+++ b/pkg/front_end/test/text_representation/empty_reference_test.dart
@@ -8,7 +8,7 @@
 import 'package:kernel/ast.dart';
 import 'text_representation_test.dart';
 
-testExpression(Expression node, String normal,
+void testExpression(Expression node, String normal,
     {String verbose, String limited}) {
   Expect.stringEquals(normal, node.toText(normalStrategy),
       "Unexpected normal strategy text for ${node.runtimeType}");
@@ -18,7 +18,7 @@
       "Unexpected limited strategy text for ${node.runtimeType}");
 }
 
-testType(DartType node, String normal, {String verbose, String limited}) {
+void testType(DartType node, String normal, {String verbose, String limited}) {
   Expect.stringEquals(normal, node.toText(normalStrategy),
       "Unexpected normal strategy text for ${node.runtimeType}");
   Expect.stringEquals(verbose ?? normal, node.toText(verboseStrategy),
@@ -27,7 +27,7 @@
       "Unexpected limited strategy text for ${node.runtimeType}");
 }
 
-main() {
+void main() {
   testTypes();
   testMembers();
 }
diff --git a/pkg/front_end/test/text_representation/internal_ast_text_representation_test.dart b/pkg/front_end/test/text_representation/internal_ast_text_representation_test.dart
index e5a47ce..3355ebf 100644
--- a/pkg/front_end/test/text_representation/internal_ast_text_representation_test.dart
+++ b/pkg/front_end/test/text_representation/internal_ast_text_representation_test.dart
@@ -11,7 +11,8 @@
 import 'package:kernel/ast.dart';
 import 'text_representation_test.dart';
 
-testStatement(Statement node, String normal, {String verbose, String limited}) {
+void testStatement(Statement node, String normal,
+    {String verbose, String limited}) {
   Expect.stringEquals(normal, node.toText(normalStrategy),
       "Unexpected normal strategy text for ${node.runtimeType}");
   Expect.stringEquals(verbose ?? normal, node.toText(verboseStrategy),
@@ -20,7 +21,7 @@
       "Unexpected limited strategy text for ${node.runtimeType}");
 }
 
-testExpression(Expression node, String normal,
+void testExpression(Expression node, String normal,
     {String verbose, String limited}) {
   Expect.stringEquals(normal, node.toText(normalStrategy),
       "Unexpected normal strategy text for ${node.runtimeType}");
@@ -32,7 +33,7 @@
 
 final Uri dummyUri = Uri.parse('test:dummy');
 
-main() {
+void main() {
   _testVariableDeclarations();
   _testTryStatement();
   _testForInStatementWithSynthesizedVariable();
@@ -399,15 +400,13 @@
 }
 
 void _testInternalPropertyGet() {
-  testExpression(
-      new PropertyGet(new IntLiteral(0), new Name('boz')), '''
+  testExpression(new PropertyGet(new IntLiteral(0), new Name('boz')), '''
 0.boz''');
 }
 
 void _testInternalPropertySet() {
   testExpression(
-      new PropertySet(
-          new IntLiteral(0), new Name('boz'), new IntLiteral(1),
+      new PropertySet(new IntLiteral(0), new Name('boz'), new IntLiteral(1),
           forEffect: false, readOnlyReceiver: false),
       '''
 0.boz = 1''');
diff --git a/pkg/front_end/test/text_representation/text_representation_test.dart b/pkg/front_end/test/text_representation/text_representation_test.dart
index db3b48c..ba24ec6 100644
--- a/pkg/front_end/test/text_representation/text_representation_test.dart
+++ b/pkg/front_end/test/text_representation/text_representation_test.dart
@@ -64,7 +64,7 @@
   throw new UnsupportedError("Unexpected marker '${marker}'.");
 }
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
   await runTests<String>(dataDir,
       args: args,
@@ -137,7 +137,7 @@
   }
 
   @override
-  visitProcedure(Procedure node) {
+  void visitProcedure(Procedure node) {
     if (!node.name.text.startsWith(expressionMarker) &&
         !node.name.text.startsWith(statementMarker)) {
       node.function.accept(this);
@@ -146,7 +146,7 @@
   }
 
   @override
-  visitField(Field node) {
+  void visitField(Field node) {
     if (!node.name.text.startsWith(expressionMarker) &&
         !node.name.text.startsWith(statementMarker)) {
       node.initializer?.accept(this);
diff --git a/pkg/front_end/test/textual_outline_test.dart b/pkg/front_end/test/textual_outline_test.dart
index 345fa42..4a2af05 100644
--- a/pkg/front_end/test/textual_outline_test.dart
+++ b/pkg/front_end/test/textual_outline_test.dart
@@ -15,7 +15,7 @@
 const ScannerConfiguration scannerConfiguration =
     const ScannerConfiguration(enableExtensionMethods: true);
 
-main() {
+void main() {
   // Doesn't sort if not asked to perform modelling.
   String result = textualOutline(utf8.encode("""
 b() { print("hello"); }
diff --git a/pkg/front_end/test/token_test.dart b/pkg/front_end/test/token_test.dart
index 4a1249c..9cf8377 100644
--- a/pkg/front_end/test/token_test.dart
+++ b/pkg/front_end/test/token_test.dart
@@ -10,7 +10,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-main() {
+void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TokenTest);
   });
diff --git a/pkg/front_end/test/tool/reload.dart b/pkg/front_end/test/tool/reload.dart
index 6d86a82..7b783bc 100644
--- a/pkg/front_end/test/tool/reload.dart
+++ b/pkg/front_end/test/tool/reload.dart
@@ -107,7 +107,7 @@
 /// launched with `--observe` to enable the service protocol.
 ///
 // TODO(sigmund): provide flags to configure the vm-service port.
-main(List<String> args) async {
+void main(List<String> args) async {
   if (args.length == 0) {
     print('usage: reload <entry-uri>');
     return;
diff --git a/pkg/front_end/test/type_labeler_test.dart b/pkg/front_end/test/type_labeler_test.dart
index cde0695..8681a9f 100644
--- a/pkg/front_end/test/type_labeler_test.dart
+++ b/pkg/front_end/test/type_labeler_test.dart
@@ -10,7 +10,7 @@
 
 import 'package:expect/expect.dart';
 
-main() {
+void main() {
   void check(Map<Node, String> expectations, int bulletCount) {
     TypeLabeler labeler = new TypeLabeler(false);
     Map<Node, List<Object>> conversions = {};
diff --git a/pkg/front_end/test/unit_test_suites.dart b/pkg/front_end/test/unit_test_suites.dart
index aafc70c..4ccc389 100644
--- a/pkg/front_end/test/unit_test_suites.dart
+++ b/pkg/front_end/test/unit_test_suites.dart
@@ -15,6 +15,6 @@
 /// TODO(paulberry): once #45192 is fixed, we can switch the `import` directive
 /// above to an `export` and remove this method, and this file will still be
 /// considered by the analysis server to be runnable.
-main(List<String> args) {
+void main(List<String> args) {
   impl.main(args);
 }
diff --git a/pkg/front_end/test/unit_test_suites_impl.dart b/pkg/front_end/test/unit_test_suites_impl.dart
index 0f208a1..bd7f75f 100644
--- a/pkg/front_end/test/unit_test_suites_impl.dart
+++ b/pkg/front_end/test/unit_test_suites_impl.dart
@@ -209,7 +209,7 @@
   @override
   void logSuiteComplete(testing.Suite suite) {}
 
-  handleTestResult(
+  void handleTestResult(
       testing.Suite suite,
       TestDescription testDescription,
       Result result,
@@ -531,7 +531,7 @@
   await File.fromUri(uri).writeAsString(lines.map((line) => "$line\n").join());
 }
 
-main([List<String> arguments = const <String>[]]) async {
+void main([List<String> arguments = const <String>[]]) async {
   Stopwatch totalRuntime = new Stopwatch()..start();
 
   List<String> results = [];
diff --git a/pkg/front_end/test/vm_service_coverage.dart b/pkg/front_end/test/vm_service_coverage.dart
index 2608419..31e61fe 100644
--- a/pkg/front_end/test/vm_service_coverage.dart
+++ b/pkg/front_end/test/vm_service_coverage.dart
@@ -8,7 +8,7 @@
 
 import 'vm_service_helper.dart' as vmService;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   CoverageHelper coverageHelper = new CoverageHelper();
 
   List<String> allArgs = <String>[];
diff --git a/pkg/front_end/test/vm_service_coverage_constant_evaluator.dart b/pkg/front_end/test/vm_service_coverage_constant_evaluator.dart
index 77fe41e..1fed414 100644
--- a/pkg/front_end/test/vm_service_coverage_constant_evaluator.dart
+++ b/pkg/front_end/test/vm_service_coverage_constant_evaluator.dart
@@ -6,7 +6,7 @@
 
 import 'vm_service_coverage.dart' as helper;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   CoverageHelper coverageHelper = new CoverageHelper();
 
   List<String> allArgs = <String>[];
diff --git a/pkg/front_end/test/vm_service_for_leak_detection.dart b/pkg/front_end/test/vm_service_for_leak_detection.dart
index 4329036..bae1839 100644
--- a/pkg/front_end/test/vm_service_for_leak_detection.dart
+++ b/pkg/front_end/test/vm_service_for_leak_detection.dart
@@ -8,7 +8,7 @@
 
 import "vm_service_heap_helper.dart" as helper;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   List<helper.Interest> interests = <helper.Interest>[];
   interests.add(new helper.Interest(
     Uri.parse("package:front_end/src/fasta/source/source_library_builder.dart"),
diff --git a/pkg/front_end/test/vm_service_heap_finder.dart b/pkg/front_end/test/vm_service_heap_finder.dart
index 6fb49d91..13f18fc 100644
--- a/pkg/front_end/test/vm_service_heap_finder.dart
+++ b/pkg/front_end/test/vm_service_heap_finder.dart
@@ -15,7 +15,7 @@
   Foo(this.x, this.y);
 }
 
-main(List<String> args) async {
+void main(List<String> args) async {
   String connectTo;
   String classToFind;
   String whatToDo;
diff --git a/pkg/front_end/test/weekly_tester.dart b/pkg/front_end/test/weekly_tester.dart
index ab01773..6cdd65a 100644
--- a/pkg/front_end/test/weekly_tester.dart
+++ b/pkg/front_end/test/weekly_tester.dart
@@ -6,7 +6,7 @@
 import 'dart:convert' show LineSplitter, utf8;
 import 'dart:io' show File, Platform, Process, exitCode;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   // General idea: Launch - in separate processes - whatever we want to run
   // concurrently, capturing the stdout and stderr, printing it with some
   // prepended identification.
diff --git a/pkg/front_end/tool/_fasta/abcompile.dart b/pkg/front_end/tool/_fasta/abcompile.dart
index a9e3125..26ad63a 100644
--- a/pkg/front_end/tool/_fasta/abcompile.dart
+++ b/pkg/front_end/tool/_fasta/abcompile.dart
@@ -18,7 +18,7 @@
 /// by alternately launching the compile application in this directory
 /// and the compile application location in the repo specified by "bRoot"
 /// via -DbRoot=/absolute/path/to/other/sdk/repo
-main(List<String> args) async {
+void main(List<String> args) async {
   print(args);
   if (bRootPath == null) {
     print('Expected -DbRoot=/absolute/path/to/other/sdk/repo');
diff --git a/pkg/front_end/tool/_fasta/additional_targets_test.dart b/pkg/front_end/tool/_fasta/additional_targets_test.dart
index daffd49..e5b3b50 100644
--- a/pkg/front_end/tool/_fasta/additional_targets_test.dart
+++ b/pkg/front_end/tool/_fasta/additional_targets_test.dart
@@ -13,7 +13,7 @@
 
 import 'additional_targets.dart' show installAdditionalTargets;
 
-main() {
+void main() {
   installAdditionalTargets();
   String expected =
       "  ${Flags.target}=${(targets.keys.toList()..sort()).join('|')}";
diff --git a/pkg/front_end/tool/_fasta/batch.dart b/pkg/front_end/tool/_fasta/batch.dart
index 968014e..94408d4 100644
--- a/pkg/front_end/tool/_fasta/batch.dart
+++ b/pkg/front_end/tool/_fasta/batch.dart
@@ -4,4 +4,4 @@
 
 import 'entry_points.dart' show batchEntryPoint;
 
-main(List<String> arguments) => batchEntryPoint(arguments);
+void main(List<String> arguments) => batchEntryPoint(arguments);
diff --git a/pkg/front_end/tool/_fasta/compile.dart b/pkg/front_end/tool/_fasta/compile.dart
index 2165cf1..88c8564 100644
--- a/pkg/front_end/tool/_fasta/compile.dart
+++ b/pkg/front_end/tool/_fasta/compile.dart
@@ -4,4 +4,4 @@
 
 import 'entry_points.dart' show compileEntryPoint;
 
-main(List<String> arguments) => compileEntryPoint(arguments);
+void main(List<String> arguments) => compileEntryPoint(arguments);
diff --git a/pkg/front_end/tool/_fasta/compile_platform.dart b/pkg/front_end/tool/_fasta/compile_platform.dart
index c9791fb..ce03fc7 100644
--- a/pkg/front_end/tool/_fasta/compile_platform.dart
+++ b/pkg/front_end/tool/_fasta/compile_platform.dart
@@ -4,4 +4,4 @@
 
 import 'entry_points.dart' show compilePlatformEntryPoint;
 
-main(List<String> arguments) => compilePlatformEntryPoint(arguments);
+void main(List<String> arguments) => compilePlatformEntryPoint(arguments);
diff --git a/pkg/front_end/tool/_fasta/compile_platform_legacy_test.dart b/pkg/front_end/tool/_fasta/compile_platform_legacy_test.dart
index 985026c..073dd5f 100644
--- a/pkg/front_end/tool/_fasta/compile_platform_legacy_test.dart
+++ b/pkg/front_end/tool/_fasta/compile_platform_legacy_test.dart
@@ -10,7 +10,7 @@
 
 import 'package:expect/expect.dart';
 
-main(List<String> arguments) {
+void main(List<String> arguments) {
   Uri dartVm = Uri.base.resolveUri(new Uri.file(Platform.resolvedExecutable));
   Uri librariesJson = Uri.base.resolve("sdk/lib/libraries.json");
   Uri compilePlatform =
@@ -38,7 +38,8 @@
   });
 }
 
-withTemporaryDirectory(String prefix, Future<void> f(Uri tmp)) async {
+Future<void> withTemporaryDirectory(
+    String prefix, Future<void> f(Uri tmp)) async {
   Directory tmp = await Directory.systemTemp.createTemp(prefix);
   try {
     await f(tmp.uri);
diff --git a/pkg/front_end/tool/_fasta/compile_platform_test.dart b/pkg/front_end/tool/_fasta/compile_platform_test.dart
index 985026c..073dd5f 100644
--- a/pkg/front_end/tool/_fasta/compile_platform_test.dart
+++ b/pkg/front_end/tool/_fasta/compile_platform_test.dart
@@ -10,7 +10,7 @@
 
 import 'package:expect/expect.dart';
 
-main(List<String> arguments) {
+void main(List<String> arguments) {
   Uri dartVm = Uri.base.resolveUri(new Uri.file(Platform.resolvedExecutable));
   Uri librariesJson = Uri.base.resolve("sdk/lib/libraries.json");
   Uri compilePlatform =
@@ -38,7 +38,8 @@
   });
 }
 
-withTemporaryDirectory(String prefix, Future<void> f(Uri tmp)) async {
+Future<void> withTemporaryDirectory(
+    String prefix, Future<void> f(Uri tmp)) async {
   Directory tmp = await Directory.systemTemp.createTemp(prefix);
   try {
     await f(tmp.uri);
diff --git a/pkg/front_end/tool/_fasta/deps.dart b/pkg/front_end/tool/_fasta/deps.dart
index 3b83d0f..154bef7 100644
--- a/pkg/front_end/tool/_fasta/deps.dart
+++ b/pkg/front_end/tool/_fasta/deps.dart
@@ -4,4 +4,4 @@
 
 import 'entry_points.dart' show depsEntryPoint;
 
-main(List<String> arguments) => depsEntryPoint(arguments);
+void main(List<String> arguments) => depsEntryPoint(arguments);
diff --git a/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart b/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
index 88168b0..3624fe0 100644
--- a/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
+++ b/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
@@ -11,7 +11,7 @@
 import 'package:dart_style/dart_style.dart' show DartFormatter;
 import '../../test/utils/io_utils.dart' show computeRepoDirUri;
 
-main(List<String> args) {
+void main(List<String> args) {
   final Uri repoDir = computeRepoDirUri();
   String generated = generateAstHelper(repoDir);
   new File.fromUri(computeAstHelperUri(repoDir))
diff --git a/pkg/front_end/tool/_fasta/entry_points.dart b/pkg/front_end/tool/_fasta/entry_points.dart
index 809d256..af225d7 100644
--- a/pkg/front_end/tool/_fasta/entry_points.dart
+++ b/pkg/front_end/tool/_fasta/entry_points.dart
@@ -59,7 +59,7 @@
 
 const int iterations = const int.fromEnvironment("iterations", defaultValue: 1);
 
-compileEntryPoint(List<String> arguments) async {
+Future<void> compileEntryPoint(List<String> arguments) async {
   installAdditionalTargets();
 
   // Timing results for each iteration
@@ -86,7 +86,7 @@
   }
 }
 
-outlineEntryPoint(List<String> arguments) async {
+void outlineEntryPoint(List<String> arguments) async {
   installAdditionalTargets();
 
   for (int i = 0; i < iterations; i++) {
@@ -97,7 +97,7 @@
   }
 }
 
-depsEntryPoint(List<String> arguments) async {
+void depsEntryPoint(List<String> arguments) async {
   installAdditionalTargets();
 
   for (int i = 0; i < iterations; i++) {
@@ -108,7 +108,7 @@
   }
 }
 
-compilePlatformEntryPoint(List<String> arguments) async {
+void compilePlatformEntryPoint(List<String> arguments) async {
   installAdditionalTargets();
   for (int i = 0; i < iterations; i++) {
     if (i > 0) {
@@ -118,7 +118,7 @@
   }
 }
 
-batchEntryPoint(List<String> arguments) {
+void batchEntryPoint(List<String> arguments) {
   installAdditionalTargets();
   return new BatchCompiler(
           stdin.transform(utf8.decoder).transform(new LineSplitter()))
@@ -136,7 +136,7 @@
 
   BatchCompiler(this.lines);
 
-  run() async {
+  void run() async {
     await for (String line in lines) {
       try {
         if (await batchCompileArguments(
@@ -207,7 +207,7 @@
   }
 }
 
-incrementalEntryPoint(List<String> arguments) async {
+void incrementalEntryPoint(List<String> arguments) async {
   installAdditionalTargets();
   await withGlobalOptions("incremental", arguments, true,
       (CompilerContext c, _) {
diff --git a/pkg/front_end/tool/_fasta/generate_experimental_flags.dart b/pkg/front_end/tool/_fasta/generate_experimental_flags.dart
index eff2e37..e321747 100644
--- a/pkg/front_end/tool/_fasta/generate_experimental_flags.dart
+++ b/pkg/front_end/tool/_fasta/generate_experimental_flags.dart
@@ -15,7 +15,7 @@
 
 import '../../test/utils/io_utils.dart' show computeRepoDirUri;
 
-main(List<String> arguments) {
+void main(List<String> arguments) {
   final Uri repoDir = computeRepoDirUri();
   new File.fromUri(computeCfeGeneratedFile(repoDir))
       .writeAsStringSync(generateCfeFile(repoDir), flush: true);
@@ -273,7 +273,7 @@
   return new DartFormatter().format("$sb");
 }
 
-keyToIdentifier(String key, {bool upperCaseFirst = false}) {
+String keyToIdentifier(String key, {bool upperCaseFirst = false}) {
   StringBuffer identifier = StringBuffer();
   bool first = true;
   for (int index = 0; index < key.length; ++index) {
diff --git a/pkg/front_end/tool/_fasta/generate_messages.dart b/pkg/front_end/tool/_fasta/generate_messages.dart
index 5420bf7..97bf6d8 100644
--- a/pkg/front_end/tool/_fasta/generate_messages.dart
+++ b/pkg/front_end/tool/_fasta/generate_messages.dart
@@ -13,7 +13,7 @@
 
 import '../../test/utils/io_utils.dart' show computeRepoDirUri;
 
-main(List<String> arguments) {
+void main(List<String> arguments) {
   final Uri repoDir = computeRepoDirUri();
   Messages message = generateMessagesFiles(repoDir);
   if (message.sharedMessages.trim().isEmpty ||
diff --git a/pkg/front_end/tool/_fasta/log_analyzer.dart b/pkg/front_end/tool/_fasta/log_analyzer.dart
index c93e916..1fdbc7a 100644
--- a/pkg/front_end/tool/_fasta/log_analyzer.dart
+++ b/pkg/front_end/tool/_fasta/log_analyzer.dart
@@ -8,7 +8,7 @@
 
 import 'package:testing/src/run_tests.dart' show CommandLine;
 
-main(List<String> arguments) async {
+void main(List<String> arguments) async {
   CommandLine cl = CommandLine.parse(arguments);
   Set<String> fields = cl.commaSeparated("--fields=");
   if (fields.isEmpty) {
diff --git a/pkg/front_end/tool/_fasta/log_collector.dart b/pkg/front_end/tool/_fasta/log_collector.dart
index 01fac75..3b0c717 100644
--- a/pkg/front_end/tool/_fasta/log_collector.dart
+++ b/pkg/front_end/tool/_fasta/log_collector.dart
@@ -10,7 +10,7 @@
 
 import 'package:front_end/src/fasta/crash.dart' show defaultServerAddress;
 
-badRequest(HttpRequest request, int status, String message) {
+void badRequest(HttpRequest request, int status, String message) {
   request.response.statusCode = status;
   request.response.write('''
 <!DOCTYPE html>
@@ -30,7 +30,7 @@
   print("${request.uri}: $message");
 }
 
-collectLog(DateTime time, HttpRequest request) async {
+void collectLog(DateTime time, HttpRequest request) async {
   String json = await request.cast<List<int>>().transform(utf8.decoder).join();
   var data;
   try {
@@ -81,7 +81,7 @@
 """);
 }
 
-main(List<String> arguments) async {
+void main(List<String> arguments) async {
   RawReceivePort keepAlive = new RawReceivePort();
   Uri uri;
   if (arguments.length == 1) {
diff --git a/pkg/front_end/tool/_fasta/outline.dart b/pkg/front_end/tool/_fasta/outline.dart
index dfba5cb..282c290 100644
--- a/pkg/front_end/tool/_fasta/outline.dart
+++ b/pkg/front_end/tool/_fasta/outline.dart
@@ -4,4 +4,4 @@
 
 import 'entry_points.dart' show outlineEntryPoint;
 
-main(List<String> arguments) => outlineEntryPoint(arguments);
+void main(List<String> arguments) => outlineEntryPoint(arguments);
diff --git a/pkg/front_end/tool/_fasta/parser.dart b/pkg/front_end/tool/_fasta/parser.dart
index aec74f9..694473e 100644
--- a/pkg/front_end/tool/_fasta/parser.dart
+++ b/pkg/front_end/tool/_fasta/parser.dart
@@ -5,4 +5,4 @@
 import 'package:_fe_analyzer_shared/src/parser/parser_main.dart'
     show mainEntryPoint;
 
-main(List<String> arguments) => mainEntryPoint(arguments);
+void main(List<String> arguments) => mainEntryPoint(arguments);
diff --git a/pkg/front_end/tool/_fasta/scanner.dart b/pkg/front_end/tool/_fasta/scanner.dart
index 9d58567..03aea34 100644
--- a/pkg/front_end/tool/_fasta/scanner.dart
+++ b/pkg/front_end/tool/_fasta/scanner.dart
@@ -5,4 +5,4 @@
 import 'package:_fe_analyzer_shared/src/scanner/scanner_main.dart'
     show mainEntryPoint;
 
-main(List<String> arguments) => mainEntryPoint(arguments);
+void main(List<String> arguments) => mainEntryPoint(arguments);
diff --git a/pkg/front_end/tool/compare_dill.dart b/pkg/front_end/tool/compare_dill.dart
index 9f74fcf..39202d5 100644
--- a/pkg/front_end/tool/compare_dill.dart
+++ b/pkg/front_end/tool/compare_dill.dart
@@ -8,7 +8,7 @@
 
 import '../test/utils/io_utils.dart' show computeRepoDir;
 
-main(List<String> args) {
+void main(List<String> args) {
   if (args.length != 2) {
     throw "Expects two arguments: The two files to compare";
   }
diff --git a/pkg/front_end/tool/fasta.dart b/pkg/front_end/tool/fasta.dart
index af6094b..3e02026 100644
--- a/pkg/front_end/tool/fasta.dart
+++ b/pkg/front_end/tool/fasta.dart
@@ -15,7 +15,7 @@
 String get dartVm =>
     Platform.isWindows ? '$repoDir/sdk/bin/dart.bat' : '$repoDir/sdk/bin/dart';
 
-main(List<String> args) async {
+Future<void> main(List<String> args) async {
   List<String> extraVmArguments = [];
   String script;
   List<String> scriptArguments = [];
diff --git a/pkg/front_end/tool/fasta_perf.dart b/pkg/front_end/tool/fasta_perf.dart
index 47fa253..6a04071 100644
--- a/pkg/front_end/tool/fasta_perf.dart
+++ b/pkg/front_end/tool/fasta_perf.dart
@@ -30,7 +30,7 @@
 /// Cumulative time spent scanning.
 Stopwatch scanTimer = new Stopwatch();
 
-main(List<String> args) async {
+Future<void> main(List<String> args) async {
   // TODO(sigmund): provide sdk folder as well.
   var options = argParser.parse(args);
   if (options.rest.length != 2) {
@@ -152,7 +152,7 @@
 
 /// Add to [files] all sources reachable from [start].
 Future<Null> collectSources(Uri start, Map<Uri, List<int>> files) async {
-  helper(Uri uri) {
+  void helper(Uri uri) {
     uri = uriResolver.translate(uri) ?? uri;
     // ignore: unnecessary_null_comparison
     if (uri == null) return;
@@ -202,7 +202,7 @@
 }
 
 /// Parse the full body of [source].
-parseFull(Uri uri, List<int> source) {
+void parseFull(Uri uri, List<int> source) {
   var tokens = tokenize(source);
   Parser parser = new Parser(new _PartialAstBuilder(uri),
       useImplicitCreationExpression: useImplicitCreationExpressionInCfe);
@@ -217,7 +217,8 @@
 }
 
 // Invoke the fasta kernel generator for the program starting in [entryUri]
-generateKernel(Uri entryUri, {bool compileSdk: true}) async {
+Future<CompilerResult> generateKernel(Uri entryUri,
+    {bool compileSdk: true}) async {
   // TODO(sigmund): this is here only to compute the input size,
   // we should extract the input size from the frontend instead.
   await scanReachableFiles(entryUri);
diff --git a/pkg/front_end/tool/fasta_perf_test.dart b/pkg/front_end/tool/fasta_perf_test.dart
index f366e73..1671627 100644
--- a/pkg/front_end/tool/fasta_perf_test.dart
+++ b/pkg/front_end/tool/fasta_perf_test.dart
@@ -9,7 +9,7 @@
 import 'dart:io' show Platform;
 import 'fasta_perf.dart' as m show main;
 
-main() async {
+void main() async {
   var benchIds = [
     'scan',
     'kernel_gen_e2e',
diff --git a/pkg/front_end/tool/generate_ast_coverage.dart b/pkg/front_end/tool/generate_ast_coverage.dart
index cc2a6a9..516d5e1 100644
--- a/pkg/front_end/tool/generate_ast_coverage.dart
+++ b/pkg/front_end/tool/generate_ast_coverage.dart
@@ -13,7 +13,7 @@
   return repoDir.resolve('pkg/kernel/lib/src/coverage.dart');
 }
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Uri output = args.isEmpty
       ? computeCoverageUri(Uri.base)
       : new File(args[0]).absolute.uri;
diff --git a/pkg/front_end/tool/generate_ast_equivalence.dart b/pkg/front_end/tool/generate_ast_equivalence.dart
index 4047380..5a0c02b 100644
--- a/pkg/front_end/tool/generate_ast_equivalence.dart
+++ b/pkg/front_end/tool/generate_ast_equivalence.dart
@@ -11,7 +11,7 @@
   return repoDir.resolve('pkg/kernel/lib/src/equivalence.dart');
 }
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Uri output = args.isEmpty
       ? computeEquivalenceUri(Uri.base)
       : new File(args[0]).absolute.uri;
diff --git a/pkg/front_end/tool/incremental_perf.dart b/pkg/front_end/tool/incremental_perf.dart
index e7dfb97..e3dda75 100644
--- a/pkg/front_end/tool/incremental_perf.dart
+++ b/pkg/front_end/tool/incremental_perf.dart
@@ -55,7 +55,7 @@
 
 import 'perf_common.dart';
 
-main(List<String> args) async {
+Future<void> main(List<String> args) async {
   var options = argParser.parse(args);
   if (options.rest.length != 2) {
     throw """
@@ -155,7 +155,7 @@
 
 /// Apply all edits of a single iteration by updating the copy of the file in
 /// the memory file system.
-applyEdits(
+Future<void> applyEdits(
     List<Edit> edits,
     OverlayFileSystem fs,
     IncrementalKernelGenerator generator,
@@ -288,7 +288,7 @@
   String toString() => 'ChangeSet($name, $edits)';
 }
 
-_resolveOverlayUri(String uriString) {
+Uri _resolveOverlayUri(String uriString) {
   Uri result = Uri.base.resolve(uriString);
   return result.isScheme("file")
       ? result.replace(scheme: 'org-dartlang-overlay')
diff --git a/pkg/front_end/tool/incremental_perf_test.dart b/pkg/front_end/tool/incremental_perf_test.dart
index 73e0893..d24c01a 100644
--- a/pkg/front_end/tool/incremental_perf_test.dart
+++ b/pkg/front_end/tool/incremental_perf_test.dart
@@ -9,7 +9,7 @@
     show computePlatformBinariesLocation;
 import 'incremental_perf.dart' as m show main;
 
-main() async {
+void main() async {
   var sdkOutline = computePlatformBinariesLocation(forceBuildDir: true).resolve(
       // TODO(sigmund): switch to `vm_outline.dill` (issue #29881).
       "vm_platform_strong.dill");
diff --git a/pkg/front_end/tool/parser_direct_ast/console_helper.dart b/pkg/front_end/tool/parser_direct_ast/console_helper.dart
index c87b878..ad90ce7 100644
--- a/pkg/front_end/tool/parser_direct_ast/console_helper.dart
+++ b/pkg/front_end/tool/parser_direct_ast/console_helper.dart
@@ -99,7 +99,7 @@
 
   _Output? _prevOutput;
 
-  _printOutput() {
+  void _printOutput() {
     int currentPosRow = -1;
     int currentPosColumn = -1;
     StringBuffer buffer = new StringBuffer();
diff --git a/pkg/front_end/tool/perf.dart b/pkg/front_end/tool/perf.dart
index ccfe1f1..bd751cb 100644
--- a/pkg/front_end/tool/perf.dart
+++ b/pkg/front_end/tool/perf.dart
@@ -32,7 +32,7 @@
 import 'package:analyzer/src/source/package_map_resolver.dart';
 import 'package:path/path.dart' as path;
 
-main(List<String> args) async {
+Future<void> main(List<String> args) async {
   // TODO(sigmund): provide sdk folder as well.
   if (args.length < 2) {
     print('usage: perf.dart <bench-id> <entry.dart>');
diff --git a/pkg/front_end/tool/perf_test.dart b/pkg/front_end/tool/perf_test.dart
index 7b54fb8..495c9fb 100644
--- a/pkg/front_end/tool/perf_test.dart
+++ b/pkg/front_end/tool/perf_test.dart
@@ -7,7 +7,7 @@
 import 'dart:io' show Platform;
 import 'perf.dart' as m;
 
-main() async {
+void main() async {
   var benchIds = ['scan', 'parse'];
   var inputFile =
       Platform.script.resolve('../lib/src/api_prototype/file_system.dart').path;
diff --git a/pkg/front_end/tool/smoke_test_quick.dart b/pkg/front_end/tool/smoke_test_quick.dart
index 9e7d790..b6d94f8 100644
--- a/pkg/front_end/tool/smoke_test_quick.dart
+++ b/pkg/front_end/tool/smoke_test_quick.dart
@@ -10,7 +10,7 @@
 
 String get dartVm => Platform.executable;
 
-main(List<String> args) async {
+void main(List<String> args) async {
   Stopwatch stopwatch = new Stopwatch()..start();
   List<Future> futures = <Future>[];
   futures.add(run("pkg/front_end/test/explicit_creation_git_test.dart",
diff --git a/pkg/front_end/tool/stat_on_dash_v.dart b/pkg/front_end/tool/stat_on_dash_v.dart
index 7040540..0e28d29 100644
--- a/pkg/front_end/tool/stat_on_dash_v.dart
+++ b/pkg/front_end/tool/stat_on_dash_v.dart
@@ -19,7 +19,7 @@
   exit(1);
 }
 
-main(List<String> args) {
+void main(List<String> args) {
   if (args.length < 4) {
     usage("Requires more input.");
   }
diff --git a/pkg/front_end/tool/update_all.dart b/pkg/front_end/tool/update_all.dart
index 3f9bfd1..e32686e 100644
--- a/pkg/front_end/tool/update_all.dart
+++ b/pkg/front_end/tool/update_all.dart
@@ -23,7 +23,7 @@
   'pkg/front_end/test/static_types/static_type_test.dart',
 ];
 
-main() async {
+void main() async {
   // Update all tests based on expectation files.
   await expectations.main(const <String>[]);
 
diff --git a/pkg/front_end/tool/update_expectations.dart b/pkg/front_end/tool/update_expectations.dart
index bd97672..45d7ef3 100644
--- a/pkg/front_end/tool/update_expectations.dart
+++ b/pkg/front_end/tool/update_expectations.dart
@@ -38,7 +38,7 @@
   }
 }
 
-main(List<String> args) async {
+Future<void> main(List<String> args) async {
   if (args.isEmpty) {
     await runStandardSuites();
     for (String suite in specialSuites) {
diff --git a/tools/VERSION b/tools/VERSION
index 3897460..0827bed 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 15
 PATCH 0
-PRERELEASE 71
+PRERELEASE 72
 PRERELEASE_PATCH 0
\ No newline at end of file
