diff --git a/BUILD.gn b/BUILD.gn
index f1332bf..3962d40 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -68,6 +68,12 @@
   }
 }
 
+# A separate target and not included in group("runtime"). This way the target\
+# "runtime" does not get many executables extra as build output.
+group("run_ffi_unit_tests") {
+  deps = [ "runtime/bin/ffi_unit_test:run_ffi_unit_tests" ]
+}
+
 group("runtime_kernel") {
   if (targetting_fuchsia) {
     # Fuchsia has run_vm_tests marked testonly.
diff --git a/DEPS b/DEPS
index f53c12e..4dc0fef 100644
--- a/DEPS
+++ b/DEPS
@@ -102,7 +102,7 @@
 
   "chromedriver_tag": "83.0.4103.39",
   "dartdoc_rev" : "6935dcd8f2d78cf1797e6365b4b71505e6579659",
-  "ffi_rev": "a90bd424116fb6f416337db67425171f2dc4c98f",
+  "ffi_rev": "a5d4232cd38562c75a3ed847baa340e399538028",
   "fixnum_rev": "16d3890c6dc82ca629659da1934e412292508bba",
   "glob_rev": "e9f4e6b7ae8abe5071461cf8f47191bb19cf7ef6",
   "html_rev": "22f17e97fedeacaa1e945cf84d8016284eed33a6",
diff --git a/pkg/analysis_server/lib/src/domain_completion.dart b/pkg/analysis_server/lib/src/domain_completion.dart
index 4ee4034..98e3a03 100644
--- a/pkg/analysis_server/lib/src/domain_completion.dart
+++ b/pkg/analysis_server/lib/src/domain_completion.dart
@@ -17,6 +17,9 @@
 import 'package:analysis_server/src/services/completion/completion_performance.dart';
 import 'package:analysis_server/src/services/completion/dart/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/token_details/token_detail_builder.dart';
+import 'package:analysis_server/src/services/completion/yaml/analysis_options_generator.dart';
+import 'package:analysis_server/src/services/completion/yaml/fix_data_generator.dart';
+import 'package:analysis_server/src/services/completion/yaml/pubspec_generator.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/analysis/session.dart';
 import 'package:analyzer/exception/exception.dart';
@@ -145,6 +148,25 @@
         request.replacementOffset, request.replacementLength, suggestions);
   }
 
+  /// Return the suggestions that should be presented in the YAML [file] at the
+  /// given [offset].
+  List<CompletionSuggestion> computeYamlSuggestions(String file, int offset) {
+    var provider = server.resourceProvider;
+    if (AnalysisEngine.isAnalysisOptionsFileName(file)) {
+      var generator = AnalysisOptionsGenerator(provider);
+      return generator.getSuggestions(file, offset);
+    }
+    var fileName = provider.pathContext.basename(file);
+    if (fileName == AnalysisEngine.PUBSPEC_YAML_FILE) {
+      var generator = PubspecGenerator(provider);
+      return generator.getSuggestions(file, offset);
+    } else if (fileName == AnalysisEngine.FIX_DATA_FILE) {
+      var generator = FixDataGenerator(provider);
+      return generator.getSuggestions(file, offset);
+    }
+    return <CompletionSuggestion>[];
+  }
+
   /// Process a `completion.getSuggestionDetails` request.
   void getSuggestionDetails(Request request) async {
     var params = CompletionGetSuggestionDetailsParams.fromRequest(request);
@@ -297,6 +319,24 @@
       if (server.sendResponseErrorIfInvalidFilePath(request, file)) {
         return;
       }
+      if (file.endsWith('.yaml')) {
+        // Return the response without results.
+        var completionId = (_nextCompletionId++).toString();
+        server.sendResponse(CompletionGetSuggestionsResult(completionId)
+            .toResponse(request.id));
+        // Send a notification with results.
+        sendCompletionNotification(
+          completionId,
+          0, // replacementOffset
+          0, // replacementLength,
+          computeYamlSuggestions(file, offset),
+          null,
+          null,
+          null,
+          null,
+        );
+        return;
+      }
 
       var resolvedUnit = await server.getResolvedUnit(file);
       server.requestStatistics?.addItemTimeNow(request, 'resolvedUnit');
diff --git a/pkg/analysis_server/lib/src/server/driver.dart b/pkg/analysis_server/lib/src/server/driver.dart
index 734177d..db988fa 100644
--- a/pkg/analysis_server/lib/src/server/driver.dart
+++ b/pkg/analysis_server/lib/src/server/driver.dart
@@ -38,176 +38,12 @@
 import 'package:telemetry/crash_reporting.dart';
 import 'package:telemetry/telemetry.dart' as telemetry;
 
-/// Commandline argument parser. (Copied from analyzer/lib/options.dart)
-/// TODO(pquitslund): replaces with a simple [ArgParser] instance
-/// when the args package supports ignoring unrecognized
-/// options/flags (https://github.com/dart-lang/args/issues/9).
-/// TODO(devoncarew): Consider removing the ability to support unrecognized
-/// flags for the analysis server.
-class CommandLineParser {
-  final List<String> _knownFlags;
-  final ArgParser _parser;
-
-  /// Creates a new command line parser
-  CommandLineParser()
-      : _knownFlags = <String>[],
-        _parser = ArgParser(allowTrailingOptions: true);
-
-  ArgParser get parser => _parser;
-
-  /// Defines a flag.
-  /// See [ArgParser.addFlag()].
-  void addFlag(String name,
-      {String abbr,
-      String help,
-      bool defaultsTo = false,
-      bool negatable = true,
-      void Function(bool value) callback,
-      bool hide = false}) {
-    _knownFlags.add(name);
-    _parser.addFlag(name,
-        abbr: abbr,
-        help: help,
-        defaultsTo: defaultsTo,
-        negatable: negatable,
-        callback: callback,
-        hide: hide);
-  }
-
-  /// Defines an option that takes multiple values.
-  /// See [ArgParser.addMultiOption].
-  void addMultiOption(String name,
-      {String abbr,
-      String help,
-      String valueHelp,
-      Iterable<String> allowed,
-      Map<String, String> allowedHelp,
-      Iterable<String> defaultsTo,
-      void Function(List<String> values) callback,
-      bool splitCommas = true,
-      bool hide = false}) {
-    _knownFlags.add(name);
-    _parser.addMultiOption(name,
-        abbr: abbr,
-        help: help,
-        valueHelp: valueHelp,
-        allowed: allowed,
-        allowedHelp: allowedHelp,
-        defaultsTo: defaultsTo,
-        callback: callback,
-        splitCommas: splitCommas,
-        hide: hide);
-  }
-
-  /// Defines a value-taking option.
-  /// See [ArgParser.addOption()].
-  void addOption(String name,
-      {String abbr,
-      String help,
-      String valueHelp,
-      List<String> allowed,
-      Map<String, String> allowedHelp,
-      String defaultsTo,
-      void Function(Object) callback,
-      bool hide = false}) {
-    _knownFlags.add(name);
-    _parser.addOption(name,
-        abbr: abbr,
-        help: help,
-        valueHelp: valueHelp,
-        allowed: allowed,
-        allowedHelp: allowedHelp,
-        defaultsTo: defaultsTo,
-        callback: callback,
-        hide: hide);
-  }
-
-  /// Generates a string displaying usage information for the defined options.
-  /// See [ArgParser.usage].
-  String getUsage() => _parser.usage;
-
-  /// Parses [args], a list of command-line arguments, matches them against the
-  /// flags and options defined by this parser, and returns the result. The
-  /// values of any defined variables are captured in the given map.
-  /// See [ArgParser].
-  ArgResults parse(List<String> args, Map<String, String> definedVariables) =>
-      _parser.parse(
-          _filterUnknowns(parseDefinedVariables(args, definedVariables)));
-
-  List<String> parseDefinedVariables(
-      List<String> args, Map<String, String> definedVariables) {
-    var count = args.length;
-    var remainingArgs = <String>[];
-    for (var i = 0; i < count; i++) {
-      var arg = args[i];
-      if (arg == '--') {
-        while (i < count) {
-          remainingArgs.add(args[i++]);
-        }
-      } else if (arg.startsWith('-D')) {
-        definedVariables[arg.substring(2)] = args[++i];
-      } else {
-        remainingArgs.add(arg);
-      }
-    }
-    return remainingArgs;
-  }
-
-  List<String> _filterUnknowns(List<String> args) {
-    // TODO(devoncarew): Consider dropping support for the
-    // --ignore-unrecognized-flags option.
-
-    // Only filter args if the ignore flag is specified.
-    if (args.contains('--ignore-unrecognized-flags')) {
-      // Filter all unrecognized flags and options.
-      var filtered = <String>[];
-      for (var i = 0; i < args.length; ++i) {
-        var arg = args[i];
-        if (arg.startsWith('--') && arg.length > 2) {
-          var option = arg.substring(2);
-          // remove any leading 'no-'
-          if (option.startsWith('no-')) {
-            option = option.substring(3);
-          }
-          // strip the last '=value'
-          var equalsOffset = option.lastIndexOf('=');
-          if (equalsOffset != -1) {
-            option = option.substring(0, equalsOffset);
-          }
-          // check the option
-          if (!_knownFlags.contains(option)) {
-            //"eat" params by advancing to the next flag/option
-            i = _getNextFlagIndex(args, i);
-          } else {
-            filtered.add(arg);
-          }
-        } else {
-          filtered.add(arg);
-        }
-      }
-
-      return filtered;
-    } else {
-      return args;
-    }
-  }
-
-  int _getNextFlagIndex(List<String> args, int i) {
-    for (; i < args.length; ++i) {
-      if (args[i].startsWith('--')) {
-        return i;
-      }
-    }
-    return i;
-  }
-}
-
 /// The [Driver] class represents a single running instance of the analysis
 /// server application.  It is responsible for parsing command line options
 /// and starting the HTTP and/or stdio servers.
 class Driver implements ServerStarter {
   /// The name of the application that is used to start a server.
-  static const BINARY_NAME = 'server';
+  static const BINARY_NAME = 'analysis_server';
 
   /// The name of the option used to set the identifier for the client.
   static const String CLIENT_ID = 'client-id';
@@ -286,7 +122,7 @@
   @override
   void start(List<String> arguments, [SendPort sendPort]) {
     var parser = _createArgParser();
-    var results = parser.parse(arguments, <String, String>{});
+    var results = parser.parse(arguments);
 
     var analysisServerOptions = AnalysisServerOptions();
     analysisServerOptions.newAnalysisDriverLog =
@@ -370,7 +206,7 @@
     }
 
     if (results[HELP_OPTION]) {
-      _printUsage(parser.parser, analytics, fromHelp: true);
+      _printUsage(parser, analytics, fromHelp: true);
       return null;
     }
 
@@ -418,7 +254,7 @@
       } on FormatException {
         print('Invalid port number: ${results[PORT_OPTION]}');
         print('');
-        _printUsage(parser.parser, analytics);
+        _printUsage(parser, analytics);
         exitCode = 1;
         return null;
       }
@@ -450,7 +286,7 @@
   void startAnalysisServer(
     ArgResults results,
     AnalysisServerOptions analysisServerOptions,
-    CommandLineParser parser,
+    ArgParser parser,
     DartSdkManager dartSdkManager,
     CrashReportingAttachmentsBuilder crashReportingAttachmentsBuilder,
     InstrumentationService instrumentationService,
@@ -639,8 +475,8 @@
   }
 
   /// Create and return the parser used to parse the command-line arguments.
-  CommandLineParser _createArgParser() {
-    var parser = CommandLineParser();
+  ArgParser _createArgParser() {
+    var parser = ArgParser();
     parser.addFlag(HELP_OPTION,
         abbr: 'h', negatable: false, help: 'Print this usage information.');
     parser.addOption(CLIENT_ID,
@@ -716,6 +552,8 @@
     parser.addFlag('enable-instrumentation', hide: true);
     // Removed 11/12/2020.
     parser.addOption('file-read-mode', hide: true);
+    // Removed 11/12/2020.
+    parser.addFlag('ignore-unrecognized-flags', hide: true);
     // Removed 11/8/2020.
     parser.addFlag('preview-dart-2', hide: true);
     // Removed 11/12/2020.
@@ -752,8 +590,11 @@
   }
 
   /// Print information about how to use the server.
-  void _printUsage(ArgParser parser, telemetry.Analytics analytics,
-      {bool fromHelp = false}) {
+  void _printUsage(
+    ArgParser parser,
+    telemetry.Analytics analytics, {
+    bool fromHelp = false,
+  }) {
     print('Usage: $BINARY_NAME [flags]');
     print('');
     print('Supported flags are:');
diff --git a/pkg/analysis_server/lib/src/services/completion/yaml/analysis_options_generator.dart b/pkg/analysis_server/lib/src/services/completion/yaml/analysis_options_generator.dart
new file mode 100644
index 0000000..7f9228a
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/completion/yaml/analysis_options_generator.dart
@@ -0,0 +1,67 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/protocol_server.dart';
+import 'package:analysis_server/src/services/completion/yaml/producer.dart';
+import 'package:analysis_server/src/services/completion/yaml/yaml_completion_generator.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/lint/registry.dart';
+import 'package:analyzer/src/task/options.dart';
+
+/// A completion generator that can produce completion suggestions for analysis
+/// options files.
+class AnalysisOptionsGenerator extends YamlCompletionGenerator {
+  /// The producer representing the known valid structure of an analysis options
+  /// file.
+  // TODO(brianwilkerson) We need to support multiple valid formats.
+  //  For example, the lint rules can either be a list or a map, but we only
+  //  suggest list items.
+  static const MapProducer analysisOptionsProducer = MapProducer({
+    AnalyzerOptions.analyzer: MapProducer({
+      AnalyzerOptions.enableExperiment: EmptyProducer(),
+      AnalyzerOptions.errors: EmptyProducer(),
+      AnalyzerOptions.exclude: EmptyProducer(),
+      AnalyzerOptions.language: MapProducer({
+        AnalyzerOptions.strictInference: EmptyProducer(),
+        AnalyzerOptions.strictRawTypes: EmptyProducer(),
+      }),
+      AnalyzerOptions.optionalChecks: MapProducer({
+        AnalyzerOptions.chromeOsManifestChecks: EmptyProducer(),
+      }),
+      AnalyzerOptions.plugins: EmptyProducer(),
+      AnalyzerOptions.strong_mode: MapProducer({
+        AnalyzerOptions.declarationCasts: EmptyProducer(),
+        AnalyzerOptions.implicitCasts: EmptyProducer(),
+        AnalyzerOptions.implicitDynamic: EmptyProducer(),
+      }),
+    }),
+    // TODO(brianwilkerson) Create a producer to produce `package:` URIs.
+    AnalyzerOptions.include: EmptyProducer(),
+    // TODO(brianwilkerson) Create constants for 'linter' and 'rules'.
+    'linter': MapProducer({
+      'rules': ListProducer(LintRuleProducer()),
+    }),
+  });
+
+  /// Initialize a newly created suggestion generator for analysis options
+  /// files.
+  AnalysisOptionsGenerator(ResourceProvider resourceProvider)
+      : super(resourceProvider);
+
+  @override
+  Producer get topLevelProducer => analysisOptionsProducer;
+}
+
+class LintRuleProducer extends Producer {
+  /// Initialize a location whose valid values are the names of the registered
+  /// lint rules.
+  const LintRuleProducer();
+
+  @override
+  Iterable<CompletionSuggestion> suggestions() sync* {
+    for (var rule in Registry.ruleRegistry.rules) {
+      yield identifier(rule.name);
+    }
+  }
+}
diff --git a/pkg/analysis_server/lib/src/services/completion/yaml/fix_data_generator.dart b/pkg/analysis_server/lib/src/services/completion/yaml/fix_data_generator.dart
new file mode 100644
index 0000000..4fd54bf
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/completion/yaml/fix_data_generator.dart
@@ -0,0 +1,71 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/services/completion/yaml/producer.dart';
+import 'package:analysis_server/src/services/completion/yaml/yaml_completion_generator.dart';
+import 'package:analyzer/file_system/file_system.dart';
+
+/// A completion generator that can produce completion suggestions for fix data
+/// files.
+class FixDataGenerator extends YamlCompletionGenerator {
+  /// The producer representing the known valid structure of a fix data file.
+  static const MapProducer fixDataProducer = MapProducer({
+    'version': EmptyProducer(),
+    'transforms': ListProducer(MapProducer({
+      'title': EmptyProducer(),
+      'date': EmptyProducer(),
+      'bulkApply': BooleanProducer(),
+      'element': MapProducer({
+        // TODO(brianwilkerson) Support suggesting uris.
+        'uris': EmptyProducer(),
+        'class': EmptyProducer(),
+        'constant': EmptyProducer(),
+        'constructor': EmptyProducer(),
+        'enum': EmptyProducer(),
+        'extension': EmptyProducer(),
+        'field': EmptyProducer(),
+        'function': EmptyProducer(),
+        'getter': EmptyProducer(),
+        'method': EmptyProducer(),
+        'mixin': EmptyProducer(),
+        'setter': EmptyProducer(),
+        'typedef': EmptyProducer(),
+        'variable': EmptyProducer(),
+        'inClass': EmptyProducer(),
+        'inEnum': EmptyProducer(),
+        'inExtension': EmptyProducer(),
+        'inMixin': EmptyProducer(),
+      }),
+      'changes': ListProducer(MapProducer({
+        // TODO(brianwilkerson) Create a way to tailor the list of additional
+        //  keys based on the kind when a kind has already been provided.
+        'kind': EnumProducer([
+          'addParameter',
+          'addTypeParameter',
+          'removeParameter',
+          'rename',
+          'renameParameter',
+        ]),
+        'index': EmptyProducer(),
+        'name': EmptyProducer(),
+        'style': EmptyProducer(),
+        'argumentValue': MapProducer({
+          'expression': EmptyProducer(),
+          'statements': EmptyProducer(),
+          // TODO(brianwilkerson) Figure out how to support 'variables'.
+          'variables': EmptyProducer(),
+        }),
+        'extends': EmptyProducer(),
+        'oldName': EmptyProducer(),
+        'newName': EmptyProducer(),
+      })),
+    })),
+  });
+
+  /// Initialize a newly created suggestion generator for fix data files.
+  FixDataGenerator(ResourceProvider resourceProvider) : super(resourceProvider);
+
+  @override
+  Producer get topLevelProducer => fixDataProducer;
+}
diff --git a/pkg/analysis_server/lib/src/services/completion/yaml/producer.dart b/pkg/analysis_server/lib/src/services/completion/yaml/producer.dart
new file mode 100644
index 0000000..834adac
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/completion/yaml/producer.dart
@@ -0,0 +1,127 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/protocol_server.dart';
+import 'package:analyzer/file_system/file_system.dart';
+
+/// An object that represents the location of a Boolean value.
+class BooleanProducer extends Producer {
+  /// Initialize a location whose valid values are Booleans.
+  const BooleanProducer();
+
+  @override
+  Iterable<CompletionSuggestion> suggestions() sync* {
+    yield identifier('true');
+    yield identifier('false');
+  }
+}
+
+/// An object that represents the location of an arbitrary value. They serve as
+/// placeholders when there are no reasonable suggestions for a given location.
+class EmptyProducer extends Producer {
+  /// Initialize a location whose valid values are arbitrary.
+  const EmptyProducer();
+
+  @override
+  Iterable<CompletionSuggestion> suggestions() sync* {
+    // Returns nothing.
+  }
+}
+
+/// An object that represents the location of a value from a finite set of
+/// choices.
+class EnumProducer extends Producer {
+  /// The list of valid values at this location.
+  final List<String> values;
+
+  /// Initialize a location whose valid values are in the list of [values].
+  const EnumProducer(this.values);
+
+  @override
+  Iterable<CompletionSuggestion> suggestions() sync* {
+    for (var value in values) {
+      yield identifier(value);
+    }
+  }
+}
+
+/// An object that represents the location of a possibly relative file path.
+class FilePathProducer extends Producer {
+  /// The resource provider used to access the content of the file in which
+  /// completion was requested.
+  final ResourceProvider provider;
+
+  /// Initialize a location whose valid values are file paths.
+  FilePathProducer(this.provider);
+
+  @override
+  Iterable<CompletionSuggestion> suggestions() sync* {
+    // TODO(brianwilkerson) Implement this.
+  }
+}
+
+/// An object that represents the location of an element in a list.
+class ListProducer extends Producer {
+  /// The producer used to produce suggestions for an element of the list.
+  final Producer element;
+
+  /// Initialize a location whose valid values are determined by the [element]
+  /// producer.
+  const ListProducer(this.element);
+
+  @override
+  Iterable<CompletionSuggestion> suggestions() sync* {
+    for (var suggestion in element.suggestions()) {
+      // TODO(brianwilkerson) Consider prepending the suggestion with a hyphen
+      //  when the current node isn't already preceded by a hyphen. The
+      //  cleanest way to do this is probably to access the [element] producer
+      //  in the place where we're choosing a producer in that situation.
+      // suggestion.completion = '- ${suggestion.completion}';
+      yield suggestion;
+    }
+  }
+}
+
+/// An object that represents the location of the keys in a map.
+class MapProducer extends Producer {
+  /// A table from the value of a key to the producer used to make suggestions
+  /// for the value following the key.
+  final Map<String, Producer> children;
+
+  /// Initialize a location whose valid values are the keys of a map as encoded
+  /// by the map of [children].
+  const MapProducer(this.children);
+
+  @override
+  Iterable<CompletionSuggestion> suggestions() sync* {
+    for (var entry in children.entries) {
+      if (entry.value is ListProducer) {
+        yield identifier('${entry.key}:');
+      } else {
+        yield identifier('${entry.key}: ');
+      }
+    }
+  }
+}
+
+/// An object that represents a specific location in the structure of the valid
+/// YAML representation and can produce completion suggestions appropriate for
+/// that location.
+abstract class Producer {
+  /// Initialize a newly created instance of this class.
+  const Producer();
+
+  /// A utility method used to create a suggestion for the [identifier].
+  CompletionSuggestion identifier(String identifier) => CompletionSuggestion(
+      CompletionSuggestionKind.IDENTIFIER,
+      1000,
+      identifier,
+      identifier.length,
+      0,
+      false,
+      false);
+
+  /// Return the completion suggestions appropriate to this location.
+  Iterable<CompletionSuggestion> suggestions();
+}
diff --git a/pkg/analysis_server/lib/src/services/completion/yaml/pubspec_generator.dart b/pkg/analysis_server/lib/src/services/completion/yaml/pubspec_generator.dart
new file mode 100644
index 0000000..e38bddc
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/completion/yaml/pubspec_generator.dart
@@ -0,0 +1,39 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/services/completion/yaml/producer.dart';
+import 'package:analysis_server/src/services/completion/yaml/yaml_completion_generator.dart';
+import 'package:analyzer/file_system/file_system.dart';
+
+/// A completion generator that can produce completion suggestions for pubspec
+/// files.
+class PubspecGenerator extends YamlCompletionGenerator {
+  /// The producer representing the known valid structure of a pubspec file.
+  static const MapProducer pubspecProducer = MapProducer({
+    'name': EmptyProducer(),
+    'version': EmptyProducer(),
+    'description': EmptyProducer(),
+    'homepage': EmptyProducer(),
+    'repository': EmptyProducer(),
+    'issue_tracker': EmptyProducer(),
+    'documentation': EmptyProducer(),
+    'executables': EmptyProducer(),
+    'publish_to': EmptyProducer(),
+    'environment': MapProducer({
+      'flutter': EmptyProducer(),
+      'sdk': EmptyProducer(),
+    }),
+    'dependencies': EmptyProducer(),
+    'dev_dependencies': EmptyProducer(),
+    // TODO(brianwilkerson) Suggest names already listed under 'dependencies'
+    //  and 'dev_dependencies'.
+    'dependency_overrides': EmptyProducer(),
+  });
+
+  /// Initialize a newly created suggestion generator for pubspec files.
+  PubspecGenerator(ResourceProvider resourceProvider) : super(resourceProvider);
+
+  @override
+  Producer get topLevelProducer => pubspecProducer;
+}
diff --git a/pkg/analysis_server/lib/src/services/completion/yaml/yaml_completion_generator.dart b/pkg/analysis_server/lib/src/services/completion/yaml/yaml_completion_generator.dart
new file mode 100644
index 0000000..3d0b64c
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/completion/yaml/yaml_completion_generator.dart
@@ -0,0 +1,224 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/protocol_server.dart';
+import 'package:analysis_server/src/services/completion/yaml/producer.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:yaml/yaml.dart';
+
+/// A completion generator that can produce completion suggestions for files
+/// containing a YAML structure.
+abstract class YamlCompletionGenerator {
+  /// The resource provider used to access the content of the file in which
+  /// completion was requested.
+  final ResourceProvider resourceProvider;
+
+  /// Initialize a newly created generator to use the [resourceProvider] to
+  /// access the content of the file in which completion was requested.
+  YamlCompletionGenerator(this.resourceProvider);
+
+  /// Return the producer used to produce suggestions at the top-level of the
+  /// file.
+  Producer get topLevelProducer;
+
+  /// Return the completion suggestions appropriate for the given [offset] in
+  /// the file at the given [filePath].
+  List<CompletionSuggestion> getSuggestions(String filePath, int offset) {
+    var file = resourceProvider.getFile(filePath);
+    String content;
+    try {
+      content = file.readAsStringSync();
+    } on FileSystemException {
+      // If the file doesn't exist or can't be read, then there are no
+      // suggestions.
+      return const <CompletionSuggestion>[];
+    }
+    var root = _parseYaml(content);
+    if (root == null) {
+      // If the contents can't be parsed, then there are no suggestions.
+      return const <CompletionSuggestion>[];
+    }
+    var path = _pathToOffset(root, offset);
+    var completionNode = path.last;
+    if (completionNode is YamlScalar) {
+      var value = completionNode.value;
+      if (value == null) {
+        return getSuggestionsForPath(path, offset);
+      } else if (value is String && completionNode.style == ScalarStyle.PLAIN) {
+        return getSuggestionsForPath(path, offset);
+      }
+    } else {
+      return getSuggestionsForPath(path, offset);
+    }
+    // There are no completions at the given location.
+    return const <CompletionSuggestion>[];
+  }
+
+  /// Given a [path] to the node in which completions are being requested and
+  /// the offset of the cursor, return the completions appropriate at that
+  /// location.
+  List<CompletionSuggestion> getSuggestionsForPath(
+      List<YamlNode> path, int offset) {
+    var producer = _producerForPath(path);
+    if (producer == null) {
+      return const <CompletionSuggestion>[];
+    }
+    var invalidSuggestions = _siblingsOnPath(path);
+    var suggestions = <CompletionSuggestion>[];
+    for (var suggestion in producer.suggestions()) {
+      if (!invalidSuggestions.contains(suggestion.completion)) {
+        suggestions.add(suggestion);
+      }
+    }
+    return suggestions;
+  }
+
+  /// Return the result of parsing the file [content] into a YAML node.
+  YamlNode _parseYaml(String content) {
+    try {
+      return loadYamlNode(content);
+    } on YamlException {
+      // If the file can't be parsed, then fall through to return `null`.
+    }
+    return null;
+  }
+
+  /// Return a list containing the node containing the [offset] and all of the
+  /// nodes between that and the [root] node. The root node is first in the list
+  /// and the node containing the offset is the last element in the list.
+  List<YamlNode> _pathToOffset(YamlNode root, int offset) {
+    var path = <YamlNode>[];
+    var node = root;
+    while (node != null) {
+      path.add(node);
+      node = node.childContainingOffset(offset);
+    }
+    return path;
+  }
+
+  /// Return the producer that should be used to produce completion suggestions
+  /// for the last node in the node [path].
+  Producer _producerForPath(List<YamlNode> path) {
+    var producer = topLevelProducer;
+    for (var i = 0; i < path.length - 1; i++) {
+      var node = path[i];
+      if (node is YamlMap && producer is MapProducer) {
+        var key = node.keyAtValue(path[i + 1]);
+        if (key is YamlScalar) {
+          producer = (producer as MapProducer).children[key.value];
+        } else {
+          return null;
+        }
+      } else if (node is YamlList && producer is ListProducer) {
+        producer = (producer as ListProducer).element;
+      } else {
+        return producer;
+      }
+    }
+    return producer;
+  }
+
+  /// Return a list of the suggestions that should not be suggested because they
+  /// are already in the structure.
+  List<String> _siblingsOnPath(List<YamlNode> path) {
+    List<String> siblingsInList(YamlList list, YamlNode currentElement) {
+      var siblings = <String>[];
+      for (var element in list.nodes) {
+        if (element != currentElement &&
+            element is YamlScalar &&
+            element.value is String) {
+          siblings.add(element.value);
+        }
+      }
+      return siblings;
+    }
+
+    List<String> siblingsInMap(YamlMap map, YamlNode currentKey) {
+      var siblings = <String>[];
+      for (var key in map.nodes.keys) {
+        if (key != currentKey && key is YamlScalar && key.value is String) {
+          siblings.add('${key.value}: ');
+        }
+      }
+      return siblings;
+    }
+
+    var length = path.length;
+    if (length < 2) {
+      return const <String>[];
+    }
+    var node = path[length - 1];
+    if (node is YamlList) {
+      return siblingsInList(node, null);
+    } else if (node is YamlMap) {
+      return siblingsInMap(node, null);
+    }
+    var parent = path[length - 2];
+    if (parent is YamlList) {
+      return siblingsInList(parent, node);
+    } else if (parent is YamlMap) {
+      return siblingsInMap(parent, node);
+    }
+    return const <String>[];
+  }
+}
+
+extension on YamlMap {
+  /// Return the node representing the key that corresponds to the value
+  /// represented by the [value] node.
+  YamlNode keyAtValue(YamlNode value) {
+    for (var entry in nodes.entries) {
+      if (entry.value == value) {
+        return entry.key;
+      }
+    }
+    return null;
+  }
+}
+
+extension on YamlNode {
+  /// Return the child of this node that contains the given [offset], or `null`
+  /// if none of the children contains the offset.
+  YamlNode childContainingOffset(int offset) {
+    var node = this;
+    if (node is YamlList) {
+      for (var element in node.nodes) {
+        if (element.containsOffset(offset)) {
+          return element;
+        }
+      }
+      for (var element in node.nodes) {
+        if (element is YamlScalar && element.value == null) {
+          // TODO(brianwilkerson) Testing for a null value probably gets
+          //  confused when there are multiple null values.
+          return element;
+        }
+      }
+    } else if (node is YamlMap) {
+      for (var entry in node.nodes.entries) {
+        if ((entry.key as YamlNode).containsOffset(offset)) {
+          return entry.key;
+        }
+        var value = entry.value;
+        if (value.containsOffset(offset) ||
+            (value is YamlScalar && value.value == null)) {
+          // TODO(brianwilkerson) Testing for a null value probably gets
+          //  confused when there are multiple null values or when there is a
+          //  null value before the node that actually contains the offset.
+          return entry.value;
+        }
+      }
+    }
+    return null;
+  }
+
+  /// Return `true` if this node contains the given [offset].
+  bool containsOffset(int offset) {
+    // TODO(brianwilkerson) Nodes at the end of the file contain any trailing
+    //  whitespace. This needs to be accounted for, here or elsewhere.
+    var nodeOffset = span.start.offset;
+    var nodeEnd = nodeOffset + span.length;
+    return nodeOffset <= offset && offset <= nodeEnd;
+  }
+}
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/add_async.dart b/pkg/analysis_server/lib/src/services/correction/dart/add_async.dart
index ef18db3..59739f3 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/add_async.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/add_async.dart
@@ -5,24 +5,92 @@
 import 'package:analysis_server/src/services/correction/dart/abstract_producer.dart';
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
 
 class AddAsync extends CorrectionProducer {
+  /// A flag indicating whether this producer is producing a fix in the case
+  /// where a function is missing a return at the end.
+  final bool isForMissingReturn;
+
+  /// Initialize a newly created producer.
+  AddAsync(this.isForMissingReturn);
+
   @override
   FixKind get fixKind => DartFixKind.ADD_ASYNC;
 
   @override
   Future<void> compute(ChangeBuilder builder) async {
-    var body = node.thisOrAncestorOfType<FunctionBody>();
-    if (body != null && body.keyword == null) {
-      var typeProvider = this.typeProvider;
-      await builder.addDartFileEdit(file, (builder) {
-        builder.convertFunctionFromSyncToAsync(body, typeProvider);
-      });
+    if (isForMissingReturn) {
+      var parent = node.parent;
+      DartType returnType;
+      FunctionBody body;
+      if (parent is FunctionDeclaration) {
+        returnType = parent.returnType.type;
+        body = parent.functionExpression.body;
+      } else if (parent is MethodDeclaration) {
+        returnType = parent.returnType.type;
+        body = parent.body;
+      }
+      if (body == null) {
+        return;
+      }
+      if (_isFutureVoid(returnType) && _hasNoReturns(body)) {
+        await builder.addDartFileEdit(file, (builder) {
+          builder.addSimpleInsertion(body.offset, 'async ');
+        });
+      }
+    } else {
+      var body = node.thisOrAncestorOfType<FunctionBody>();
+      if (body != null && body.keyword == null) {
+        var typeProvider = this.typeProvider;
+        await builder.addDartFileEdit(file, (builder) {
+          builder.convertFunctionFromSyncToAsync(body, typeProvider);
+        });
+      }
     }
   }
 
+  /// Return `true` if there are no return statements in the given function
+  /// [body].
+  bool _hasNoReturns(FunctionBody body) {
+    var finder = _ReturnFinder();
+    body.accept(finder);
+    return !finder.foundReturn;
+  }
+
+  /// Return `true` if the [type] is `Future<void>`.
+  bool _isFutureVoid(DartType type) {
+    if (type is InterfaceType && type.isDartAsyncFuture) {
+      return type.typeArguments[0].isVoid;
+    }
+    return false;
+  }
+
   /// Return an instance of this class. Used as a tear-off in `FixProcessor`.
-  static AddAsync newInstance() => AddAsync();
+  static AddAsync missingReturn() => AddAsync(true);
+
+  /// Return an instance of this class. Used as a tear-off in `FixProcessor`.
+  static AddAsync newInstance() => AddAsync(false);
+}
+
+/// An AST visitor used to find return statements in function bodies.
+class _ReturnFinder extends RecursiveAstVisitor<void> {
+  /// A flag indicating whether a return statement was visited.
+  bool foundReturn = false;
+
+  /// Initialize a newly created visitor.
+  _ReturnFinder();
+
+  @override
+  void visitFunctionExpression(FunctionExpression node) {
+    // Return statements within closures aren't counted.
+  }
+
+  @override
+  void visitReturnStatement(ReturnStatement node) {
+    foundReturn = true;
+  }
 }
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/convert_to_set_literal.dart b/pkg/analysis_server/lib/src/services/correction/dart/convert_to_set_literal.dart
index f374346..f6a8db3 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/convert_to_set_literal.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/convert_to_set_literal.dart
@@ -178,6 +178,11 @@
           parent2.type?.type?.element == typeProvider.setElement) {
         return true;
       }
+    } else if (parent.parent is InvocationExpression) {
+      var parameterElement = creation.staticParameterElement;
+      if (parameterElement?.type?.element == typeProvider.setElement) {
+        return true;
+      }
     }
     return _hasUnambiguousElement(creation);
   }
diff --git a/pkg/analysis_server/lib/src/services/correction/fix_internal.dart b/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
index 881714d..5995aaf 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
@@ -646,6 +646,9 @@
     CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT: [
       AddAsync.newInstance,
     ],
+    CompileTimeErrorCode.BODY_MIGHT_COMPLETE_NORMALLY: [
+      AddAsync.missingReturn,
+    ],
     CompileTimeErrorCode.CAST_TO_NON_TYPE: [
       ChangeTo.classOrMixin,
       CreateClass.newInstance,
@@ -959,6 +962,9 @@
     HintCode.MISSING_REQUIRED_PARAM_WITH_DETAILS: [
       AddMissingRequiredArgument.newInstance,
     ],
+    HintCode.MISSING_RETURN: [
+      AddAsync.missingReturn,
+    ],
     HintCode.NULLABLE_TYPE_IN_CATCH_CLAUSE: [
       RemoveQuestionMark.newInstance,
     ],
diff --git a/pkg/analysis_server/test/src/services/completion/test_all.dart b/pkg/analysis_server/test/src/services/completion/test_all.dart
index 6055c7b..19d31b3 100644
--- a/pkg/analysis_server/test/src/services/completion/test_all.dart
+++ b/pkg/analysis_server/test/src/services/completion/test_all.dart
@@ -6,10 +6,12 @@
 
 import 'dart/test_all.dart' as dart;
 import 'filtering/test_all.dart' as filtering;
+import 'yaml/test_all.dart' as yaml;
 
 void main() {
   defineReflectiveSuite(() {
     dart.main();
     filtering.main();
+    yaml.main();
   }, name: 'completion');
 }
diff --git a/pkg/analysis_server/test/src/services/completion/yaml/analysis_options_generator_test.dart b/pkg/analysis_server/test/src/services/completion/yaml/analysis_options_generator_test.dart
new file mode 100644
index 0000000..c86dc28
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/completion/yaml/analysis_options_generator_test.dart
@@ -0,0 +1,155 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/services/completion/yaml/analysis_options_generator.dart';
+import 'package:analyzer/src/task/options.dart';
+import 'package:linter/src/rules.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'yaml_generator_test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(AnalysisOptionsGeneratorTest);
+  });
+}
+
+@reflectiveTest
+class AnalysisOptionsGeneratorTest extends YamlGeneratorTest {
+  @override
+  String get fileName => 'analysis_options.yaml';
+
+  @override
+  AnalysisOptionsGenerator get generator =>
+      AnalysisOptionsGenerator(resourceProvider);
+
+  void test_analyzer() {
+    getCompletions('''
+analyzer:
+  ^
+''');
+    assertSuggestion('${AnalyzerOptions.enableExperiment}: ');
+  }
+
+  void test_empty() {
+    getCompletions('^');
+    assertSuggestion('${AnalyzerOptions.analyzer}: ');
+    assertSuggestion('${AnalyzerOptions.include}: ');
+    // TODO(brianwilkerson) Replace this with a constant.
+    assertSuggestion('linter: ');
+  }
+
+  void test_linter() {
+    getCompletions('''
+linter:
+  ^
+''');
+    assertSuggestion('rules:');
+  }
+
+  void test_linter_rules() {
+    registerLintRules();
+    getCompletions('''
+linter:
+  rules:
+    ^
+''');
+    assertSuggestion('annotate_overrides');
+  }
+
+  void test_linter_rules_listItem_first() {
+    registerLintRules();
+    getCompletions('''
+linter:
+  rules:
+    - ^
+    - annotate_overrides
+''');
+    assertSuggestion('avoid_as');
+    assertNoSuggestion('annotate_overrides');
+  }
+
+  void test_linter_rules_listItem_last() {
+    registerLintRules();
+    getCompletions('''
+linter:
+  rules:
+    - annotate_overrides
+    - ^
+''');
+    assertSuggestion('avoid_as');
+    assertNoSuggestion('annotate_overrides');
+  }
+
+  void test_linter_rules_listItem_middle() {
+    registerLintRules();
+    getCompletions('''
+linter:
+  rules:
+    - annotate_overrides
+    - ^
+    - avoid_empty_else
+''');
+    assertSuggestion('avoid_as');
+    assertNoSuggestion('annotate_overrides');
+    assertNoSuggestion('avoid_empty_else');
+  }
+
+  void test_linter_rules_listItem_nonDuplicate() {
+    registerLintRules();
+    getCompletions('''
+linter:
+  rules:
+    - annotate_overrides
+    - ^
+''');
+    assertNoSuggestion('annotate_overrides');
+  }
+
+  void test_linter_rules_listItem_only() {
+    registerLintRules();
+    getCompletions('''
+linter:
+  rules:
+    - ^
+''');
+    assertSuggestion('annotate_overrides');
+  }
+
+  void test_linter_rules_listItem_partial() {
+    registerLintRules();
+    getCompletions('''
+linter:
+  rules:
+    - ann^
+''');
+    assertSuggestion('annotate_overrides');
+  }
+
+  @failingTest
+  void test_topLevel_afterOtherKeys() {
+    // This test fails because the cursor is considered to be inside the exclude
+    // list, and we don't suggest values there.
+    getCompletions('''
+analyzer:
+  exclude:
+    - '*.g.dart'
+^
+''');
+    assertSuggestion('${AnalyzerOptions.include}: ');
+  }
+
+  @failingTest
+  void test_topLevel_afterOtherKeys_partial() {
+    // This test fails because the YAML parser can't recover from this kind of
+    // invalid input.
+    getCompletions('''
+analyzer:
+  exclude:
+    - '*.g.dart'
+li^
+''');
+    assertSuggestion('linter');
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/completion/yaml/fix_data_generator_test.dart b/pkg/analysis_server/test/src/services/completion/yaml/fix_data_generator_test.dart
new file mode 100644
index 0000000..4634360
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/completion/yaml/fix_data_generator_test.dart
@@ -0,0 +1,76 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/services/completion/yaml/fix_data_generator.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'yaml_generator_test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(FixDataGeneratorTest);
+  });
+}
+
+@reflectiveTest
+class FixDataGeneratorTest extends YamlGeneratorTest {
+  @override
+  String get fileName => 'fix_data.yaml';
+
+  @override
+  FixDataGenerator get generator => FixDataGenerator(resourceProvider);
+
+  void test_empty() {
+    getCompletions('^');
+    assertSuggestion('version: ');
+    assertSuggestion('transforms:');
+  }
+
+  void test_transforms_changes_listItem_last() {
+    getCompletions('''
+transforms:
+  - changes:
+    - kind: rename
+      ^
+''');
+    assertSuggestion('newName: ');
+    assertNoSuggestion('kind: ');
+  }
+
+  void test_transforms_changes_listItem_only() {
+    getCompletions('''
+transforms:
+  - changes:
+    - ^
+''');
+    assertSuggestion('kind: ');
+  }
+
+  void test_transforms_element() {
+    getCompletions('''
+transforms:
+  - element:
+      ^
+''');
+    assertSuggestion('uris: ');
+  }
+
+  void test_transforms_listItem_last() {
+    getCompletions('''
+transforms:
+  - title: ''
+    ^
+''');
+    assertSuggestion('date: ');
+    assertNoSuggestion('title: ');
+  }
+
+  void test_transforms_listItem_only() {
+    getCompletions('''
+transforms:
+  - ^
+''');
+    assertSuggestion('title: ');
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/completion/yaml/pubspec_generator_test.dart b/pkg/analysis_server/test/src/services/completion/yaml/pubspec_generator_test.dart
new file mode 100644
index 0000000..7247af0
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/completion/yaml/pubspec_generator_test.dart
@@ -0,0 +1,37 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/services/completion/yaml/pubspec_generator.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'yaml_generator_test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(PubspecGeneratorTest);
+  });
+}
+
+@reflectiveTest
+class PubspecGeneratorTest extends YamlGeneratorTest {
+  @override
+  String get fileName => 'pubspec.yaml';
+
+  @override
+  PubspecGenerator get generator => PubspecGenerator(resourceProvider);
+
+  void test_empty() {
+    getCompletions('^');
+    assertSuggestion('name: ');
+  }
+
+  void test_environment() {
+    getCompletions('''
+environment:
+  ^
+''');
+    assertSuggestion('flutter: ');
+    assertSuggestion('sdk: ');
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/completion/yaml/test_all.dart b/pkg/analysis_server/test/src/services/completion/yaml/test_all.dart
new file mode 100644
index 0000000..0d82611
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/completion/yaml/test_all.dart
@@ -0,0 +1,17 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'analysis_options_generator_test.dart' as analysis_options_generator;
+import 'fix_data_generator_test.dart' as fix_data_generator;
+import 'pubspec_generator_test.dart' as pubspec_generator;
+
+void main() {
+  defineReflectiveSuite(() {
+    analysis_options_generator.main();
+    fix_data_generator.main();
+    pubspec_generator.main();
+  }, name: 'yaml');
+}
diff --git a/pkg/analysis_server/test/src/services/completion/yaml/yaml_generator_test_support.dart b/pkg/analysis_server/test/src/services/completion/yaml/yaml_generator_test_support.dart
new file mode 100644
index 0000000..7e4cc84
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/completion/yaml/yaml_generator_test_support.dart
@@ -0,0 +1,64 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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.
+
+import 'package:analysis_server/src/protocol_server.dart';
+import 'package:analysis_server/src/services/completion/yaml/yaml_completion_generator.dart';
+import 'package:analyzer/src/test_utilities/resource_provider_mixin.dart';
+import 'package:test/test.dart';
+
+abstract class YamlGeneratorTest with ResourceProviderMixin {
+  /// The completion results produced by [getCompletions].
+  /* late */ List<CompletionSuggestion> results;
+
+  /// Return the name of the file being tested.
+  String get fileName;
+
+  /// Return the generator to be used for this test.
+  YamlCompletionGenerator get generator;
+
+  /// Assert that there is no suggestion with the given [completion].
+  void assertNoSuggestion(String completion) {
+    for (var suggestion in results) {
+      if (suggestion.completion == completion) {
+        var buffer = StringBuffer();
+        buffer.writeln("Unexpected suggestion of '$completion' in:");
+        for (var suggestion in results) {
+          buffer.writeln("  '${suggestion.completion}'");
+        }
+        fail(buffer.toString());
+      }
+    }
+  }
+
+  /// Assert that there is a suggestion with the given [completion].
+  void assertSuggestion(String completion) {
+    for (var suggestion in results) {
+      if (suggestion.completion == completion) {
+        return;
+      }
+    }
+    var buffer = StringBuffer();
+    buffer.writeln("Missing suggestion of '$completion', found:");
+    for (var suggestion in results) {
+      buffer.writeln("  '${suggestion.completion}'");
+    }
+    fail(buffer.toString());
+  }
+
+  /// Compute the completions in the given [content]. The location of the
+  /// completion request is encoded in the content as a caret (`^`).
+  void getCompletions(String content) {
+    // Extract the completion location from the [content].
+    var completionOffset = content.indexOf('^');
+    expect(completionOffset, isNot(equals(-1)), reason: 'missing ^');
+    var nextOffset = content.indexOf('^', completionOffset + 1);
+    expect(nextOffset, equals(-1), reason: 'too many ^');
+    content = content.substring(0, completionOffset) +
+        content.substring(completionOffset + 1);
+    // Add the file to the file system.
+    var file = newFile('/home/test/$fileName', content: content);
+    // Generate completions.
+    results = generator.getSuggestions(file.path, completionOffset);
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/correction/fix/add_async_test.dart b/pkg/analysis_server/test/src/services/correction/fix/add_async_test.dart
index 8047f30..f4c1745 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/add_async_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/add_async_test.dart
@@ -4,7 +4,7 @@
 
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server/src/services/linter/lint_names.dart';
-import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/dart/analysis/experiments.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -14,6 +14,7 @@
 void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AddAsyncTest);
+    defineReflectiveTests(AddAsyncWithNullSafetyTest);
     defineReflectiveTests(AvoidReturningNullForFutureTest);
   });
 }
@@ -69,7 +70,7 @@
   await foo;
   return 1;
 }
-''', errorFilter: (AnalysisError error) {
+''', errorFilter: (error) {
       return error.errorCode == CompileTimeErrorCode.UNDEFINED_IDENTIFIER_AWAIT;
     });
   }
@@ -84,7 +85,7 @@
 void takeFutureCallback(Future callback()) {}
 
 void doStuff() => takeFutureCallback(() async => await 1);
-''', errorFilter: (AnalysisError error) {
+''', errorFilter: (error) {
       return error.errorCode == CompileTimeErrorCode.UNDEFINED_IDENTIFIER_AWAIT;
     });
   }
@@ -100,6 +101,42 @@
 ''');
   }
 
+  Future<void> test_missingReturn_hasReturn() async {
+    await resolveTestCode('''
+Future<int> f(bool b) {
+  if (b) {
+    return 0;
+  }
+}
+''');
+    await assertNoFix(errorFilter: (error) {
+      return error.errorCode ==
+          CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION;
+    });
+  }
+
+  Future<void> test_missingReturn_notVoid() async {
+    await resolveTestCode('''
+Future<int> f() {
+  print('');
+}
+''');
+    await assertNoFix();
+  }
+
+  Future<void> test_missingReturn_void() async {
+    await resolveTestCode('''
+Future<void> f() {
+  print('');
+}
+''');
+    await assertHasFix('''
+Future<void> f() async {
+  print('');
+}
+''');
+  }
+
   Future<void> test_nullFunctionBody() async {
     await resolveTestCode('''
 var F = await;
@@ -121,7 +158,7 @@
   await foo();
   return 42;
 }
-''', errorFilter: (AnalysisError error) {
+''', errorFilter: (error) {
       return error.errorCode == CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT;
     });
   }
@@ -179,6 +216,95 @@
 }
 
 @reflectiveTest
+class AddAsyncWithNullSafetyTest extends FixProcessorTest {
+  @override
+  List<String> get experiments => [EnableString.non_nullable];
+
+  @override
+  FixKind get kind => DartFixKind.ADD_ASYNC;
+
+  Future<void> test_missingReturn_method_hasReturn() async {
+    await resolveTestCode('''
+class C {
+  Future<int> m(bool b) {
+    if (b) {
+      return 0;
+    }
+  }
+}
+''');
+    await assertNoFix(errorFilter: (error) {
+      return error.errorCode ==
+          CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_METHOD;
+    });
+  }
+
+  Future<void> test_missingReturn_method_notVoid() async {
+    await resolveTestCode('''
+class C {
+  Future<int> m() {
+    print('');
+  }
+}
+''');
+    await assertNoFix();
+  }
+
+  Future<void> test_missingReturn_method_void() async {
+    await resolveTestCode('''
+class C {
+  Future<void> m() {
+    print('');
+  }
+}
+''');
+    await assertHasFix('''
+class C {
+  Future<void> m() async {
+    print('');
+  }
+}
+''');
+  }
+
+  Future<void> test_missingReturn_topLevel_hasReturn() async {
+    await resolveTestCode('''
+Future<int> f(bool b) {
+  if (b) {
+    return 0;
+  }
+}
+''');
+    await assertNoFix(errorFilter: (error) {
+      return error.errorCode ==
+          CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION;
+    });
+  }
+
+  Future<void> test_missingReturn_topLevel_notVoid() async {
+    await resolveTestCode('''
+Future<int> f() {
+  print('');
+}
+''');
+    await assertNoFix();
+  }
+
+  Future<void> test_missingReturn_topLevel_void() async {
+    await resolveTestCode('''
+Future<void> f() {
+  print('');
+}
+''');
+    await assertHasFix('''
+Future<void> f() async {
+  print('');
+}
+''');
+  }
+}
+
+@reflectiveTest
 class AvoidReturningNullForFutureTest extends FixProcessorLintTest {
   @override
   FixKind get kind => DartFixKind.ADD_ASYNC;
diff --git a/pkg/analysis_server/test/src/services/correction/fix/convert_to_set_literal_test.dart b/pkg/analysis_server/test/src/services/correction/fix/convert_to_set_literal_test.dart
index f12ee52..28674cb 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/convert_to_set_literal_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/convert_to_set_literal_test.dart
@@ -83,10 +83,7 @@
 ''');
   }
 
-  @failingTest
   Future<void> test_from_inferred() async {
-    // _setWouldBeInferred does not check for inference based on the parameter
-    // type.
     await resolveTestCode('''
 void f(Set<int> s) {}
 var s = f(Set.from([]));
diff --git a/pkg/analyzer/lib/src/error/best_practices_verifier.dart b/pkg/analyzer/lib/src/error/best_practices_verifier.dart
index acc8ac7..4fc82c5 100644
--- a/pkg/analyzer/lib/src/error/best_practices_verifier.dart
+++ b/pkg/analyzer/lib/src/error/best_practices_verifier.dart
@@ -1360,17 +1360,17 @@
       _errorReporter.reportErrorForNode(
           HintCode.INVALID_REQUIRED_OPTIONAL_POSITIONAL_PARAM,
           param,
-          [param.identifier.name]);
+          [_formalParameterNameOrEmpty(param)]);
     }
     for (final param in nonNamedParamsWithRequired.where((p) => p.isRequired)) {
       _errorReporter.reportErrorForNode(
           HintCode.INVALID_REQUIRED_POSITIONAL_PARAM,
           param,
-          [param.identifier.name]);
+          [_formalParameterNameOrEmpty(param)]);
     }
     for (final param in namedParamsWithRequiredAndDefault) {
       _errorReporter.reportErrorForNode(HintCode.INVALID_REQUIRED_NAMED_PARAM,
-          param, [param.identifier.name]);
+          param, [_formalParameterNameOrEmpty(param)]);
     }
   }
 
@@ -1629,6 +1629,11 @@
     return true;
   }
 
+  static String _formalParameterNameOrEmpty(FormalParameter node) {
+    var identifier = node.identifier;
+    return identifier?.name ?? '';
+  }
+
   static bool _hasNonVirtualAnnotation(ExecutableElement element) {
     if (element == null) {
       return false;
diff --git a/pkg/analyzer/lib/src/generated/engine.dart b/pkg/analyzer/lib/src/generated/engine.dart
index e0368a4..63e7b03 100644
--- a/pkg/analyzer/lib/src/generated/engine.dart
+++ b/pkg/analyzer/lib/src/generated/engine.dart
@@ -101,6 +101,10 @@
   /// The file name used for analysis options files.
   static const String ANALYSIS_OPTIONS_YAML_FILE = 'analysis_options.yaml';
 
+  /// The file name used for the files containing the data for the data-driven
+  /// fixes.
+  static const String FIX_DATA_FILE = 'fix_data.yaml';
+
   /// The file name used for pubspec files.
   static const String PUBSPEC_YAML_FILE = 'pubspec.yaml';
 
diff --git a/pkg/analyzer/test/src/diagnostics/invalid_required_positional_param_test.dart b/pkg/analyzer/test/src/diagnostics/invalid_required_positional_param_test.dart
index 39caa76..072131e 100644
--- a/pkg/analyzer/test/src/diagnostics/invalid_required_positional_param_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/invalid_required_positional_param_test.dart
@@ -21,7 +21,7 @@
     writeTestPackageConfigWithMeta();
   }
 
-  test_requiredPositionalParameter() async {
+  test_ofFunction_first() async {
     await assertErrorsInCode(r'''
 import 'package:meta/meta.dart';
 
@@ -31,7 +31,7 @@
     ]);
   }
 
-  test_requiredPositionalParameter_asSecond() async {
+  test_ofFunction_second() async {
     await assertErrorsInCode(r'''
 import 'package:meta/meta.dart';
 
@@ -41,6 +41,26 @@
     ]);
   }
 
+  test_ofGenericFunctionType_named() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+typedef F = void Function(@required int a);
+''', [
+      error(HintCode.INVALID_REQUIRED_POSITIONAL_PARAM, 60, 15),
+    ]);
+  }
+
+  test_ofGenericFunctionType_unnamed() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+typedef F = void Function(@required int);
+''', [
+      error(HintCode.INVALID_REQUIRED_POSITIONAL_PARAM, 60, 13),
+    ]);
+  }
+
   test_valid() async {
     await assertNoErrorsInCode(r'''
 m1() => null;
diff --git a/pkg/analyzer_plugin/lib/utilities/analyzer_converter.dart b/pkg/analyzer_plugin/lib/utilities/analyzer_converter.dart
index f7347d2..a46f3bd 100644
--- a/pkg/analyzer_plugin/lib/utilities/analyzer_converter.dart
+++ b/pkg/analyzer_plugin/lib/utilities/analyzer_converter.dart
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/element/element.dart' as analyzer;
-import 'package:analyzer/dart/element/type.dart' as analyzer;
 import 'package:analyzer/diagnostic/diagnostic.dart' as analyzer;
 import 'package:analyzer/error/error.dart' as analyzer;
 import 'package:analyzer/exception/exception.dart' as analyzer;
@@ -11,10 +10,7 @@
 import 'package:analyzer/source/line_info.dart' as analyzer;
 import 'package:analyzer/src/generated/engine.dart' as analyzer;
 import 'package:analyzer/src/generated/source.dart' as analyzer;
-import 'package:analyzer/src/generated/utilities_dart.dart' as analyzer;
 import 'package:analyzer_plugin/protocol/protocol_common.dart' as plugin;
-import 'package:analyzer_plugin/protocol/protocol_constants.dart' as plugin;
-import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 
 /// An object used to convert between objects defined by the 'analyzer' package
 /// and those defined by the plugin protocol.
diff --git a/pkg/compiler/lib/src/js/js.dart b/pkg/compiler/lib/src/js/js.dart
index c2f8403..dd31e3b 100644
--- a/pkg/compiler/lib/src/js/js.dart
+++ b/pkg/compiler/lib/src/js/js.dart
@@ -18,11 +18,14 @@
 String prettyPrint(Node node,
     {bool enableMinification: false,
     bool allowVariableMinification: true,
+    bool preferSemicolonToNewlineInMinifiedOutput: false,
     Renamer renamerForNames: JavaScriptPrintingOptions.identityRenamer}) {
   // TODO(johnniwinther): Do we need all the options here?
   JavaScriptPrintingOptions options = new JavaScriptPrintingOptions(
       shouldCompressOutput: enableMinification,
       minifyLocalVariables: allowVariableMinification,
+      preferSemicolonToNewlineInMinifiedOutput:
+          preferSemicolonToNewlineInMinifiedOutput,
       renamerForNames: renamerForNames);
   SimpleJavaScriptPrintingContext context =
       new SimpleJavaScriptPrintingContext();
diff --git a/pkg/compiler/lib/src/js/size_estimator.dart b/pkg/compiler/lib/src/js/size_estimator.dart
new file mode 100644
index 0000000..60d0354
--- /dev/null
+++ b/pkg/compiler/lib/src/js/size_estimator.dart
@@ -0,0 +1,1042 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+library js.size_estimator;
+
+import 'package:js_ast/js_ast.dart';
+import 'package:js_ast/src/characters.dart' as charCodes;
+import 'package:js_ast/src/precedence.dart';
+
+import '../js_backend/string_reference.dart';
+import '../js_backend/type_reference.dart';
+import '../js_emitter/metadata_collector.dart';
+
+/// [SizeEstimator] is a [NodeVisitor] designed to produce a consistent size
+/// estimate for a given JavaScript AST. [SizeEstimator] trades accuracy for
+/// stability and performance. In addition, [SizeEstimator] assumes we will emit
+/// production quality minified JavaScript.
+class SizeEstimator implements NodeVisitor {
+  int charCount = 0;
+  bool inForInit = false;
+  bool atStatementBegin = false;
+  bool pendingSemicolon = false;
+  bool pendingSpace = false;
+
+  static final String variableSizeEstimate = '#';
+  static final String nameSizeEstimate = '###';
+
+  String sizeEstimate(Node node) {
+    if (node is VariableDeclaration || node is VariableUse) {
+      // We assume all [VariableDeclaration] and [VariableUse] nodes are
+      // locals.
+      return variableSizeEstimate;
+    } else if (node is Name ||
+        node is Parameter ||
+        node is VariableDeclaration ||
+        node is VariableUse) {
+      return nameSizeEstimate;
+    } else if (node is LiteralString) {
+      assert(!node.isFinalized);
+      // We assume all non-final literal strings are minified names, and thus
+      // use the nameSizeEstimate.
+      return nameSizeEstimate;
+    } else if (node is BoundMetadataEntry) {
+      // Value is an int.
+      return '####';
+    } else if (node is TypeReference) {
+      // Type references vary in size. Some references look like:
+      // '<typeHolder>$.<type>' where <typeHolder> is a one byte local and
+      // <type> is roughly 3 bytes. However, we also have to initialize the type
+      // in the holder, some like ab:f("QQ<b7c>"), ie 16 bytes. For two
+      // occurences we will have on average 13 bytes. For a more detailed
+      // estimate, we'd have to partially finalize the results.
+      return '###_###_###_#';
+    } else if (node is StringReference) {
+      // Worst case we have to inline the string so size of string + 2 bytes for
+      // quotes.
+      return "'${node.constant}'";
+    } else {
+      throw UnsupportedError('$node type is not supported');
+    }
+  }
+
+  /// Always emit a newline, even under `enableMinification`.
+  void forceLine() {
+    out('\n'); // '\n'
+  }
+
+  void out(String s) {
+    if (s.length > 0) {
+      // We can elide a semicolon in some cases, but for simplicity we
+      // assume a semicolon is needed here.
+      if (pendingSemicolon) {
+        emit(';'); // ';'
+      }
+
+      // We can elide a pending space in some cases, but for simplicity we
+      // assume a space is needed here.
+      if (pendingSpace) {
+        emit(' '); // ' '
+      }
+      pendingSpace = false;
+      pendingSemicolon = false;
+      emit(s); // str
+    }
+  }
+
+  void outSemicolonLn() {
+    pendingSemicolon = true;
+  }
+
+  void emit(String s) {
+    charCount += s.length;
+  }
+
+  void visit(Node node) {
+    node.accept(this);
+  }
+
+  void visitCommaSeparated(List<Node> nodes, int hasRequiredType,
+      {bool newInForInit, bool newAtStatementBegin}) {
+    for (int i = 0; i < nodes.length; i++) {
+      if (i != 0) {
+        atStatementBegin = false;
+        out(','); // ','
+      }
+      visitNestedExpression(nodes[i], hasRequiredType,
+          newInForInit: newInForInit, newAtStatementBegin: newAtStatementBegin);
+    }
+  }
+
+  void visitAll(List<Node> nodes) {
+    nodes.forEach(visit);
+  }
+
+  @override
+  void visitProgram(Program program) {
+    if (program.body.isNotEmpty) {
+      visitAll(program.body);
+    }
+  }
+
+  Statement unwrapBlockIfSingleStatement(Statement body) {
+    Statement result = body;
+    while (result is Block) {
+      Block block = result;
+      if (block.statements.length != 1) break;
+      result = block.statements.single;
+    }
+    return result;
+  }
+
+  bool blockBody(Statement body, {bool needsSeparation}) {
+    if (body is Block) {
+      blockOut(body);
+      return true;
+    }
+    if (needsSeparation) {
+      out(' '); // ' '
+    }
+    visit(body);
+    return false;
+  }
+
+  void blockOutWithoutBraces(Node node) {
+    if (node is Block) {
+      Block block = node;
+      block.statements.forEach(blockOutWithoutBraces);
+    } else {
+      visit(node);
+    }
+  }
+
+  int blockOut(Block node) {
+    out('{'); // '{'
+    node.statements.forEach(blockOutWithoutBraces);
+    out('}'); // '}'
+    int closingPosition = charCount - 1;
+    return closingPosition;
+  }
+
+  @override
+  void visitBlock(Block block) {
+    blockOut(block);
+  }
+
+  @override
+  void visitExpressionStatement(ExpressionStatement node) {
+    visitNestedExpression(node.expression, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: true);
+    outSemicolonLn();
+  }
+
+  @override
+  void visitEmptyStatement(EmptyStatement node) {
+    out(';'); // ';'
+  }
+
+  void ifOut(If node) {
+    Statement then = unwrapBlockIfSingleStatement(node.then);
+    Statement elsePart = node.otherwise;
+    bool hasElse = node.hasElse;
+
+    out('if('); // 'if('
+    visitNestedExpression(node.condition, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out(')'); // ')'
+    blockBody(then, needsSeparation: false);
+    if (hasElse) {
+      out('else'); // 'else'
+      if (elsePart is If) {
+        pendingSpace = true;
+        ifOut(elsePart);
+      } else {
+        blockBody(unwrapBlockIfSingleStatement(elsePart),
+            needsSeparation: true);
+      }
+    }
+  }
+
+  @override
+  void visitIf(If node) {
+    ifOut(node);
+  }
+
+  @override
+  void visitFor(For loop) {
+    out('for('); // 'for('
+    if (loop.init != null) {
+      visitNestedExpression(loop.init, EXPRESSION,
+          newInForInit: true, newAtStatementBegin: false);
+    }
+    out(';'); // ';'
+    if (loop.condition != null) {
+      visitNestedExpression(loop.condition, EXPRESSION,
+          newInForInit: false, newAtStatementBegin: false);
+    }
+    out(';'); // ';'
+    if (loop.update != null) {
+      visitNestedExpression(loop.update, EXPRESSION,
+          newInForInit: false, newAtStatementBegin: false);
+    }
+    out(')'); // ')'
+    blockBody(unwrapBlockIfSingleStatement(loop.body), needsSeparation: false);
+  }
+
+  @override
+  void visitForIn(ForIn loop) {
+    out('for('); // 'for('
+    visitNestedExpression(loop.leftHandSide, EXPRESSION,
+        newInForInit: true, newAtStatementBegin: false);
+    out(' in'); // ' in'
+    pendingSpace = true;
+    visitNestedExpression(loop.object, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out(')'); // ')'
+    blockBody(unwrapBlockIfSingleStatement(loop.body), needsSeparation: false);
+  }
+
+  @override
+  void visitWhile(While loop) {
+    out('while('); // 'while('
+    visitNestedExpression(loop.condition, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out(')'); // ')'
+    blockBody(unwrapBlockIfSingleStatement(loop.body), needsSeparation: false);
+  }
+
+  @override
+  void visitDo(Do loop) {
+    out('do'); // 'do'
+    if (blockBody(unwrapBlockIfSingleStatement(loop.body),
+        needsSeparation: true)) {}
+    out('while('); // 'while('
+    visitNestedExpression(loop.condition, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out(')'); // ')'
+    outSemicolonLn();
+  }
+
+  @override
+  void visitContinue(Continue node) {
+    if (node.targetLabel == null) {
+      out('continue'); // 'continue'
+    } else {
+      out('continue ${node.targetLabel}'); // 'continue ${node.targetLabel}'
+    }
+    outSemicolonLn();
+  }
+
+  @override
+  void visitBreak(Break node) {
+    if (node.targetLabel == null) {
+      out('break');
+    } else {
+      out('break ${node.targetLabel}');
+    }
+    outSemicolonLn();
+  }
+
+  @override
+  void visitReturn(Return node) {
+    out('return'); // 'return'
+    if (node.value != null) {
+      pendingSpace = true;
+      visitNestedExpression(node.value, EXPRESSION,
+          newInForInit: false, newAtStatementBegin: false);
+    }
+    outSemicolonLn();
+  }
+
+  @override
+  void visitDartYield(DartYield node) {
+    if (node.hasStar) {
+      out('yield*'); // 'yield*'
+    } else {
+      out('yield'); // 'yield'
+    }
+    pendingSpace = true;
+    visitNestedExpression(node.expression, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    outSemicolonLn();
+  }
+
+  @override
+  void visitThrow(Throw node) {
+    out('throw'); // 'throw'
+    pendingSpace = true;
+    visitNestedExpression(node.expression, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    outSemicolonLn();
+  }
+
+  @override
+  void visitTry(Try node) {
+    out('try'); // 'try'
+    blockBody(node.body, needsSeparation: true);
+    if (node.catchPart != null) {
+      visit(node.catchPart);
+    }
+    if (node.finallyPart != null) {
+      out('finally'); // 'finally'
+      blockBody(node.finallyPart, needsSeparation: true);
+    }
+  }
+
+  @override
+  void visitCatch(Catch node) {
+    out('catch('); // 'catch('
+    visitNestedExpression(node.declaration, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out(')'); // ')'
+    blockBody(node.body, needsSeparation: false);
+  }
+
+  @override
+  void visitSwitch(Switch node) {
+    out('switch('); // 'switch('
+    visitNestedExpression(node.key, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out('){'); // '){
+    visitAll(node.cases);
+    out('}'); // '}'
+  }
+
+  @override
+  void visitCase(Case node) {
+    out('case'); // 'case'
+    pendingSpace = true;
+    visitNestedExpression(node.expression, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out(':'); // ':'
+    if (!node.body.statements.isEmpty) {
+      blockOutWithoutBraces(node.body);
+    }
+  }
+
+  @override
+  void visitDefault(Default node) {
+    out('default:'); // 'default:'
+    if (!node.body.statements.isEmpty) {
+      blockOutWithoutBraces(node.body);
+    }
+  }
+
+  @override
+  void visitLabeledStatement(LabeledStatement node) {
+    Statement body = unwrapBlockIfSingleStatement(node.body);
+    // `label: break label;`
+    // Does not work on IE. The statement is a nop, so replace it by an empty
+    // statement.
+    // See:
+    // https://connect.microsoft.com/IE/feedback/details/891889/parser-bugs
+    if (body is Break && body.targetLabel == node.label) {
+      visit(new EmptyStatement());
+      return;
+    }
+    out('${node.label}:');
+    blockBody(body, needsSeparation: false);
+  }
+
+  int functionOut(Fun fun, Node name, VarCollector vars) {
+    out('function'); // 'function'
+    if (name != null) {
+      out(' '); // ' '
+      // Name must be a [Decl]. Therefore only test for primary expressions.
+      visitNestedExpression(name, PRIMARY,
+          newInForInit: false, newAtStatementBegin: false);
+    }
+    out('('); // '('
+    if (fun.params != null) {
+      visitCommaSeparated(fun.params, PRIMARY,
+          newInForInit: false, newAtStatementBegin: false);
+    }
+    out(')'); // ')'
+    switch (fun.asyncModifier) {
+      case AsyncModifier.sync:
+        break;
+      case AsyncModifier.async:
+        out(' async'); // ' async'
+        break;
+      case AsyncModifier.syncStar:
+        out(' sync*'); // ' sync*'
+        break;
+      case AsyncModifier.asyncStar:
+        out(' async*'); // ' async*'
+        break;
+    }
+    int closingPosition = blockOut(fun.body);
+    return closingPosition;
+  }
+
+  @override
+  visitFunctionDeclaration(FunctionDeclaration declaration) {
+    VarCollector vars = new VarCollector();
+    vars.visitFunctionDeclaration(declaration);
+    functionOut(declaration.function, declaration.name, vars);
+  }
+
+  visitNestedExpression(Expression node, int requiredPrecedence,
+      {bool newInForInit, bool newAtStatementBegin}) {
+    bool needsParentheses = !node.isFinalized ||
+        // a - (b + c).
+        (requiredPrecedence != EXPRESSION &&
+            node.precedenceLevel < requiredPrecedence) ||
+        // for (a = (x in o); ... ; ... ) { ... }
+        (newInForInit && node is Binary && node.op == "in") ||
+        // (function() { ... })().
+        // ({a: 2, b: 3}.toString()).
+        (newAtStatementBegin &&
+            (node is NamedFunction ||
+                node is Fun ||
+                node is ObjectInitializer));
+    if (needsParentheses) {
+      inForInit = false;
+      atStatementBegin = false;
+      out('('); // '('
+      visit(node);
+      out(')'); // ')'
+    } else {
+      inForInit = newInForInit;
+      atStatementBegin = newAtStatementBegin;
+      visit(node);
+    }
+  }
+
+  @override
+  visitVariableDeclarationList(VariableDeclarationList list) {
+    out('var '); // 'var '
+    List<Node> nodes = list.declarations;
+    if (inForInit) {
+      visitCommaSeparated(nodes, ASSIGNMENT,
+          newInForInit: inForInit, newAtStatementBegin: false);
+    } else {
+      for (int i = 0; i < nodes.length; i++) {
+        Node node = nodes[i];
+        if (i > 0) {
+          atStatementBegin = false;
+          out(','); // ','
+        }
+        visitNestedExpression(node, ASSIGNMENT,
+            newInForInit: inForInit, newAtStatementBegin: false);
+      }
+    }
+  }
+
+  void _outputIncDec(String op, Expression variable, [Expression alias]) {
+    // We can eliminate the space preceding the inc/dec in some cases,
+    // but for estimation purposes we assume the worst case.
+    if (op == '+') {
+      out(' ++');
+    } else {
+      out(' --');
+    }
+    visitNestedExpression(variable, UNARY,
+        newInForInit: inForInit, newAtStatementBegin: false);
+  }
+
+  @override
+  visitAssignment(Assignment assignment) {
+    /// To print assignments like `a = a + 1` and `a = a + b` compactly as
+    /// `++a` and `a += b` in the face of [DeferredExpression]s we detect the
+    /// pattern of the undeferred assignment.
+    String op = assignment.op;
+    Node leftHandSide = assignment.leftHandSide;
+    Node rightHandSide = assignment.value;
+    if ((op == '+' || op == '-') &&
+        leftHandSide is VariableUse &&
+        rightHandSide is LiteralNumber &&
+        rightHandSide.value == "1") {
+      // Output 'a += 1' as '++a' and 'a -= 1' as '--a'.
+      _outputIncDec(op, assignment.leftHandSide);
+      return;
+    }
+    if (!assignment.isCompound &&
+        leftHandSide is VariableUse &&
+        rightHandSide is Binary) {
+      Node rLeft = rightHandSide.left;
+      Node rRight = rightHandSide.right;
+      String op = rightHandSide.op;
+      if (op == '+' ||
+          op == '-' ||
+          op == '/' ||
+          op == '*' ||
+          op == '%' ||
+          op == '^' ||
+          op == '&' ||
+          op == '|') {
+        if (rLeft is VariableUse && rLeft.name == leftHandSide.name) {
+          // Output 'a = a + 1' as '++a' and 'a = a - 1' as '--a'.
+          if ((op == '+' || op == '-') &&
+              rRight is LiteralNumber &&
+              rRight.value == "1") {
+            _outputIncDec(op, assignment.leftHandSide, rightHandSide.left);
+            return;
+          }
+          // Output 'a = a + b' as 'a += b'.
+          visitNestedExpression(assignment.leftHandSide, CALL,
+              newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
+          assert(op.length == 1);
+          out('$op='); // '$op='
+          visitNestedExpression(rRight, ASSIGNMENT,
+              newInForInit: inForInit, newAtStatementBegin: false);
+          return;
+        }
+      }
+    }
+    visitNestedExpression(assignment.leftHandSide, CALL,
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
+    if (assignment.value != null) {
+      if (op != null) out(op);
+      out('='); // '='
+      visitNestedExpression(assignment.value, ASSIGNMENT,
+          newInForInit: inForInit, newAtStatementBegin: false);
+    }
+  }
+
+  @override
+  visitVariableInitialization(VariableInitialization initialization) {
+    visitAssignment(initialization);
+  }
+
+  @override
+  visitConditional(Conditional cond) {
+    visitNestedExpression(cond.condition, LOGICAL_OR,
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
+    out('?'); // '?'
+    // The then part is allowed to have an 'in'.
+    visitNestedExpression(cond.then, ASSIGNMENT,
+        newInForInit: false, newAtStatementBegin: false);
+    out(':'); // ':'
+    visitNestedExpression(cond.otherwise, ASSIGNMENT,
+        newInForInit: inForInit, newAtStatementBegin: false);
+  }
+
+  @override
+  visitNew(New node) {
+    out('new'); // 'new'
+    visitNestedExpression(node.target, LEFT_HAND_SIDE,
+        newInForInit: inForInit, newAtStatementBegin: false);
+    out('('); // '('
+    visitCommaSeparated(node.arguments, ASSIGNMENT,
+        newInForInit: false, newAtStatementBegin: false);
+    out(')'); // ')'
+  }
+
+  @override
+  visitCall(Call call) {
+    visitNestedExpression(call.target, CALL,
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
+    out('('); // '('
+    visitCommaSeparated(call.arguments, ASSIGNMENT,
+        newInForInit: false, newAtStatementBegin: false);
+    out(')'); // ')'
+  }
+
+  @override
+  void visitBinary(Binary binary) {
+    Expression left = binary.left;
+    Expression right = binary.right;
+    String op = binary.op;
+    int leftPrecedenceRequirement;
+    int rightPrecedenceRequirement;
+    switch (op) {
+      case ',':
+        //  x, (y, z) <=> (x, y), z.
+        leftPrecedenceRequirement = EXPRESSION;
+        rightPrecedenceRequirement = EXPRESSION;
+        break;
+      case "||":
+        leftPrecedenceRequirement = LOGICAL_OR;
+        // x || (y || z) <=> (x || y) || z.
+        rightPrecedenceRequirement = LOGICAL_OR;
+        break;
+      case "&&":
+        leftPrecedenceRequirement = LOGICAL_AND;
+        // x && (y && z) <=> (x && y) && z.
+        rightPrecedenceRequirement = LOGICAL_AND;
+        break;
+      case "|":
+        leftPrecedenceRequirement = BIT_OR;
+        // x | (y | z) <=> (x | y) | z.
+        rightPrecedenceRequirement = BIT_OR;
+        break;
+      case "^":
+        leftPrecedenceRequirement = BIT_XOR;
+        // x ^ (y ^ z) <=> (x ^ y) ^ z.
+        rightPrecedenceRequirement = BIT_XOR;
+        break;
+      case "&":
+        leftPrecedenceRequirement = BIT_AND;
+        // x & (y & z) <=> (x & y) & z.
+        rightPrecedenceRequirement = BIT_AND;
+        break;
+      case "==":
+      case "!=":
+      case "===":
+      case "!==":
+        leftPrecedenceRequirement = EQUALITY;
+        rightPrecedenceRequirement = RELATIONAL;
+        break;
+      case "<":
+      case ">":
+      case "<=":
+      case ">=":
+      case "instanceof":
+      case "in":
+        leftPrecedenceRequirement = RELATIONAL;
+        rightPrecedenceRequirement = SHIFT;
+        break;
+      case ">>":
+      case "<<":
+      case ">>>":
+        leftPrecedenceRequirement = SHIFT;
+        rightPrecedenceRequirement = ADDITIVE;
+        break;
+      case "+":
+      case "-":
+        leftPrecedenceRequirement = ADDITIVE;
+        // We cannot remove parenthesis for "+" because
+        //   x + (y + z) <!=> (x + y) + z:
+        // Example:
+        //   "a" + (1 + 2) => "a3";
+        //   ("a" + 1) + 2 => "a12";
+        rightPrecedenceRequirement = MULTIPLICATIVE;
+        break;
+      case "*":
+      case "/":
+      case "%":
+        leftPrecedenceRequirement = MULTIPLICATIVE;
+        // We cannot remove parenthesis for "*" because of precision issues.
+        rightPrecedenceRequirement = UNARY;
+        break;
+      default:
+        throw UnsupportedError("Forgot operator: $op");
+    }
+
+    visitNestedExpression(left, leftPrecedenceRequirement,
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
+
+    if (op == "in" || op == "instanceof") {
+      // There are cases where the space is not required but without further
+      // analysis we cannot know.
+      out(' $op '); // ' $op '
+    } else {
+      out(op); // '$op'
+    }
+    visitNestedExpression(right, rightPrecedenceRequirement,
+        newInForInit: inForInit, newAtStatementBegin: false);
+  }
+
+  @override
+  void visitPrefix(Prefix unary) {
+    String op = unary.op;
+    switch (op) {
+      case "delete":
+      case "void":
+      case "typeof":
+      case "+":
+      case "++":
+      case "-":
+      case "--":
+        // We may be able to eliminate the space in some cases, but for
+        // estimation we assume the worst case.
+        out('$op '); // '$op '
+        break;
+      default:
+        out('$op'); // '$op'
+    }
+    visitNestedExpression(unary.argument, UNARY,
+        newInForInit: inForInit, newAtStatementBegin: false);
+  }
+
+  @override
+  void visitPostfix(Postfix postfix) {
+    visitNestedExpression(postfix.argument, CALL,
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
+    out(postfix.op); // '${postfix.op}'
+  }
+
+  @override
+  void visitVariableUse(VariableUse ref) {
+    // For simplicity and stability we use a constant name size estimate.
+    // In production this is:
+    // '${localNamer.getName(ref.name)'
+    out(sizeEstimate(ref));
+  }
+
+  @override
+  void visitThis(This node) {
+    out('this'); // 'this'
+  }
+
+  @override
+  void visitVariableDeclaration(VariableDeclaration decl) {
+    // '${localNamer.getName(decl.name)'
+    out(sizeEstimate(decl));
+  }
+
+  @override
+  void visitParameter(Parameter param) {
+    // For simplicity and stability we use a constant name size estimate.
+    // In production this is:
+    // '${localNamer.getName(param.name)'
+    out(sizeEstimate(param));
+  }
+
+  bool isDigit(int charCode) {
+    return charCodes.$0 <= charCode && charCode <= charCodes.$9;
+  }
+
+  bool isValidJavaScriptId(String field) {
+    if (field.length < 3) return false;
+    // Ignore the leading and trailing string-delimiter.
+    for (int i = 1; i < field.length - 1; i++) {
+      // TODO(floitsch): allow more characters.
+      int charCode = field.codeUnitAt(i);
+      if (!(charCodes.$a <= charCode && charCode <= charCodes.$z ||
+          charCodes.$A <= charCode && charCode <= charCodes.$Z ||
+          charCode == charCodes.$$ ||
+          charCode == charCodes.$_ ||
+          i != 1 && isDigit(charCode))) {
+        return false;
+      }
+    }
+    // TODO(floitsch): normally we should also check that the field is not a
+    // reserved word.  We don't generate fields with reserved word names except
+    // for 'super'.
+    if (field == '"super"') return false;
+    if (field == '"catch"') return false;
+    return true;
+  }
+
+  @override
+  void visitAccess(PropertyAccess access) {
+    visitNestedExpression(access.receiver, CALL,
+        newInForInit: inForInit, newAtStatementBegin: atStatementBegin);
+    Node selector = access.selector;
+    if (selector is LiteralString) {
+      String fieldWithQuotes = selector.value;
+      if (isValidJavaScriptId(fieldWithQuotes)) {
+        if (access.receiver is LiteralNumber) {
+          // We can eliminate the space in some cases, but for simplicity we
+          // always assume it is necessary.
+          out(' '); // ' '
+        }
+
+        // '.${fieldWithQuotes.substring(1, fieldWithQuotes.length - 1)}'
+        out('.${fieldWithQuotes.substring(1, fieldWithQuotes.length - 1)}');
+        return;
+      }
+    } else if (selector is Name) {
+      Node receiver = access.receiver;
+      if (receiver is LiteralNumber) {
+        // We can eliminate the space in some cases, but for simplicity we
+        // always assume it is necessary.
+        out(' '); // ' '
+      }
+      out('.'); // '.'
+      selector.accept(this);
+      return;
+    }
+    out('['); // '['
+    visitNestedExpression(access.selector, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out(']'); // ']
+  }
+
+  @override
+  void visitNamedFunction(NamedFunction namedFunction) {
+    VarCollector vars = new VarCollector();
+    vars.visitNamedFunction(namedFunction);
+    functionOut(namedFunction.function, namedFunction.name, vars);
+  }
+
+  @override
+  void visitFun(Fun fun) {
+    VarCollector vars = new VarCollector();
+    vars.visitFun(fun);
+    functionOut(fun, null, vars);
+  }
+
+  @override
+  visitDeferredExpression(DeferredExpression node) {
+    if (node.isFinalized) {
+      // Continue printing with the expression value.
+      assert(node.precedenceLevel == node.value.precedenceLevel);
+      node.value.accept(this);
+    } else {
+      out(sizeEstimate(node));
+    }
+  }
+
+  outputNumberWithRequiredWhitespace(String number) {
+    int charCode = number.codeUnitAt(0);
+    if (charCode == charCodes.$MINUS) {
+      // We can eliminate the space in some cases, but for simplicity we
+      // always assume it is necessary.
+      out(' ');
+    }
+    out(number); // '${number}'
+  }
+
+  @override
+  visitDeferredNumber(DeferredNumber node) {
+    if (node.isFinalized) {
+      outputNumberWithRequiredWhitespace("${node.value}");
+    } else {
+      out(sizeEstimate(node));
+    }
+  }
+
+  @override
+  visitDeferredString(DeferredString node) {
+    if (node.isFinalized) {
+      out(node.value);
+    } else {
+      out(sizeEstimate(node));
+    }
+  }
+
+  @override
+  visitLiteralBool(LiteralBool node) {
+    out(node.value ? '!0' : '!1');
+  }
+
+  @override
+  void visitLiteralString(LiteralString node) {
+    if (node.isFinalized) {
+      out(node.value); // '${node.value}'
+    } else {
+      out(sizeEstimate(node));
+    }
+  }
+
+  @override
+  visitStringConcatenation(StringConcatenation node) {
+    node.visitChildren(this);
+  }
+
+  @override
+  visitName(Name node) {
+    // For simplicity and stability we use a constant name size estimate.
+    // In production this is:
+    // '${options.renamerForNames(node)}'
+    out(sizeEstimate(node));
+  }
+
+  @override
+  visitParentheses(Parentheses node) {
+    out('('); // '('
+    visitNestedExpression(node.enclosed, EXPRESSION,
+        newInForInit: false, newAtStatementBegin: false);
+    out(')'); // ')'
+  }
+
+  @override
+  visitLiteralNumber(LiteralNumber node) {
+    outputNumberWithRequiredWhitespace(node.value);
+  }
+
+  @override
+  void visitLiteralNull(LiteralNull node) {
+    out('null'); // 'null'
+  }
+
+  @override
+  void visitArrayInitializer(ArrayInitializer node) {
+    out('['); // '['
+    List<Expression> elements = node.elements;
+    for (int i = 0; i < elements.length; i++) {
+      Expression element = elements[i];
+      if (element is ArrayHole) {
+        // Note that array holes must have a trailing "," even if they are
+        // in last position. Otherwise `[,]` (having length 1) would become
+        // equal to `[]` (the empty array)
+        // and [1,,] (array with 1 and a hole) would become [1,] = [1].
+        out(','); // ','
+        continue;
+      }
+      visitNestedExpression(element, ASSIGNMENT,
+          newInForInit: false, newAtStatementBegin: false);
+      // We can skip the trailing "," for the last element (since it's not
+      // an array hole).
+      if (i != elements.length - 1) out(','); // ','
+    }
+    out(']'); // ']'
+  }
+
+  @override
+  void visitArrayHole(ArrayHole node) {
+    throw UnsupportedError("Unreachable");
+  }
+
+  @override
+  void visitObjectInitializer(ObjectInitializer node) {
+    // Print all the properties on one line until we see a function-valued
+    // property.  Ideally, we would use a proper pretty-printer to make the
+    // decision based on layout.
+    bool exitOneLinerMode(Expression value) {
+      return value is Fun ||
+          value is ArrayInitializer && value.elements.any((e) => e is Fun);
+    }
+
+    bool isOneLiner = true;
+    List<Property> properties = node.properties;
+    out('{'); // '{'
+    for (int i = 0; i < properties.length; i++) {
+      Node value = properties[i].value;
+      if (isOneLiner && exitOneLinerMode(value)) isOneLiner = false;
+      if (i != 0) {
+        out(','); // ','
+      }
+      if (!isOneLiner) {
+        forceLine();
+      }
+      visit(properties[i]);
+    }
+    out('}'); // '}'
+  }
+
+  @override
+  void visitProperty(Property node) {
+    Node name = node.name;
+    if (name is LiteralString) {
+      String text = name.value;
+      if (isValidJavaScriptId(text)) {
+        // '${text.substring(1, text.length - 1)}
+        out('${text.substring(1, text.length - 1)}');
+      } else {
+        out(text); // '$text'
+      }
+    } else if (name is Name) {
+      node.name.accept(this);
+    } else if (name is DeferredExpression) {
+      out(sizeEstimate(name));
+    } else {
+      assert(name is LiteralNumber);
+      LiteralNumber nameNumber = node.name;
+      out(nameNumber.value); // '${nameNumber.value}'
+    }
+    out(':'); // ':'
+    visitNestedExpression(node.value, ASSIGNMENT,
+        newInForInit: false, newAtStatementBegin: false);
+  }
+
+  @override
+  void visitRegExpLiteral(RegExpLiteral node) {
+    out(node.pattern); // '${node.pattern}'
+  }
+
+  @override
+  void visitLiteralExpression(LiteralExpression node) {
+    String template = node.template;
+    List<Expression> inputs = node.inputs;
+
+    List<String> parts = template.split('#');
+    int inputsLength = inputs == null ? 0 : inputs.length;
+    if (parts.length != inputsLength + 1) {
+      throw UnsupportedError('Wrong number of arguments for JS: $template');
+    }
+    // Code that uses JS must take care of operator precedences, and
+    // put parenthesis if needed.
+    out(parts[0]); // '${parts[0]}'
+    for (int i = 0; i < inputsLength; i++) {
+      visit(inputs[i]);
+      out(parts[i + 1]); // '${parts[i + 1]}'
+    }
+  }
+
+  @override
+  void visitLiteralStatement(LiteralStatement node) {
+    out(node.code); // '${node.code}'
+  }
+
+  void visitInterpolatedNode(InterpolatedNode node) {
+    throw UnsupportedError('InterpolatedStatements are not supported');
+  }
+
+  @override
+  void visitInterpolatedExpression(InterpolatedExpression node) =>
+      visitInterpolatedNode(node);
+
+  @override
+  void visitInterpolatedLiteral(InterpolatedLiteral node) =>
+      visitInterpolatedNode(node);
+
+  @override
+  void visitInterpolatedParameter(InterpolatedParameter node) =>
+      visitInterpolatedNode(node);
+
+  @override
+  void visitInterpolatedSelector(InterpolatedSelector node) =>
+      visitInterpolatedNode(node);
+
+  @override
+  void visitInterpolatedStatement(InterpolatedStatement node) {
+    throw UnsupportedError('InterpolatedStatements are not supported');
+  }
+
+  @override
+  void visitInterpolatedDeclaration(InterpolatedDeclaration node) {
+    visitInterpolatedNode(node);
+  }
+
+  @override
+  void visitComment(Comment node) {
+    // We assume output is compressed and thus do not output comments.
+  }
+
+  @override
+  void visitAwait(Await node) {
+    out('await '); // 'await '
+    visit(node.expression);
+  }
+}
+
+int EstimateSize(Node node) {
+  var estimator = SizeEstimator();
+  estimator.visit(node);
+  return estimator.charCount;
+}
diff --git a/pkg/compiler/lib/src/js_backend/namer_names.dart b/pkg/compiler/lib/src/js_backend/namer_names.dart
index dd8c765..ce57087 100644
--- a/pkg/compiler/lib/src/js_backend/namer_names.dart
+++ b/pkg/compiler/lib/src/js_backend/namer_names.dart
@@ -83,6 +83,9 @@
   int get hashCode => base.hashCode * 13 + prefix.hashCode;
 
   @override
+  bool get isFinalized => prefix.isFinalized && base.isFinalized;
+
+  @override
   int compareTo(jsAst.Name other) {
     _NamerName otherNamerName;
     if (other is ModularName) {
@@ -209,6 +212,7 @@
 
   TokenName(this._scope, this.key);
 
+  @override
   bool get isFinalized => _name != null;
 
   @override
@@ -276,6 +280,9 @@
   }
 
   @override
+  bool get isFinalized => _target.isFinalized;
+
+  @override
   bool operator ==(other) => _target == other;
 
   @override
diff --git a/pkg/compiler/lib/src/js_backend/string_reference.dart b/pkg/compiler/lib/src/js_backend/string_reference.dart
index 95fa795..b8c41aa 100644
--- a/pkg/compiler/lib/src/js_backend/string_reference.dart
+++ b/pkg/compiler/lib/src/js_backend/string_reference.dart
@@ -115,16 +115,19 @@
   }
 
   set value(js.Expression value) {
-    assert(_value == null && value != null);
+    assert(!isFinalized && value != null);
     _value = value;
   }
 
   @override
   js.Expression get value {
-    assert(_value != null, 'StringReference is unassigned');
+    assert(isFinalized, 'StringReference is unassigned');
     return _value;
   }
 
+  @override
+  bool get isFinalized => _value != null;
+
   // Precedence will be CALL or LEFT_HAND_SIDE depending on what expression the
   // reference is resolved to.
   @override
@@ -139,7 +142,7 @@
   }
 
   @override
-  Iterable<js.Node> get containedNodes => _value == null ? const [] : [_value];
+  Iterable<js.Node> get containedNodes => isFinalized ? [_value] : const [];
 }
 
 /// A [StringReferenceResource] is a deferred JavaScript expression determined
@@ -159,13 +162,13 @@
   StringReferenceResource._(this._value, this.sourceInformation);
 
   set value(js.Expression value) {
-    assert(_value == null && value != null);
+    assert(!isFinalized && value != null);
     _value = value;
   }
 
   @override
   js.Expression get value {
-    assert(_value != null, 'StringReferenceResource is unassigned');
+    assert(isFinalized, 'StringReferenceResource is unassigned');
     return _value;
   }
 
@@ -173,6 +176,9 @@
   int get precedenceLevel => value.precedenceLevel;
 
   @override
+  bool get isFinalized => _value != null;
+
+  @override
   StringReferenceResource withSourceInformation(
       js.JavaScriptNodeSourceInformation newSourceInformation) {
     if (newSourceInformation == sourceInformation) return this;
@@ -181,7 +187,7 @@
   }
 
   @override
-  Iterable<js.Node> get containedNodes => _value == null ? const [] : [_value];
+  Iterable<js.Node> get containedNodes => isFinalized ? [_value] : const [];
 
   @override
   void visitChildren<T>(js.NodeVisitor<T> visitor) {
diff --git a/pkg/compiler/lib/src/js_backend/type_reference.dart b/pkg/compiler/lib/src/js_backend/type_reference.dart
index de1a5f3..f33591d 100644
--- a/pkg/compiler/lib/src/js_backend/type_reference.dart
+++ b/pkg/compiler/lib/src/js_backend/type_reference.dart
@@ -132,16 +132,19 @@
   }
 
   set value(js.Expression value) {
-    assert(_value == null && value != null);
+    assert(!isFinalized && value != null);
     _value = value;
   }
 
   @override
   js.Expression get value {
-    assert(_value != null, 'TypeReference is unassigned');
+    assert(isFinalized, 'TypeReference is unassigned');
     return _value;
   }
 
+  @override
+  bool get isFinalized => _value != null;
+
   // Precedence will be CALL or LEFT_HAND_SIDE depending on what expression the
   // reference is resolved to.
   @override
@@ -156,7 +159,7 @@
   }
 
   @override
-  Iterable<js.Node> get containedNodes => _value == null ? const [] : [_value];
+  Iterable<js.Node> get containedNodes => isFinalized ? [_value] : const [];
 }
 
 /// A [TypeReferenceResource] is a deferred JavaScript expression determined by
@@ -176,17 +179,20 @@
   TypeReferenceResource._(this._value, this.sourceInformation);
 
   set value(js.Expression value) {
-    assert(_value == null && value != null);
+    assert(!isFinalized && value != null);
     _value = value;
   }
 
   @override
   js.Expression get value {
-    assert(_value != null, 'TypeReferenceResource is unassigned');
+    assert(isFinalized, 'TypeReferenceResource is unassigned');
     return _value;
   }
 
   @override
+  bool get isFinalized => _value != null;
+
+  @override
   int get precedenceLevel => value.precedenceLevel;
 
   @override
@@ -198,7 +204,7 @@
   }
 
   @override
-  Iterable<js.Node> get containedNodes => _value == null ? const [] : [_value];
+  Iterable<js.Node> get containedNodes => isFinalized ? [_value] : const [];
 
   @override
   void visitChildren<T>(js.NodeVisitor<T> visitor) {
diff --git a/pkg/compiler/lib/src/js_emitter/metadata_collector.dart b/pkg/compiler/lib/src/js_emitter/metadata_collector.dart
index 8066ff1..6fac2f9 100644
--- a/pkg/compiler/lib/src/js_emitter/metadata_collector.dart
+++ b/pkg/compiler/lib/src/js_emitter/metadata_collector.dart
@@ -41,15 +41,16 @@
   void markSeen(jsAst.TokenCounter visitor);
 }
 
-class _BoundMetadataEntry extends _MetadataEntry {
+class BoundMetadataEntry extends _MetadataEntry {
   int _value = -1;
   @override
   int _rc = 0;
   @override
   final jsAst.Expression entry;
 
-  _BoundMetadataEntry(this.entry);
+  BoundMetadataEntry(this.entry);
 
+  @override
   bool get isFinalized => _value != -1;
 
   finalize(int value) {
@@ -75,7 +76,7 @@
   int compareTo(covariant _MetadataEntry other) => other._rc - this._rc;
 
   @override
-  String toString() => '_BoundMetadataEntry($hashCode,rc=$_rc,_value=$_value)';
+  String toString() => 'BoundMetadataEntry($hashCode,rc=$_rc,_value=$_value)';
 }
 
 class _MetadataList extends jsAst.DeferredExpression {
@@ -114,8 +115,8 @@
   }
 
   /// A map used to canonicalize the entries of metadata.
-  Map<OutputUnit, Map<String, _BoundMetadataEntry>> _metadataMap =
-      <OutputUnit, Map<String, _BoundMetadataEntry>>{};
+  Map<OutputUnit, Map<String, BoundMetadataEntry>> _metadataMap =
+      <OutputUnit, Map<String, BoundMetadataEntry>>{};
 
   /// A map with a token for a lists of JS expressions, one token for each
   /// output unit. Once finalized, the entries represent types including
@@ -128,8 +129,8 @@
   }
 
   /// A map used to canonicalize the entries of types.
-  Map<OutputUnit, Map<DartType, _BoundMetadataEntry>> _typesMap =
-      <OutputUnit, Map<DartType, _BoundMetadataEntry>>{};
+  Map<OutputUnit, Map<DartType, BoundMetadataEntry>> _typesMap =
+      <OutputUnit, Map<DartType, BoundMetadataEntry>>{};
 
   MetadataCollector(this._options, this.reporter, this._emitter,
       this._rtiRecipeEncoder, this._elementEnvironment);
@@ -165,9 +166,9 @@
     String printed = jsAst.prettyPrint(node,
         enableMinification: _options.enableMinification,
         renamerForNames: nameToKey);
-    _metadataMap[outputUnit] ??= new Map<String, _BoundMetadataEntry>();
+    _metadataMap[outputUnit] ??= new Map<String, BoundMetadataEntry>();
     return _metadataMap[outputUnit].putIfAbsent(printed, () {
-      return new _BoundMetadataEntry(node);
+      return new BoundMetadataEntry(node);
     });
   }
 
@@ -177,36 +178,36 @@
   }
 
   jsAst.Expression addTypeInOutputUnit(DartType type, OutputUnit outputUnit) {
-    _typesMap[outputUnit] ??= new Map<DartType, _BoundMetadataEntry>();
+    _typesMap[outputUnit] ??= new Map<DartType, BoundMetadataEntry>();
     return _typesMap[outputUnit].putIfAbsent(type, () {
-      return new _BoundMetadataEntry(_computeTypeRepresentationNewRti(type));
+      return new BoundMetadataEntry(_computeTypeRepresentationNewRti(type));
     });
   }
 
   @override
   void finalizeTokens() {
-    void countTokensInTypes(Iterable<_BoundMetadataEntry> entries) {
+    void countTokensInTypes(Iterable<BoundMetadataEntry> entries) {
       jsAst.TokenCounter counter = new jsAst.TokenCounter();
       entries
-          .where((_BoundMetadataEntry e) => e._rc > 0)
-          .map((_BoundMetadataEntry e) => e.entry)
+          .where((BoundMetadataEntry e) => e._rc > 0)
+          .map((BoundMetadataEntry e) => e.entry)
           .forEach(counter.countTokens);
     }
 
-    jsAst.ArrayInitializer finalizeMap(Map<dynamic, _BoundMetadataEntry> map) {
-      bool isUsed(_BoundMetadataEntry entry) => entry.isUsed;
-      List<_BoundMetadataEntry> entries = map.values.where(isUsed).toList();
+    jsAst.ArrayInitializer finalizeMap(Map<dynamic, BoundMetadataEntry> map) {
+      bool isUsed(BoundMetadataEntry entry) => entry.isUsed;
+      List<BoundMetadataEntry> entries = map.values.where(isUsed).toList();
       entries.sort();
 
       // TODO(herhut): Bucket entries by index length and use a stable
       //               distribution within buckets.
       int count = 0;
-      for (_BoundMetadataEntry entry in entries) {
+      for (BoundMetadataEntry entry in entries) {
         entry.finalize(count++);
       }
 
       List<jsAst.Node> values =
-          entries.map((_BoundMetadataEntry e) => e.entry).toList();
+          entries.map((BoundMetadataEntry e) => e.entry).toList();
 
       return new jsAst.ArrayInitializer(values);
     }
diff --git a/pkg/compiler/test/js/debug_size_estimator.dart b/pkg/compiler/test/js/debug_size_estimator.dart
new file mode 100644
index 0000000..86b528c
--- /dev/null
+++ b/pkg/compiler/test/js/debug_size_estimator.dart
@@ -0,0 +1,18 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+import 'package:compiler/src/js/size_estimator.dart';
+
+/// This class is supposed to be identical to [SizeEstimator] with the sole
+/// difference that it builds up strings to help debug estimates.
+class DebugSizeEstimator extends SizeEstimator {
+  StringBuffer resultBuffer = StringBuffer();
+  String get resultString => resultBuffer.toString();
+
+  @override
+  void emit(String s) {
+    resultBuffer.write(s);
+    super.emit(s);
+  }
+}
diff --git a/pkg/compiler/test/js/js_size_estimator_test.dart b/pkg/compiler/test/js/js_size_estimator_test.dart
new file mode 100644
index 0000000..cb5ce76
--- /dev/null
+++ b/pkg/compiler/test/js/js_size_estimator_test.dart
@@ -0,0 +1,125 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+// @dart = 2.7
+
+import 'dart:convert' as json;
+import 'dart:io';
+
+import 'package:expect/expect.dart';
+import 'package:compiler/src/js/js.dart';
+import 'package:compiler/src/js/size_estimator.dart';
+import 'debug_size_estimator.dart';
+
+const String expressionsKey = 'expressions';
+const String statementsKey = 'statements';
+const String originalKey = 'original';
+const String expectedKey = 'expected';
+const String minifiedKey = 'minified';
+
+DebugSizeEstimator debugSizeEstimator(Node node) {
+  DebugSizeEstimator debugSizeEstimator = DebugSizeEstimator();
+  debugSizeEstimator.visit(node);
+
+  // Always verify the actual results from the [SizeEstimator].
+  // This is the actual test, though DebugSizeEstimator is pretty trivial.
+  int actualEstimate = EstimateSize(node);
+  Expect.equals(actualEstimate, debugSizeEstimator.charCount);
+  return debugSizeEstimator;
+}
+
+abstract class TestSuite {
+  String get key;
+  Node parse(String testCase);
+
+  String generateExpected(Node node) {
+    return debugSizeEstimator(node).resultString;
+  }
+
+  String generateMinified(Node node) {
+    return prettyPrint(node,
+        enableMinification: true,
+        preferSemicolonToNewlineInMinifiedOutput: true);
+  }
+
+  Map<String, String> goldenTestCase(goldenTestCaseJson) {
+    String original = goldenTestCaseJson[originalKey];
+    Node node = parse(original);
+    return {
+      originalKey: original,
+      expectedKey: generateExpected(node),
+      minifiedKey: generateMinified(node),
+    };
+  }
+
+  List<Map<String, String>> regenerateGoldens(currentGoldensJson) {
+    List<Map<String, String>> newGoldens = [];
+    for (var testCaseJson in currentGoldensJson) {
+      newGoldens.add(goldenTestCase(testCaseJson));
+    }
+    return newGoldens;
+  }
+
+  void verifyGoldens(goldensJson) {
+    for (var goldenTestCase in goldensJson) {
+      test(goldenTestCase[originalKey], goldenTestCase[expectedKey]);
+    }
+  }
+
+  void test(String original, String expected) {
+    var debugResults = debugSizeEstimator(parse(original));
+    Expect.equals(expected, debugResults.resultString);
+    Expect.equals(expected.length, debugResults.charCount);
+  }
+}
+
+class ExpressionTestSuite extends TestSuite {
+  @override
+  String get key => expressionsKey;
+
+  @override
+  Node parse(String expression) => js(expression);
+}
+
+class StatementTestSuite extends TestSuite {
+  @override
+  String get key => statementsKey;
+
+  @override
+  Node parse(String statement) => js.statement(statement);
+}
+
+List<TestSuite> testSuites = [
+  ExpressionTestSuite(),
+  StatementTestSuite(),
+];
+
+void generateGoldens(currentGoldens,
+    Map<String, List<Map<String, String>>> newGoldens, List<TestSuite> suites) {
+  for (var suite in suites) {
+    newGoldens[suite.key] = suite.regenerateGoldens(currentGoldens[suite.key]);
+  }
+}
+
+void testGoldens(currentGoldens, List<TestSuite> suites) {
+  for (var suite in suites) {
+    suite.verifyGoldens(currentGoldens[suite.key]);
+  }
+}
+
+void main(List<String> args) {
+  var goldenFile = 'pkg/compiler/test/js/size_estimator_expectations.json';
+  bool generate = args.contains('-g');
+  var currentGoldens = json.jsonDecode(File(goldenFile).readAsStringSync());
+
+  if (generate) {
+    Map<String, List<Map<String, String>>> newGoldens = {};
+    generateGoldens(currentGoldens, newGoldens, testSuites);
+
+    File(goldenFile).writeAsStringSync(
+        json.JsonEncoder.withIndent('  ').convert(newGoldens));
+  } else {
+    testGoldens(currentGoldens, testSuites);
+  }
+}
diff --git a/pkg/compiler/test/js/size_estimator_expectations.json b/pkg/compiler/test/js/size_estimator_expectations.json
new file mode 100644
index 0000000..57b911f
--- /dev/null
+++ b/pkg/compiler/test/js/size_estimator_expectations.json
@@ -0,0 +1,196 @@
+{
+  "expressions": [
+    {
+      "original": "1",
+      "expected": "1",
+      "minified": "1"
+    },
+    {
+      "original": "123456789",
+      "expected": "123456789",
+      "minified": "123456789"
+    },
+    {
+      "original": "true",
+      "expected": "!0",
+      "minified": "true"
+    },
+    {
+      "original": "false",
+      "expected": "!1",
+      "minified": "false"
+    },
+    {
+      "original": "a || b",
+      "expected": "#||#",
+      "minified": "a||b"
+    },
+    {
+      "original": "(a || b) && c",
+      "expected": "(#||#)&&#",
+      "minified": "(a||b)&&c"
+    },
+    {
+      "original": "a == true ? b : c",
+      "expected": "#==!0?#:#",
+      "minified": "a==true?b:c"
+    },
+    {
+      "original": "x = a + b * c",
+      "expected": "#=#+#*#",
+      "minified": "x=a+b*c"
+    },
+    {
+      "original": "a + (b == c) + d",
+      "expected": "#+(#==#)+#",
+      "minified": "a+(b==c)+d"
+    },
+    {
+      "original": "foo(bar)",
+      "expected": "#(#)",
+      "minified": "foo(bar)"
+    },
+    {
+      "original": "foo.bar(baz)",
+      "expected": "#.bar(#)",
+      "minified": "foo.bar(baz)"
+    },
+    {
+      "original": "foo({meaning: 42})",
+      "expected": "#({meaning:42})",
+      "minified": "foo({meaning:42})"
+    },
+    {
+      "original": "x = !x",
+      "expected": "#=!#",
+      "minified": "x=!x"
+    },
+    {
+      "original": "delete foo.bar",
+      "expected": "delete #.bar",
+      "minified": "delete foo.bar"
+    },
+    {
+      "original": "x in y",
+      "expected": "# in #",
+      "minified": "x in y"
+    },
+    {
+      "original": "x instanceof y",
+      "expected": "# instanceof #",
+      "minified": "x instanceof y"
+    },
+    {
+      "original": "x &= ~mask",
+      "expected": "#&=~#",
+      "minified": "x&=~mask"
+    },
+    {
+      "original": "await x++",
+      "expected": "await #++",
+      "minified": "await x++"
+    },
+    {
+      "original": "foo[x[bar]]",
+      "expected": "#[#[#]]",
+      "minified": "foo[x[bar]]"
+    },
+    {
+      "original": "x << 5",
+      "expected": "#<<5",
+      "minified": "x<<5"
+    },
+    {
+      "original": "x = ['a', 'b', 'c']",
+      "expected": "#=['a','b','c']",
+      "minified": "x=['a','b','c']"
+    },
+    {
+      "original": "a = {'b': 1, 'c': 2}",
+      "expected": "#={b:1,c:2}",
+      "minified": "a={b:1,c:2}"
+    },
+    {
+      "original": "foo([1, 2, 3])",
+      "expected": "#([1,2,3])",
+      "minified": "foo([1,2,3])"
+    },
+    {
+      "original": "a = b = c",
+      "expected": "#=#=#",
+      "minified": "a=b=c"
+    },
+    {
+      "original": "var a = \"\"",
+      "expected": "var #=\"\"",
+      "minified": "var a=\"\""
+    }
+  ],
+  "statements": [
+    {
+      "original": "{ 1; 2; 3; }",
+      "expected": "{1;2;3;}",
+      "minified": "{1;2;3}"
+    },
+    {
+      "original": "function foo() { /a/; 1; 2; }",
+      "expected": "function #(){/a/;1;2;}",
+      "minified": "function foo(){/a/;1;2}"
+    },
+    {
+      "original": "function foo() { return function bar() { return null; } }",
+      "expected": "function #(){return function #(){return null;};}",
+      "minified": "function foo(){return function bar(){return null}}"
+    },
+    {
+      "original": "if (x == true) { bar(); }",
+      "expected": "if(#==!0)#()",
+      "minified": "if(x==true)bar()"
+    },
+    {
+      "original": "if (x > 4 && y < 5) { 1; 2; }",
+      "expected": "if(#>4&&#<5){1;2;}",
+      "minified": "if(x>4&&y<5){1;2}"
+    },
+    {
+      "original": "if (x == true) { return true; } else if (y < 3 || z > 5) { return l != null ? 'a' : 4; } else { foo(); return; }",
+      "expected": "if(#==!0)return !0;else if(#<3||#>5)return #!=null?'a':4;else{#();return;}",
+      "minified": "if(x==true)return true;else if(y<3||z>5)return l!=null?'a':4;else{foo();return}"
+    },
+    {
+      "original": "for (var a = 0; a < 10; a++) { foo(a); }",
+      "expected": "for(var #=0;#<10;#++)#(#)",
+      "minified": "for(var a=0;a<10;a++)foo(a)"
+    },
+    {
+      "original": "for (var b in c) { var e = 1; foo(e); }",
+      "expected": "for(var # in #){var #=1;#(#);}",
+      "minified": "for(var b in c){var e=1;foo(e)}"
+    },
+    {
+      "original": "while (x != null) { foo(); }",
+      "expected": "while(#!=null)#()",
+      "minified": "while(x!=null)foo()"
+    },
+    {
+      "original": "do { print(1); do while (true) ; while (false); } while (a != b);",
+      "expected": "do{#(1);do while(!0);while(!1);}while(#!=#)",
+      "minified": "do{print(1);do while(true);while(false)}while(a!=b)"
+    },
+    {
+      "original": "switch (foo) { case 'a': case 'b': bar(); break; case 'c': 1; break; default: boo(); }",
+      "expected": "switch(#){case 'a':case 'b':#();break;case 'c':1;break;default:#();}",
+      "minified": "switch(foo){case'a':case'b':bar();break;case'c':1;break;default:boo()}"
+    },
+    {
+      "original": "foo.prototype.Goo = function(a) { return a.bar(); }",
+      "expected": "#.prototype.Goo=function(#){return #.bar();}",
+      "minified": "foo.prototype.Goo=function(a){return a.bar()}"
+    },
+    {
+      "original": "try { null = 4; } catch (e) { print(e); }",
+      "expected": "try{null=4;}catch(#){#(#);}",
+      "minified": "try{null=4}catch(e){print(e)}"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index 9571c2a..5d79c5f 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -4428,6 +4428,33 @@
   js_ast.Expression _emitMethodCall(Expression receiver, Member target,
       Arguments arguments, InvocationExpression node) {
     var name = node.name.text;
+
+    /// Returns `true` when [node] represents an invocation of `List.add()` that
+    /// can be optimized.
+    ///
+    /// The optimized add operation can skip checks for a growable or modifiable
+    /// list and the element type is known to be invariant so it can skip the
+    /// type check.
+    bool isNativeListInvariantAdd(InvocationExpression node) {
+      if (node is MethodInvocation &&
+          node.isInvariant &&
+          node.name.name == 'add') {
+        // The call to add is marked as invariant, so the type check on the
+        // parameter to add is not needed.
+        var receiver = node.receiver;
+        if (receiver is VariableGet && receiver.variable.isFinal) {
+          // The receiver is a final variable, so it only contains the
+          // initializer value.
+          if (receiver.variable.initializer is ListLiteral) {
+            // The initializer is a list literal, so we know the list can be
+            // grown, modified, and is represented by a JavaScript Array.
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
     if (isOperatorMethodName(name) && arguments.named.isEmpty) {
       var argLength = arguments.positional.length;
       if (argLength == 0) {
@@ -4441,6 +4468,10 @@
     var jsReceiver = _visitExpression(receiver);
     var args = _emitArgumentList(arguments, target: target);
 
+    if (isNativeListInvariantAdd(node)) {
+      return js.call('#.push(#)', [jsReceiver, args]);
+    }
+
     var isCallingDynamicField = target is Member &&
         target.hasGetter &&
         _isDynamicOrFunction(target.getterType);
diff --git a/pkg/js_ast/lib/src/nodes.dart b/pkg/js_ast/lib/src/nodes.dart
index 82cdc4f..7a9298a 100644
--- a/pkg/js_ast/lib/src/nodes.dart
+++ b/pkg/js_ast/lib/src/nodes.dart
@@ -444,6 +444,8 @@
 
   bool get isCommaOperator => false;
 
+  bool get isFinalized => true;
+
   Statement toStatement() {
     throw new UnsupportedError('toStatement');
   }
@@ -1005,6 +1007,9 @@
 
   LiteralStringFromName(this.name) : super(null);
 
+  @override
+  bool get isFinalized => name.isFinalized;
+
   String get value => '"${name.name}"';
 
   void visitChildren<T>(NodeVisitor<T> visitor) {
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index f3875f3..b76ee89 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -145,6 +145,12 @@
   /// being visited, or null.
   Element _currentClassOrExtension;
 
+  /// If an extension declaration is being visited, the decorated type of the
+  /// type appearing in the `on` clause (this is the type of `this` inside the
+  /// extension declaration).  Null if an extension declaration is not being
+  /// visited.
+  DecoratedType _currentExtendedType;
+
   /// The [DecoratedType] of the innermost list or set literal being visited, or
   /// `null` if the visitor is not inside any list or set.
   ///
@@ -792,9 +798,12 @@
   }
 
   DecoratedType visitExtensionDeclaration(ExtensionDeclaration node) {
-    visitClassOrMixinOrExtensionDeclaration(node);
     _dispatch(node.typeParameters);
     _dispatch(node.extendedType);
+    _currentExtendedType =
+        _variables.decoratedTypeAnnotation(source, node.extendedType);
+    visitClassOrMixinOrExtensionDeclaration(node);
+    _currentExtendedType = null;
     return null;
   }
 
@@ -3148,22 +3157,8 @@
               .toList());
     } else {
       assert(_currentClassOrExtension is ExtensionElement);
-      final type = (_currentClassOrExtension as ExtensionElement).extendedType;
-
-      if (type is InterfaceType) {
-        var index = 0;
-        return DecoratedType(type, NullabilityNode.forInferredType(target),
-            typeArguments: type.typeArguments
-                .map((t) => DecoratedType(
-                    t,
-                    NullabilityNode.forInferredType(
-                        target.typeArgument(index++))))
-                .toList());
-      } else if (type is TypeParameterType) {
-        return DecoratedType(type, NullabilityNode.forInferredType(target));
-      } else {
-        _unimplemented(node, 'extension of $type (${type.runtimeType}');
-      }
+      assert(_currentExtendedType != null);
+      return _currentExtendedType;
     }
   }
 
diff --git a/pkg/nnbd_migration/test/api_test.dart b/pkg/nnbd_migration/test/api_test.dart
index 1eb3737..d3075e1 100644
--- a/pkg/nnbd_migration/test/api_test.dart
+++ b/pkg/nnbd_migration/test/api_test.dart
@@ -2217,6 +2217,28 @@
     await _checkSingleFileChanges(content, expected);
   }
 
+  Future<void> test_extension_on_generic_type() async {
+    var content = '''
+class C<T> {
+  final T value;
+  C(this.value);
+}
+extension E<T> on Future<C<T/*?*/>> {
+  Future<T> get asyncValue async => (await this).value;
+}
+''';
+    var expected = '''
+class C<T> {
+  final T value;
+  C(this.value);
+}
+extension E<T> on Future<C<T?>> {
+  Future<T?> get asyncValue async => (await this).value;
+}
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   Future<void> test_extension_on_type_param_implementation() async {
     var content = '''
 abstract class C {
@@ -6408,11 +6430,11 @@
     await _checkSingleFileChanges(content, expected);
   }
 
-  @FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/39387')
   Future<void> test_this_inside_extension() async {
     var content = '''
 class C<T> {
   T field;
+  C(this.field);
 }
 extension on C<int> {
   f() {
@@ -6421,14 +6443,14 @@
 }
 extension on C<List<int>> {
   f() {
-    this.field = null;
+    this.field = [null];
   }
 }
 ''';
     var expected = '''
-
 class C<T> {
   T field;
+  C(this.field);
 }
 extension on C<int?> {
   f() {
diff --git a/pkg/nnbd_migration/test/edge_builder_test.dart b/pkg/nnbd_migration/test/edge_builder_test.dart
index 001a94b..e8f81c6 100644
--- a/pkg/nnbd_migration/test/edge_builder_test.dart
+++ b/pkg/nnbd_migration/test/edge_builder_test.dart
@@ -2929,7 +2929,6 @@
     // metadata was visited.
   }
 
-  @FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/39387')
   Future<void> test_extension_on_class_with_generic_type_arguments() async {
     await analyze('''
 class C<T> {}
@@ -2942,7 +2941,6 @@
     // adding assertion(s).
   }
 
-  @FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/39387')
   Future<void> test_extension_on_function_type() async {
     await analyze('''
 extension CurryFunction<R, S, T> on R Function(S, T) {
diff --git a/pkg/test_runner/lib/src/test_configurations.dart b/pkg/test_runner/lib/src/test_configurations.dart
index 4d3925a..3179fec 100644
--- a/pkg/test_runner/lib/src/test_configurations.dart
+++ b/pkg/test_runner/lib/src/test_configurations.dart
@@ -149,6 +149,12 @@
           // vm tests contain both cc tests (added here) and dart tests (added
           // in [TEST_SUITE_DIRECTORIES]).
           testSuites.add(VMTestSuite(configuration));
+        } else if (key == 'ffi_unit') {
+          // 'ffi_unit' contains cc non-DartVM unit tests.
+          //
+          // This is a separate suite from 'ffi', because we want to run the
+          // 'ffi' suite on many architectures, but 'ffi_unit' only on one.
+          testSuites.add(FfiTestSuite(configuration));
         } else if (configuration.compiler == Compiler.dart2analyzer) {
           if (key == 'analyze_library') {
             testSuites.add(AnalyzeLibraryTestSuite(configuration));
diff --git a/pkg/test_runner/lib/src/test_suite.dart b/pkg/test_runner/lib/src/test_suite.dart
index e788744..53af2c7 100644
--- a/pkg/test_runner/lib/src/test_suite.dart
+++ b/pkg/test_runner/lib/src/test_suite.dart
@@ -364,6 +364,128 @@
   VMUnitTest(this.name, this.expectation);
 }
 
+/// A specialized [TestSuite] that runs tests written in C to unit test
+/// the standalone (non-DartVM) C/C++ code.
+///
+/// The tests are compiled into an executable for all [targetAbis] by the
+/// build step.
+/// An executable lists its tests when run with the --list command line flag.
+/// Individual tests are run by specifying them on the command line.
+class FfiTestSuite extends TestSuite {
+  Map<String, String> runnerPaths;
+  final String dartDir;
+
+  static const targetAbis = [
+    "arm64_android",
+    "arm64_ios",
+    "arm64_linux",
+    "arm64_macos",
+    "arm_android",
+    "arm_ios",
+    "arm_linux",
+    "ia32_android",
+    "ia32_linux",
+    "ia32_win",
+    "x64_ios",
+    "x64_linux",
+    "x64_macos",
+    "x64_win",
+  ];
+
+  FfiTestSuite(TestConfiguration configuration)
+      : dartDir = Repository.dir.toNativePath(),
+        super(configuration, "ffi_unit", []) {
+    final binarySuffix = Platform.operatingSystem == 'windows' ? '.exe' : '';
+
+    // For running the tests we use multiple binaries, one for each target ABI.
+    runnerPaths = Map.fromIterables(
+        targetAbis,
+        targetAbis.map((String config) =>
+            '$buildDir/run_ffi_unit_tests_$config$binarySuffix'));
+  }
+
+  void findTestCases(TestCaseEvent onTest, Map testCache) {
+    final statusFiles =
+        statusFilePaths.map((statusFile) => "$dartDir/$statusFile").toList();
+    final expectations = ExpectationSet.read(statusFiles, configuration);
+
+    runnerPaths.forEach((runnerName, runnerPath) {
+      try {
+        for (final test in _listTests(runnerName, runnerPath)) {
+          _addTest(expectations, test, onTest);
+        }
+      } catch (error, s) {
+        print(
+            "Fatal error occurred while parsing tests from $runnerName: $error");
+        print(s);
+        exit(1);
+      }
+    });
+  }
+
+  void _addTest(
+      ExpectationSet testExpectations, FfiUnitTest test, TestCaseEvent onTest) {
+    final fullName = '${test.runnerName}/${test.name}';
+    var expectations = testExpectations.expectations(fullName);
+
+    // Get the expectation from the test itself.
+    final testExpectation = Expectation.find(test.expectation);
+
+    // Update the legacy status-file based expectations to include
+    // [testExpectation].
+    if (testExpectation != Expectation.pass) {
+      expectations = {...expectations, testExpectation};
+      expectations.remove(Expectation.pass);
+    }
+
+    // Update the new workflow based expectations to include [testExpectation].
+    final testFile = TestFile.vmUnitTest(
+        hasSyntaxError: false,
+        hasCompileError: testExpectation == Expectation.compileTimeError,
+        hasRuntimeError: testExpectation == Expectation.runtimeError,
+        hasStaticWarning: false,
+        hasCrash: testExpectation == Expectation.crash);
+
+    final args = [
+      // This test has no VM, but pipe through vmOptions as test options.
+      // Passing `--vm-options=--update` will update all test expectations.
+      ...configuration.vmOptions,
+      test.name,
+    ];
+    final command = ProcessCommand(
+        'run_ffi_unit_test', test.runnerPath, args, environmentOverrides);
+
+    _addTestCase(testFile, fullName, [command], expectations, onTest);
+  }
+
+  Iterable<FfiUnitTest> _listTests(String runnerName, String runnerPath) {
+    final result = Process.runSync(runnerPath, ["--list"]);
+    if (result.exitCode != 0) {
+      throw "Failed to list tests: '$runnerPath --list'. "
+          "Process exited with ${result.exitCode}";
+    }
+
+    return (result.stdout as String)
+        .split('\n')
+        .map((line) => line.trim())
+        .where((name) => name.isNotEmpty)
+        .map((String line) {
+      final parts = line.split(' ');
+      assert(parts.length == 2);
+      return FfiUnitTest(runnerName, runnerPath, parts[0], parts[1]);
+    });
+  }
+}
+
+class FfiUnitTest {
+  final String runnerName;
+  final String runnerPath;
+  final String name;
+  final String expectation;
+
+  FfiUnitTest(this.runnerName, this.runnerPath, this.name, this.expectation);
+}
+
 /// A standard [TestSuite] implementation that searches for tests in a
 /// directory, and creates [TestCase]s that compile and/or run them.
 class StandardTestSuite extends TestSuite {
diff --git a/pkg/test_runner/tool/update_static_error_tests.dart b/pkg/test_runner/tool/update_static_error_tests.dart
index 5364fc2..7432ff2 100644
--- a/pkg/test_runner/tool/update_static_error_tests.dart
+++ b/pkg/test_runner/tool/update_static_error_tests.dart
@@ -301,7 +301,7 @@
   return errors;
 }
 
-/// Find the most recently-built [binary] in any of the build directories.
+/// Find the most recently-built binary [name] in any of the build directories.
 String _findBinary(String name, String windowsExtension) {
   var binary = Platform.isWindows ? "$name.$windowsExtension" : name;
 
diff --git a/pkg/vm_service/test/get_stack_test.dart b/pkg/vm_service/test/get_stack_test.dart
index 6e61379..0f65938 100644
--- a/pkg/vm_service/test/get_stack_test.dart
+++ b/pkg/vm_service/test/get_stack_test.dart
@@ -74,17 +74,17 @@
     ]);
 
     expectFrames(result.asyncCausalFrames, [
-      [equals('AsyncCausal'), endsWith(' func10')],
-      [equals('AsyncCausal'), endsWith(' func9')],
-      [equals('AsyncCausal'), endsWith(' func8')],
-      [equals('AsyncCausal'), endsWith(' func7')],
-      [equals('AsyncCausal'), endsWith(' func6')],
-      [equals('AsyncCausal'), endsWith(' func5')],
-      [equals('AsyncCausal'), endsWith(' func4')],
-      [equals('AsyncCausal'), endsWith(' func3')],
-      [equals('AsyncCausal'), endsWith(' func2')],
-      [equals('AsyncCausal'), endsWith(' func1')],
-      [equals('AsyncCausal'), endsWith(' testMain')],
+      [equals('Regular'), endsWith(' func10')],
+      [equals('Regular'), endsWith(' func9')],
+      [equals('Regular'), endsWith(' func8')],
+      [equals('Regular'), endsWith(' func7')],
+      [equals('Regular'), endsWith(' func6')],
+      [equals('Regular'), endsWith(' func5')],
+      [equals('Regular'), endsWith(' func4')],
+      [equals('Regular'), endsWith(' func3')],
+      [equals('Regular'), endsWith(' func2')],
+      [equals('Regular'), endsWith(' func1')],
+      [equals('Regular'), endsWith(' testMain')],
     ]);
 
     expectFrames(result.awaiterFrames, [
@@ -126,7 +126,7 @@
     ]);
 
     expectFrames(result.asyncCausalFrames, [
-      [equals('AsyncCausal'), endsWith(' func10')],
+      [equals('Regular'), endsWith(' func10')],
       [equals('AsyncSuspensionMarker'), isNull],
       [equals('AsyncCausal'), endsWith(' func9')],
       [equals('AsyncSuspensionMarker'), isNull],
diff --git a/runtime/bin/ffi_unit_test/BUILD.gn b/runtime/bin/ffi_unit_test/BUILD.gn
new file mode 100644
index 0000000..d7c93ba
--- /dev/null
+++ b/runtime/bin/ffi_unit_test/BUILD.gn
@@ -0,0 +1,187 @@
+# Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+# 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.
+
+import("../../platform/platform_sources.gni")
+import("../../vm/compiler/compiler_sources.gni")
+import("../../vm/vm_sources.gni")
+
+template("build_run_ffi_unit_tests") {
+  extra_configs = []
+  if (defined(invoker.extra_configs)) {
+    extra_configs += invoker.extra_configs
+  }
+
+  executable(target_name) {
+    configs += [] + extra_configs
+
+    defines = [
+      "TESTING",
+      "FFI_UNIT_TESTS",
+    ]
+
+    include_dirs = [
+      "../..",
+      "//third_party",
+    ]
+
+    constants = rebase_path(constants_sources, ".", "../../vm")
+    ffi_tests = rebase_path(ffi_sources_tests, ".", "../../vm/compiler")
+    platform = rebase_path(platform_sources, ".", "../../platform")
+
+    sources = [ "run_ffi_unit_tests.cc" ] + constants + ffi_tests + platform
+  }
+}
+
+config("define_target_arch_arm") {
+  defines = [ "TARGET_ARCH_ARM" ]
+}
+
+config("define_target_arch_arm64") {
+  defines = [ "TARGET_ARCH_ARM64" ]
+}
+
+config("define_target_arch_ia32") {
+  defines = [ "TARGET_ARCH_IA32" ]
+}
+
+config("define_target_arch_x64") {
+  defines = [ "TARGET_ARCH_X64" ]
+}
+
+config("define_target_os_android") {
+  defines = [ "TARGET_OS_ANDROID" ]
+}
+
+config("define_target_os_ios") {
+  defines = [ "TARGET_OS_IOS" ]
+}
+
+config("define_target_os_linux") {
+  defines = [ "TARGET_OS_LINUX" ]
+}
+
+config("define_target_os_macos") {
+  defines = [ "TARGET_OS_MACOS" ]
+}
+
+config("define_target_os_windows") {
+  defines = [ "TARGET_OS_WINDOWS" ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_arm_android") {
+  extra_configs = [
+    ":define_target_arch_arm",
+    ":define_target_os_android",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_arm_ios") {
+  extra_configs = [
+    ":define_target_arch_arm",
+    ":define_target_os_ios",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_arm_linux") {
+  extra_configs = [
+    ":define_target_arch_arm",
+    ":define_target_os_linux",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_arm64_android") {
+  extra_configs = [
+    ":define_target_arch_arm64",
+    ":define_target_os_android",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_arm64_ios") {
+  extra_configs = [
+    ":define_target_arch_arm64",
+    ":define_target_os_ios",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_arm64_macos") {
+  extra_configs = [
+    ":define_target_arch_arm64",
+    ":define_target_os_macos",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_arm64_linux") {
+  extra_configs = [
+    ":define_target_arch_arm64",
+    ":define_target_os_linux",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_ia32_android") {
+  extra_configs = [
+    ":define_target_arch_ia32",
+    ":define_target_os_android",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_ia32_linux") {
+  extra_configs = [
+    ":define_target_arch_ia32",
+    ":define_target_os_linux",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_ia32_win") {
+  extra_configs = [
+    ":define_target_arch_ia32",
+    ":define_target_os_windows",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_x64_ios") {
+  extra_configs = [
+    ":define_target_arch_x64",
+    ":define_target_os_ios",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_x64_linux") {
+  extra_configs = [
+    ":define_target_arch_x64",
+    ":define_target_os_linux",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_x64_macos") {
+  extra_configs = [
+    ":define_target_arch_x64",
+    ":define_target_os_macos",
+  ]
+}
+
+build_run_ffi_unit_tests("run_ffi_unit_tests_x64_win") {
+  extra_configs = [
+    ":define_target_arch_x64",
+    ":define_target_os_windows",
+  ]
+}
+
+group("run_ffi_unit_tests") {
+  deps = [
+    ":run_ffi_unit_tests_arm64_android",
+    ":run_ffi_unit_tests_arm64_ios",  # No other test coverage.
+    ":run_ffi_unit_tests_arm64_linux",
+    ":run_ffi_unit_tests_arm64_macos",
+    ":run_ffi_unit_tests_arm_android",  # SoftFP
+    ":run_ffi_unit_tests_arm_ios",  # No other test coverage.
+    ":run_ffi_unit_tests_arm_linux",  # HardFP
+    ":run_ffi_unit_tests_ia32_android",  # Emulator, no other test coverage.
+    ":run_ffi_unit_tests_ia32_linux",
+    ":run_ffi_unit_tests_ia32_win",
+    ":run_ffi_unit_tests_x64_ios",  # Simulator, no other test coverage.
+    ":run_ffi_unit_tests_x64_linux",
+    ":run_ffi_unit_tests_x64_macos",
+    ":run_ffi_unit_tests_x64_win",
+  ]
+}
diff --git a/runtime/bin/ffi_unit_test/run_ffi_unit_tests.cc b/runtime/bin/ffi_unit_test/run_ffi_unit_tests.cc
new file mode 100644
index 0000000..8fe8784
--- /dev/null
+++ b/runtime/bin/ffi_unit_test/run_ffi_unit_tests.cc
@@ -0,0 +1,115 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+// A slimmed down version of bin/run_vm_tests.cc that only runs C++ non-DartVM
+// unit tests.
+//
+// By slimming it down to non-VM, we can run with the defines for all target
+// architectures and operating systems.
+
+#include "vm/compiler/ffi/unit_test.h"
+
+#include "platform/assert.h"
+#include "platform/syslog.h"
+
+namespace dart {
+namespace compiler {
+namespace ffi {
+
+static const char* const kNone = "No Test";
+static const char* const kList = "List all Tests";
+static const char* const kAll = "Run all Tests";
+static const char* run_filter = kNone;
+
+static const char* kCommandAll = "--all";
+static const char* kCommandList = "--list";
+static const char* kCommandUpdate = "--update";
+
+static int run_matches = 0;
+
+TestCaseBase* TestCaseBase::first_ = nullptr;
+TestCaseBase* TestCaseBase::tail_ = nullptr;
+bool TestCaseBase::update_expectations = false;
+
+TestCaseBase::TestCaseBase(const char* name, const char* expectation)
+    : next_(nullptr), name_(name), expectation_(expectation) {
+  ASSERT(strlen(expectation) > 0);
+  if (first_ == nullptr) {
+    first_ = this;
+  } else {
+    tail_->next_ = this;
+  }
+  tail_ = this;
+}
+
+void TestCaseBase::RunAll() {
+  TestCaseBase* test = first_;
+  while (test != nullptr) {
+    test->RunTest();
+    test = test->next_;
+  }
+}
+
+void TestCaseBase::RunTest() {
+  if (run_filter == kList) {
+    Syslog::Print("%s %s\n", this->name(), this->expectation());
+    run_matches++;
+  } else if (run_filter == kAll) {
+    this->Run();
+    run_matches++;
+  } else if (strcmp(run_filter, this->name()) == 0) {
+    this->Run();
+    run_matches++;
+  }
+}
+
+void RawTestCase::Run() {
+  Syslog::Print("Running test: %s\n", name());
+  (*run_)();
+  Syslog::Print("Done: %s\n", name());
+}
+
+static int Main(int argc, const char** argv) {
+  if (argc == 2 && strcmp(argv[1], kCommandList) == 0) {
+    run_filter = kList;
+    // List all tests and benchmarks and exit.
+    TestCaseBase::RunAll();
+    fflush(stdout);
+    return 0;
+  }
+  if (argc > 1 && strcmp(argv[1], kCommandUpdate) == 0) {
+    TestCaseBase::update_expectations = true;
+  }
+  if (strcmp(argv[argc - 1], kCommandAll) == 0) {
+    // Run all tests.
+    run_filter = kAll;
+  } else if (argc > 1) {
+    // Run only test with specific name.
+    run_filter = argv[argc - 1];
+  }
+
+  TestCaseBase::RunAll();
+
+  // Print a warning message if no tests or benchmarks were matched.
+  if (run_matches == 0) {
+    Syslog::PrintErr("No tests matched: %s\n", run_filter);
+    return 1;
+  }
+  if (Expect::failed()) {
+    Syslog::PrintErr(
+        "Some tests failed. Run the following command to update "
+        "expectations.\ntools/test.py --vm-options=--update ffi_unit");
+    return 255;
+  }
+
+  return 0;
+}
+
+}  // namespace ffi
+}  // namespace compiler
+}  // namespace dart
+
+int main(int argc, const char** argv) {
+  return dart::compiler::ffi::Main(argc, argv);
+}
diff --git a/runtime/platform/globals.h b/runtime/platform/globals.h
index ab51780..79b6a6b 100644
--- a/runtime/platform/globals.h
+++ b/runtime/platform/globals.h
@@ -339,17 +339,17 @@
 // Verify that host and target architectures match, we cannot
 // have a 64 bit Dart VM generating 32 bit code or vice-versa.
 #if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64)
-#if !defined(ARCH_IS_64_BIT)
+#if !defined(ARCH_IS_64_BIT) && !defined(FFI_UNIT_TESTS)
 #error Mismatched Host/Target architectures.
-#endif  // !defined(ARCH_IS_64_BIT)
+#endif  // !defined(ARCH_IS_64_BIT) && !defined(FFI_UNIT_TESTS)
 #elif defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
 #if defined(HOST_ARCH_X64) && defined(TARGET_ARCH_ARM)
 // This is simarm_x64, which is the only case where host/target architecture
-// mismatch is allowed.
+// mismatch is allowed. Unless, we're running FFI unit tests.
 #define IS_SIMARM_X64 1
-#elif !defined(ARCH_IS_32_BIT)
+#elif !defined(ARCH_IS_32_BIT) && !defined(FFI_UNIT_TESTS)
 #error Mismatched Host/Target architectures.
-#endif  // !defined(ARCH_IS_32_BIT)
+#endif  // !defined(ARCH_IS_32_BIT) && !defined(FFI_UNIT_TESTS)
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
 
 // Determine whether we will be using the simulator.
diff --git a/runtime/tools/embedder_layering_check.py b/runtime/tools/embedder_layering_check.py
index d49b705..8e33bf0 100644
--- a/runtime/tools/embedder_layering_check.py
+++ b/runtime/tools/embedder_layering_check.py
@@ -20,7 +20,9 @@
 
 # Tests that don't match the simple case of *_test.cc.
 EXTRA_TEST_FILES = [
-    'runtime/bin/run_vm_tests.cc', 'runtime/vm/libfuzzer/dart_libfuzzer.cc'
+    'runtime/bin/run_vm_tests.cc',
+    'runtime/bin/ffi_unit_test/run_ffi_unit_tests.cc',
+    'runtime/vm/libfuzzer/dart_libfuzzer.cc'
 ]
 
 
diff --git a/runtime/vm/compilation_trace.cc b/runtime/vm/compilation_trace.cc
index 0db337d..5a86366 100644
--- a/runtime/vm/compilation_trace.cc
+++ b/runtime/vm/compilation_trace.cc
@@ -744,6 +744,8 @@
       fields_ = cls_.fields();
     }
 
+    SafepointWriteRwLocker ml(thread_,
+                              thread_->isolate_group()->program_lock());
     for (intptr_t i = 0; i < num_fields; i++) {
       field_name_ = ReadString();
       intptr_t guarded_cid = cid_map_[ReadInt()];
diff --git a/runtime/vm/compiler/compiler_sources.gni b/runtime/vm/compiler/compiler_sources.gni
index dd1d2fa..386dd86 100644
--- a/runtime/vm/compiler/compiler_sources.gni
+++ b/runtime/vm/compiler/compiler_sources.gni
@@ -204,3 +204,10 @@
   "assembler/disassembler_arm64.cc",
   "assembler/disassembler_x86.cc",
 ]
+
+ffi_sources_tests = [
+  "ffi/native_calling_convention_test.cc",
+  "ffi/native_location_test.cc",
+  "ffi/native_type_test.cc",
+  "ffi/unit_test_custom_zone.cc",
+]
diff --git a/runtime/vm/compiler/ffi/native_calling_convention.cc b/runtime/vm/compiler/ffi/native_calling_convention.cc
index fe3881c..5b21cf2 100644
--- a/runtime/vm/compiler/ffi/native_calling_convention.cc
+++ b/runtime/vm/compiler/ffi/native_calling_convention.cc
@@ -6,9 +6,12 @@
 
 #include "vm/compiler/ffi/native_location.h"
 #include "vm/compiler/ffi/native_type.h"
-#include "vm/cpu.h"
 #include "vm/zone_text_buffer.h"
 
+#if !defined(FFI_UNIT_TESTS)
+#include "vm/cpu.h"
+#endif
+
 namespace dart {
 
 namespace compiler {
@@ -17,6 +20,7 @@
 
 const intptr_t kNoFpuRegister = -1;
 
+#if !defined(FFI_UNIT_TESTS)
 // In Soft FP, floats and doubles get passed in integer registers.
 static bool SoftFpAbi() {
 #if defined(TARGET_ARCH_ARM)
@@ -25,6 +29,15 @@
   return false;
 #endif
 }
+#else  // !defined(FFI_UNIT_TESTS)
+static bool SoftFpAbi() {
+#if defined(TARGET_ARCH_ARM) && defined(TARGET_OS_ANDROID)
+  return true;
+#else
+  return false;
+#endif
+}
+#endif  // !defined(FFI_UNIT_TESTS)
 
 // In Soft FP, floats are treated as 4 byte ints, and doubles as 8 byte ints.
 static const NativeType& ConvertIfSoftFp(Zone* zone, const NativeType& rep) {
@@ -293,9 +306,11 @@
   return textBuffer.buffer();
 }
 
+#if !defined(FFI_UNIT_TESTS)
 const char* NativeCallingConvention::ToCString(bool multi_line) const {
   return ToCString(Thread::Current()->zone(), multi_line);
 }
+#endif
 
 }  // namespace ffi
 
diff --git a/runtime/vm/compiler/ffi/native_calling_convention.h b/runtime/vm/compiler/ffi/native_calling_convention.h
index bb10887..9faf620 100644
--- a/runtime/vm/compiler/ffi/native_calling_convention.h
+++ b/runtime/vm/compiler/ffi/native_calling_convention.h
@@ -42,7 +42,9 @@
   void PrintTo(BaseTextBuffer* f, bool multi_line = false) const;
   void PrintToMultiLine(BaseTextBuffer* f) const;
   const char* ToCString(Zone* zone, bool multi_line = false) const;
+#if !defined(FFI_UNIT_TESTS)
   const char* ToCString(bool multi_line = false) const;
+#endif
 
  private:
   NativeCallingConvention(const NativeLocations& argument_locations,
diff --git a/runtime/vm/compiler/ffi/native_calling_convention_test.cc b/runtime/vm/compiler/ffi/native_calling_convention_test.cc
new file mode 100644
index 0000000..23ed777
--- /dev/null
+++ b/runtime/vm/compiler/ffi/native_calling_convention_test.cc
@@ -0,0 +1,138 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+#include "vm/compiler/ffi/unit_test.h"
+
+#include "platform/syslog.h"
+#include "vm/compiler/ffi/native_calling_convention.h"
+
+namespace dart {
+namespace compiler {
+namespace ffi {
+
+#if defined(TARGET_ARCH_ARM)
+const char* kArch = "arm";
+#elif defined(TARGET_ARCH_ARM64)
+const char* kArch = "arm64";
+#elif defined(TARGET_ARCH_IA32)
+const char* kArch = "ia32";
+#elif defined(TARGET_ARCH_X64)
+const char* kArch = "x64";
+#endif
+
+#if defined(TARGET_OS_ANDROID)
+const char* kOs = "android";
+#elif defined(TARGET_OS_IOS)
+const char* kOs = "ios";
+#elif defined(TARGET_OS_LINUX)
+const char* kOs = "linux";
+#elif defined(TARGET_OS_MACOS)
+const char* kOs = "macos";
+#elif defined(TARGET_OS_WINDOWS)
+const char* kOs = "win";
+#endif
+
+void WriteToFile(char* path, const char* contents) {
+  FILE* file;
+  file = fopen(path, "w");
+  if (file != nullptr) {
+    fprintf(file, "%s", contents);
+  } else {
+    Syslog::Print("Error %d \n", errno);
+  }
+  fclose(file);
+}
+
+void ReadFromFile(char* path, char** buffer_pointer) {
+  FILE* file = fopen(path, "rb");
+  if (file == nullptr) {
+    Syslog::Print("Error %d \n", errno);
+    return;
+  }
+
+  fseek(file, 0, SEEK_END);
+  size_t size = ftell(file);
+  rewind(file);
+
+  char* buffer = reinterpret_cast<char*>(malloc(sizeof(char) * (size + 1)));
+
+  fread(buffer, 1, size, file);
+  buffer[size] = 0;
+
+  fclose(file);
+  *buffer_pointer = buffer;
+}
+
+void RunSignatureTest(dart::Zone* zone,
+                      const char* name,
+                      const NativeTypes& argument_types,
+                      const NativeType& return_type) {
+  const auto& native_signature =
+      *new (zone) NativeFunctionType(argument_types, return_type);
+
+  const auto& native_calling_convention =
+      NativeCallingConvention::FromSignature(zone, native_signature);
+
+  const char* test_result =
+      native_calling_convention.ToCString(zone, /*multi_line=*/true);
+
+  const int kFilePathLength = 100;
+  char expectation_file_path[kFilePathLength];
+  Utils::SNPrint(expectation_file_path, kFilePathLength,
+                 "runtime/vm/compiler/ffi/unit_tests/%s/%s_%s.expect", name,
+                 kArch, kOs);
+
+  if (TestCaseBase::update_expectations) {
+    Syslog::Print("Updating %s\n", expectation_file_path);
+    WriteToFile(expectation_file_path, test_result);
+  }
+
+  char* expectation_file_contents = nullptr;
+  ReadFromFile(expectation_file_path, &expectation_file_contents);
+  EXPECT_NOTNULL(expectation_file_contents);
+  if (expectation_file_contents != nullptr) {
+    EXPECT_STREQ(expectation_file_contents, test_result);
+    free(expectation_file_contents);
+  }
+}
+
+UNIT_TEST_CASE_WITH_ZONE(NativeCallingConvention_int8x10) {
+  const auto& int8type = *new (Z) NativePrimitiveType(kInt8);
+
+  auto& arguments = *new (Z) NativeTypes(Z, 10);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+  arguments.Add(&int8type);
+
+  RunSignatureTest(Z, "int8x10", arguments, int8type);
+}
+
+UNIT_TEST_CASE_WITH_ZONE(NativeCallingConvention_floatx10) {
+  const auto& floatType = *new (Z) NativePrimitiveType(kFloat);
+
+  auto& arguments = *new (Z) NativeTypes(Z, 10);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+  arguments.Add(&floatType);
+
+  RunSignatureTest(Z, "floatx10", arguments, floatType);
+}
+
+}  // namespace ffi
+}  // namespace compiler
+}  // namespace dart
diff --git a/runtime/vm/compiler/ffi/native_location.cc b/runtime/vm/compiler/ffi/native_location.cc
index dce51c1..12439aa 100644
--- a/runtime/vm/compiler/ffi/native_location.cc
+++ b/runtime/vm/compiler/ffi/native_location.cc
@@ -12,6 +12,7 @@
 
 namespace ffi {
 
+#if !defined(FFI_UNIT_TESTS)
 bool NativeLocation::LocationCanBeExpressed(Location loc, Representation rep) {
   switch (loc.kind()) {
     case Location::Kind::kRegister:
@@ -74,6 +75,7 @@
   const Location loc = pair_loc.AsPairLocation()->At(index);
   return FromLocation(zone, loc, rep);
 }
+#endif
 
 const NativeRegistersLocation& NativeLocation::AsRegisters() const {
   ASSERT(IsRegisters());
@@ -90,6 +92,7 @@
   return static_cast<const NativeStackLocation&>(*this);
 }
 
+#if !defined(FFI_UNIT_TESTS)
 Location NativeRegistersLocation::AsLocation() const {
   ASSERT(IsExpressibleAsLocation());
   switch (num_regs()) {
@@ -126,6 +129,7 @@
   }
   UNREACHABLE();
 }
+#endif
 
 NativeRegistersLocation& NativeRegistersLocation::Split(Zone* zone,
                                                         intptr_t index) const {
@@ -206,10 +210,12 @@
   return other_stack.offset_in_bytes_ == offset_in_bytes_;
 }
 
+#if !defined(FFI_UNIT_TESTS)
 compiler::Address NativeLocationToStackSlotAddress(
     const NativeStackLocation& loc) {
   return compiler::Address(loc.base_register(), loc.offset_in_bytes());
 }
+#endif
 
 static void PrintRepresentations(BaseTextBuffer* f, const NativeLocation& loc) {
   f->AddString(" ");
@@ -271,9 +277,11 @@
   return textBuffer.buffer();
 }
 
+#if !defined(FFI_UNIT_TESTS)
 const char* NativeLocation::ToCString() const {
   return ToCString(Thread::Current()->zone());
 }
+#endif
 
 intptr_t SizeFromFpuRegisterKind(enum FpuRegisterKind kind) {
   switch (kind) {
diff --git a/runtime/vm/compiler/ffi/native_location.h b/runtime/vm/compiler/ffi/native_location.h
index c3cce14..3437e5c 100644
--- a/runtime/vm/compiler/ffi/native_location.h
+++ b/runtime/vm/compiler/ffi/native_location.h
@@ -10,17 +10,24 @@
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
 
 #include "platform/assert.h"
-#include "vm/compiler/backend/locations.h"
 #include "vm/compiler/ffi/native_type.h"
 #include "vm/constants.h"
 #include "vm/growable_array.h"
 
+#if !defined(FFI_UNIT_TESTS)
+#include "vm/compiler/backend/locations.h"
+#endif
+
 namespace dart {
 
 class BaseTextBuffer;
 
 namespace compiler {
 
+namespace target {
+extern const int kWordSize;
+}
+
 namespace ffi {
 
 class NativeRegistersLocation;
@@ -55,6 +62,7 @@
 // inequality cannot be used to determine disjointness.
 class NativeLocation : public ZoneAllocated {
  public:
+#if !defined(FFI_UNIT_TESTS)
   static bool LocationCanBeExpressed(Location loc, Representation rep);
   static NativeLocation& FromLocation(Zone* zone,
                                       Location loc,
@@ -63,6 +71,7 @@
                                           Location loc,
                                           Representation rep,
                                           intptr_t index);
+#endif
 
   // The type of the data at this location.
   const NativeType& payload_type() const { return payload_type_; }
@@ -91,14 +100,18 @@
   virtual bool IsStack() const { return false; }
 
   virtual bool IsExpressibleAsLocation() const { return false; }
+#if !defined(FFI_UNIT_TESTS)
   virtual Location AsLocation() const {
     ASSERT(IsExpressibleAsLocation());
     UNREACHABLE();
   }
+#endif
 
   virtual void PrintTo(BaseTextBuffer* f) const;
   const char* ToCString(Zone* zone) const;
+#if !defined(FFI_UNIT_TESTS)
   const char* ToCString() const;
+#endif
 
   const NativeRegistersLocation& AsRegisters() const;
   const NativeFpuRegistersLocation& AsFpuRegisters() const;
@@ -171,7 +184,9 @@
   virtual bool IsExpressibleAsLocation() const {
     return num_regs() == 1 || num_regs() == 2;
   }
+#if !defined(FFI_UNIT_TESTS)
   virtual Location AsLocation() const;
+#endif
   intptr_t num_regs() const { return regs_->length(); }
   Register reg_at(intptr_t index) const { return regs_->At(index); }
 
@@ -238,10 +253,12 @@
   virtual bool IsExpressibleAsLocation() const {
     return fpu_reg_kind_ == kQuadFpuReg;
   }
+#if !defined(FFI_UNIT_TESTS)
   virtual Location AsLocation() const {
     ASSERT(IsExpressibleAsLocation());
     return Location::FpuRegisterLocation(fpu_reg());
   }
+#endif
   FpuRegisterKind fpu_reg_kind() const { return fpu_reg_kind_; }
   FpuRegister fpu_reg() const {
     ASSERT(fpu_reg_kind_ == kQuadFpuReg);
@@ -299,6 +316,8 @@
            size % compiler::target::kWordSize == 0 &&
            (size_slots == 1 || size_slots == 2);
   }
+
+#if !defined(FFI_UNIT_TESTS)
   virtual Location AsLocation() const;
 
   // ConstantInstr expects DoubleStackSlot for doubles, even on 64-bit systems.
@@ -308,6 +327,7 @@
     ASSERT(compiler::target::kWordSize == 8);
     return Location::DoubleStackSlot(offset_in_words(), base_register_);
   }
+#endif
 
   virtual NativeStackLocation& Split(Zone* zone, intptr_t index) const;
 
@@ -334,9 +354,11 @@
   DISALLOW_COPY_AND_ASSIGN(NativeStackLocation);
 };
 
+#if !defined(FFI_UNIT_TESTS)
 // Return a memory operand for stack slot locations.
 compiler::Address NativeLocationToStackSlotAddress(
     const NativeStackLocation& loc);
+#endif
 
 }  // namespace ffi
 
diff --git a/runtime/vm/compiler/ffi/native_location_test.cc b/runtime/vm/compiler/ffi/native_location_test.cc
new file mode 100644
index 0000000..ea1fb27
--- /dev/null
+++ b/runtime/vm/compiler/ffi/native_location_test.cc
@@ -0,0 +1,40 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+#include "vm/compiler/ffi/unit_test.h"
+
+#include "vm/compiler/ffi/native_location.h"
+
+namespace dart {
+namespace compiler {
+namespace ffi {
+
+UNIT_TEST_CASE_WITH_ZONE(NativeStackLocation) {
+  const auto& native_type = *new (Z) NativePrimitiveType(kInt8);
+
+  const int kUnalignedStackLocation = 17;
+
+  const auto& native_location = *new (Z) NativeStackLocation(
+      native_type, native_type, SPREG, kUnalignedStackLocation);
+
+  EXPECT_EQ(kUnalignedStackLocation + native_type.SizeInBytes(),
+            native_location.StackTopInBytes());
+}
+
+UNIT_TEST_CASE_WITH_ZONE(NativeStackLocation_Split) {
+  const auto& native_type = *new (Z) NativePrimitiveType(kInt64);
+
+  const auto& native_location =
+      *new (Z) NativeStackLocation(native_type, native_type, SPREG, 0);
+
+  const auto& half_0 = native_location.Split(Z, 0);
+  const auto& half_1 = native_location.Split(Z, 1);
+
+  EXPECT_EQ(0, half_0.offset_in_bytes());
+  EXPECT_EQ(4, half_1.offset_in_bytes());
+}
+
+}  // namespace ffi
+}  // namespace compiler
+}  // namespace dart
diff --git a/runtime/vm/compiler/ffi/native_type.cc b/runtime/vm/compiler/ffi/native_type.cc
index 7c1faae..db06400 100644
--- a/runtime/vm/compiler/ffi/native_type.cc
+++ b/runtime/vm/compiler/ffi/native_type.cc
@@ -10,9 +10,9 @@
 #include "vm/constants.h"
 #include "vm/zone_text_buffer.h"
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 #include "vm/compiler/backend/locations.h"
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+#endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
 namespace dart {
 
@@ -127,7 +127,7 @@
   }
 }
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 bool NativePrimitiveType::IsExpressibleAsRepresentation() const {
   switch (representation_) {
     case kInt8:
@@ -170,7 +170,7 @@
       UNREACHABLE();
   }
 }
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+#endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
 bool NativePrimitiveType::Equals(const NativeType& other) const {
   if (!other.IsPrimitive()) {
@@ -249,12 +249,14 @@
   return *new (zone) NativePrimitiveType(fundamental_rep);
 }
 
+#if !defined(FFI_UNIT_TESTS)
 NativeType& NativeType::FromAbstractType(Zone* zone, const AbstractType& type) {
   // TODO(36730): Support composites.
   return NativeType::FromTypedDataClassId(zone, type.type_class_id());
 }
+#endif
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 static PrimitiveType fundamental_rep(Representation rep) {
   switch (rep) {
     case kUnboxedDouble:
@@ -277,7 +279,7 @@
                                                            Representation rep) {
   return *new (zone) NativePrimitiveType(fundamental_rep(rep));
 }
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+#endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
 const char* NativeType::ToCString(Zone* zone) const {
   ZoneTextBuffer textBuffer(zone);
@@ -285,9 +287,11 @@
   return textBuffer.buffer();
 }
 
+#if !defined(FFI_UNIT_TESTS)
 const char* NativeType::ToCString() const {
   return ToCString(Thread::Current()->zone());
 }
+#endif
 
 static const char* PrimitiveTypeToCString(PrimitiveType rep) {
   switch (rep) {
@@ -334,9 +338,11 @@
   return textBuffer.buffer();
 }
 
+#if !defined(FFI_UNIT_TESTS)
 const char* NativeFunctionType::ToCString() const {
   return ToCString(Thread::Current()->zone());
 }
+#endif
 
 void NativeFunctionType::PrintTo(BaseTextBuffer* f) const {
   f->AddString("(");
diff --git a/runtime/vm/compiler/ffi/native_type.h b/runtime/vm/compiler/ffi/native_type.h
index d2ca9c1..3c11341 100644
--- a/runtime/vm/compiler/ffi/native_type.h
+++ b/runtime/vm/compiler/ffi/native_type.h
@@ -9,11 +9,13 @@
 #include "platform/globals.h"
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
-#include "vm/object.h"
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 #include "vm/compiler/backend/locations.h"
 #endif
+#if !defined(FFI_UNIT_TESTS)
+#include "vm/object.h"
+#endif
 
 namespace dart {
 
@@ -51,13 +53,15 @@
 // TODO(36730): Add composites.
 class NativeType : public ZoneAllocated {
  public:
+#if !defined(FFI_UNIT_TESTS)
   static NativeType& FromAbstractType(Zone* zone, const AbstractType& type);
+#endif
   static NativeType& FromTypedDataClassId(Zone* zone, classid_t class_id);
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
   static NativePrimitiveType& FromUnboxedRepresentation(Zone* zone,
                                                         Representation rep);
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+#endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
   virtual bool IsPrimitive() const { return false; }
   const NativePrimitiveType& AsPrimitive() const;
@@ -79,7 +83,7 @@
   // The alignment in bytes of this representation as member of a composite.
   virtual intptr_t AlignmentInBytesField() const = 0;
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
   // NativeTypes which are available as unboxed Representations.
   virtual bool IsExpressibleAsRepresentation() const { return false; }
 
@@ -91,7 +95,7 @@
     const auto& widened = WidenTo4Bytes(zone_);
     return widened.AsRepresentation();
   }
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+#endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
   virtual bool Equals(const NativeType& other) const { UNREACHABLE(); }
 
@@ -104,7 +108,9 @@
 
   virtual void PrintTo(BaseTextBuffer* f) const;
   const char* ToCString(Zone* zone) const;
+#if !defined(FFI_UNIT_TESTS)
   const char* ToCString() const;
+#endif
 
   virtual ~NativeType() {}
 
@@ -152,10 +158,10 @@
   virtual intptr_t AlignmentInBytesStack() const;
   virtual intptr_t AlignmentInBytesField() const;
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
   virtual bool IsExpressibleAsRepresentation() const;
   virtual Representation AsRepresentation() const;
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+#endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
   virtual bool Equals(const NativeType& other) const;
   virtual NativePrimitiveType& Split(Zone* zone, intptr_t part) const;
@@ -181,8 +187,9 @@
 
   void PrintTo(BaseTextBuffer* f) const;
   const char* ToCString(Zone* zone) const;
-
+#if !defined(FFI_UNIT_TESTS)
   const char* ToCString() const;
+#endif
 
  private:
   const NativeTypes& argument_types_;
diff --git a/runtime/vm/compiler/ffi/native_type_test.cc b/runtime/vm/compiler/ffi/native_type_test.cc
new file mode 100644
index 0000000..abf275d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/native_type_test.cc
@@ -0,0 +1,25 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+#include "vm/compiler/ffi/unit_test.h"
+
+#include "vm/compiler/ffi/native_type.h"
+
+namespace dart {
+namespace compiler {
+namespace ffi {
+
+UNIT_TEST_CASE_WITH_ZONE(NativeType) {
+  const auto& native_type = *new (Z) NativePrimitiveType(kInt8);
+
+  EXPECT_EQ(1, native_type.SizeInBytes());
+  EXPECT(native_type.IsInt());
+  EXPECT(native_type.IsPrimitive());
+
+  EXPECT_STREQ("int8", native_type.ToCString(Z));
+}
+
+}  // namespace ffi
+}  // namespace compiler
+}  // namespace dart
diff --git a/runtime/vm/compiler/ffi/unit_test.h b/runtime/vm/compiler/ffi/unit_test.h
new file mode 100644
index 0000000..44c4f0d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_test.h
@@ -0,0 +1,85 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+// A slimmed down version of runtime/vm/unit_test.h that only runs C++
+// non-DartVM unit tests.
+
+#ifndef RUNTIME_VM_COMPILER_FFI_UNIT_TEST_H_
+#define RUNTIME_VM_COMPILER_FFI_UNIT_TEST_H_
+
+// Don't use the DartVM zone, so include this first.
+#include "vm/compiler/ffi/unit_test_custom_zone.h"
+
+#include "platform/globals.h"
+
+// The UNIT_TEST_CASE macro is used for tests.
+#define UNIT_TEST_CASE_WITH_EXPECTATION(name, expectation)                     \
+  void Dart_Test##name();                                                      \
+  static const dart::compiler::ffi::RawTestCase kRegister##name(               \
+      Dart_Test##name, #name, expectation);                                    \
+  void Dart_Test##name()
+
+#define UNIT_TEST_CASE(name) UNIT_TEST_CASE_WITH_EXPECTATION(name, "Pass")
+
+// The UNIT_TEST_CASE_WITH_ZONE macro is used for tests that need a custom
+// dart::Zone.
+#define UNIT_TEST_CASE_WITH_ZONE_WITH_EXPECTATION(name, expectation)           \
+  static void Dart_TestHelper##name(dart::Zone* Z);                            \
+  UNIT_TEST_CASE_WITH_EXPECTATION(name, expectation) {                         \
+    dart::Zone zone;                                                           \
+    Dart_TestHelper##name(&zone);                                              \
+  }                                                                            \
+  static void Dart_TestHelper##name(dart::Zone* Z)
+
+#define UNIT_TEST_CASE_WITH_ZONE(name)                                         \
+  UNIT_TEST_CASE_WITH_ZONE_WITH_EXPECTATION(name, "Pass")
+
+namespace dart {
+namespace compiler {
+namespace ffi {
+
+class TestCaseBase {
+ public:
+  explicit TestCaseBase(const char* name, const char* expectation);
+  virtual ~TestCaseBase() {}
+
+  const char* name() const { return name_; }
+  const char* expectation() const { return expectation_; }
+
+  virtual void Run() = 0;
+  void RunTest();
+
+  static void RunAll();
+  static void RunAllRaw();
+
+  static bool update_expectations;
+
+ private:
+  static TestCaseBase* first_;
+  static TestCaseBase* tail_;
+
+  TestCaseBase* next_;
+  const char* name_;
+  const char* expectation_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCaseBase);
+};
+
+class RawTestCase : TestCaseBase {
+ public:
+  typedef void(RunEntry)();
+
+  RawTestCase(RunEntry* run, const char* name, const char* expectation)
+      : TestCaseBase(name, expectation), run_(run) {}
+  virtual void Run();
+
+ private:
+  RunEntry* const run_;
+};
+
+}  // namespace ffi
+}  // namespace compiler
+}  // namespace dart
+
+#endif  // RUNTIME_VM_COMPILER_FFI_UNIT_TEST_H_
diff --git a/runtime/vm/compiler/ffi/unit_test_custom_zone.cc b/runtime/vm/compiler/ffi/unit_test_custom_zone.cc
new file mode 100644
index 0000000..90f01cf
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_test_custom_zone.cc
@@ -0,0 +1,45 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+#include "vm/compiler/ffi/unit_test_custom_zone.h"
+
+#include "vm/compiler/runtime_api.h"
+
+// Directly compile cc files into the custom zone, so that we do not get linker
+// errors from object files compiled against the DartVM Zone.
+#include "vm/compiler/ffi/native_calling_convention.cc"  // NOLINT
+#include "vm/compiler/ffi/native_location.cc"            // NOLINT
+#include "vm/compiler/ffi/native_type.cc"                // NOLINT
+#include "vm/zone_text_buffer.cc"                        // NOLINT
+
+namespace dart {
+
+void* ZoneAllocated::operator new(uintptr_t size, dart::Zone* zone) {
+  return reinterpret_cast<void*>(zone->AllocUnsafe(size));
+}
+
+Zone::~Zone() {
+  while (buffers_.size() > 0) {
+    free(buffers_.back());
+    buffers_.pop_back();
+  }
+}
+
+void* Zone::AllocUnsafe(intptr_t size) {
+  void* memory = malloc(size);
+  buffers_.push_back(memory);
+  return memory;
+}
+
+DART_EXPORT void Dart_PrepareToAbort() {
+  fprintf(stderr, "Dart_PrepareToAbort() not implemented!\n");
+  exit(1);
+}
+
+DART_EXPORT void Dart_DumpNativeStackTrace(void* context) {
+  fprintf(stderr, "Dart_DumpNativeStackTrace() not implemented!\n");
+  exit(1);
+}
+
+}  // namespace dart
diff --git a/runtime/vm/compiler/ffi/unit_test_custom_zone.h b/runtime/vm/compiler/ffi/unit_test_custom_zone.h
new file mode 100644
index 0000000..ac305a1
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_test_custom_zone.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+#ifndef RUNTIME_VM_COMPILER_FFI_UNIT_TEST_CUSTOM_ZONE_H_
+#define RUNTIME_VM_COMPILER_FFI_UNIT_TEST_CUSTOM_ZONE_H_
+
+#include <vector>
+
+// We use a custom zone here which doesn't depend on VM internals (e.g. handles,
+// thread, ...)
+#if defined(RUNTIME_VM_ZONE_H_)
+#error "We want our own zone implementation"
+#endif
+#define RUNTIME_VM_ZONE_H_
+
+namespace dart {
+
+class Zone {
+ public:
+  Zone() {}
+  ~Zone();
+
+  template <class ElementType>
+  inline ElementType* Alloc(intptr_t length) {
+    return static_cast<ElementType*>(AllocUnsafe(sizeof(ElementType) * length));
+  }
+
+  template <class ElementType>
+  inline ElementType* Realloc(ElementType* old_array,
+                              intptr_t old_length,
+                              intptr_t new_length) {
+    void* memory = AllocUnsafe(sizeof(ElementType) * new_length);
+    memmove(memory, old_array, sizeof(ElementType) * old_length);
+    return static_cast<ElementType*>(memory);
+  }
+
+  template <class ElementType>
+  void Free(ElementType* old_array, intptr_t len) {}
+
+  void* AllocUnsafe(intptr_t size);
+
+ private:
+  Zone(const Zone&) = delete;
+  void operator=(const Zone&) = delete;
+  std::vector<void*> buffers_;
+};
+
+}  // namespace dart
+
+#endif  // RUNTIME_VM_COMPILER_FFI_UNIT_TEST_CUSTOM_ZONE_H_
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_android.expect
new file mode 100644
index 0000000..8f237e3
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_android.expect
@@ -0,0 +1,12 @@
+v0 float
+v1 float
+v2 float
+v3 float
+v4 float
+v5 float
+v6 float
+v7 float
+S+0 float
+S+8 float
+=>
+v0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_ios.expect
new file mode 100644
index 0000000..8f237e3
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_ios.expect
@@ -0,0 +1,12 @@
+v0 float
+v1 float
+v2 float
+v3 float
+v4 float
+v5 float
+v6 float
+v7 float
+S+0 float
+S+8 float
+=>
+v0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_linux.expect
new file mode 100644
index 0000000..8f237e3
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_linux.expect
@@ -0,0 +1,12 @@
+v0 float
+v1 float
+v2 float
+v3 float
+v4 float
+v5 float
+v6 float
+v7 float
+S+0 float
+S+8 float
+=>
+v0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_macos.expect
new file mode 100644
index 0000000..8f237e3
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm64_macos.expect
@@ -0,0 +1,12 @@
+v0 float
+v1 float
+v2 float
+v3 float
+v4 float
+v5 float
+v6 float
+v7 float
+S+0 float
+S+8 float
+=>
+v0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_android.expect
new file mode 100644
index 0000000..f563dbd
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_android.expect
@@ -0,0 +1,12 @@
+r0 int32[float]
+r1 int32[float]
+r2 int32[float]
+r3 int32[float]
+S+0 float
+S+4 float
+S+8 float
+S+12 float
+S+16 float
+S+20 float
+=>
+r0 int32[float]
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_ios.expect
new file mode 100644
index 0000000..9ff44a7
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_ios.expect
@@ -0,0 +1,12 @@
+s0 float
+s1 float
+s2 float
+s3 float
+s4 float
+s5 float
+s6 float
+s7 float
+s8 float
+s9 float
+=>
+q0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_linux.expect
new file mode 100644
index 0000000..9ff44a7
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/arm_linux.expect
@@ -0,0 +1,12 @@
+s0 float
+s1 float
+s2 float
+s3 float
+s4 float
+s5 float
+s6 float
+s7 float
+s8 float
+s9 float
+=>
+q0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_android.expect
new file mode 100644
index 0000000..c4390e7
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_android.expect
@@ -0,0 +1,12 @@
+S+0 float
+S+4 float
+S+8 float
+S+12 float
+S+16 float
+S+20 float
+S+24 float
+S+28 float
+S+32 float
+S+36 float
+=>
+xmm0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_linux.expect
new file mode 100644
index 0000000..c4390e7
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_linux.expect
@@ -0,0 +1,12 @@
+S+0 float
+S+4 float
+S+8 float
+S+12 float
+S+16 float
+S+20 float
+S+24 float
+S+28 float
+S+32 float
+S+36 float
+=>
+xmm0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_win.expect
new file mode 100644
index 0000000..c4390e7
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/ia32_win.expect
@@ -0,0 +1,12 @@
+S+0 float
+S+4 float
+S+8 float
+S+12 float
+S+16 float
+S+20 float
+S+24 float
+S+28 float
+S+32 float
+S+36 float
+=>
+xmm0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_ios.expect
new file mode 100644
index 0000000..b650130
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_ios.expect
@@ -0,0 +1,12 @@
+xmm0 float
+xmm1 float
+xmm2 float
+xmm3 float
+xmm4 float
+xmm5 float
+xmm6 float
+xmm7 float
+S+0 float
+S+8 float
+=>
+xmm0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_linux.expect
new file mode 100644
index 0000000..b650130
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_linux.expect
@@ -0,0 +1,12 @@
+xmm0 float
+xmm1 float
+xmm2 float
+xmm3 float
+xmm4 float
+xmm5 float
+xmm6 float
+xmm7 float
+S+0 float
+S+8 float
+=>
+xmm0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_macos.expect
new file mode 100644
index 0000000..b650130
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_macos.expect
@@ -0,0 +1,12 @@
+xmm0 float
+xmm1 float
+xmm2 float
+xmm3 float
+xmm4 float
+xmm5 float
+xmm6 float
+xmm7 float
+S+0 float
+S+8 float
+=>
+xmm0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_win.expect
new file mode 100644
index 0000000..1244587
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/floatx10/x64_win.expect
@@ -0,0 +1,12 @@
+xmm0 float
+xmm1 float
+xmm2 float
+xmm3 float
+S+0 float
+S+8 float
+S+16 float
+S+24 float
+S+32 float
+S+40 float
+=>
+xmm0 float
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_android.expect
new file mode 100644
index 0000000..04f72e5f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_android.expect
@@ -0,0 +1,12 @@
+r0 int8
+r1 int8
+r2 int8
+r3 int8
+r4 int8
+r5 int8
+r6 int8
+r7 int8
+S+0 int8
+S+8 int8
+=>
+r0 int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_ios.expect
new file mode 100644
index 0000000..04f72e5f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_ios.expect
@@ -0,0 +1,12 @@
+r0 int8
+r1 int8
+r2 int8
+r3 int8
+r4 int8
+r5 int8
+r6 int8
+r7 int8
+S+0 int8
+S+8 int8
+=>
+r0 int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_linux.expect
new file mode 100644
index 0000000..04f72e5f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_linux.expect
@@ -0,0 +1,12 @@
+r0 int8
+r1 int8
+r2 int8
+r3 int8
+r4 int8
+r5 int8
+r6 int8
+r7 int8
+S+0 int8
+S+8 int8
+=>
+r0 int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_macos.expect
new file mode 100644
index 0000000..04f72e5f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm64_macos.expect
@@ -0,0 +1,12 @@
+r0 int8
+r1 int8
+r2 int8
+r3 int8
+r4 int8
+r5 int8
+r6 int8
+r7 int8
+S+0 int8
+S+8 int8
+=>
+r0 int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_android.expect
new file mode 100644
index 0000000..9307d2f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_android.expect
@@ -0,0 +1,12 @@
+r0 int32[int8]
+r1 int32[int8]
+r2 int32[int8]
+r3 int32[int8]
+S+0 int32[int8]
+S+4 int32[int8]
+S+8 int32[int8]
+S+12 int32[int8]
+S+16 int32[int8]
+S+20 int32[int8]
+=>
+r0 int32[int8]
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_ios.expect
new file mode 100644
index 0000000..9307d2f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_ios.expect
@@ -0,0 +1,12 @@
+r0 int32[int8]
+r1 int32[int8]
+r2 int32[int8]
+r3 int32[int8]
+S+0 int32[int8]
+S+4 int32[int8]
+S+8 int32[int8]
+S+12 int32[int8]
+S+16 int32[int8]
+S+20 int32[int8]
+=>
+r0 int32[int8]
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_linux.expect
new file mode 100644
index 0000000..9307d2f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/arm_linux.expect
@@ -0,0 +1,12 @@
+r0 int32[int8]
+r1 int32[int8]
+r2 int32[int8]
+r3 int32[int8]
+S+0 int32[int8]
+S+4 int32[int8]
+S+8 int32[int8]
+S+12 int32[int8]
+S+16 int32[int8]
+S+20 int32[int8]
+=>
+r0 int32[int8]
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_android.expect
new file mode 100644
index 0000000..bf5f6c4
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_android.expect
@@ -0,0 +1,12 @@
+S+0 int32[int8]
+S+4 int32[int8]
+S+8 int32[int8]
+S+12 int32[int8]
+S+16 int32[int8]
+S+20 int32[int8]
+S+24 int32[int8]
+S+28 int32[int8]
+S+32 int32[int8]
+S+36 int32[int8]
+=>
+eax int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_linux.expect
new file mode 100644
index 0000000..bf5f6c4
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_linux.expect
@@ -0,0 +1,12 @@
+S+0 int32[int8]
+S+4 int32[int8]
+S+8 int32[int8]
+S+12 int32[int8]
+S+16 int32[int8]
+S+20 int32[int8]
+S+24 int32[int8]
+S+28 int32[int8]
+S+32 int32[int8]
+S+36 int32[int8]
+=>
+eax int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_win.expect
new file mode 100644
index 0000000..bf5f6c4
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/ia32_win.expect
@@ -0,0 +1,12 @@
+S+0 int32[int8]
+S+4 int32[int8]
+S+8 int32[int8]
+S+12 int32[int8]
+S+16 int32[int8]
+S+20 int32[int8]
+S+24 int32[int8]
+S+28 int32[int8]
+S+32 int32[int8]
+S+36 int32[int8]
+=>
+eax int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_ios.expect
new file mode 100644
index 0000000..0bcad4b
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_ios.expect
@@ -0,0 +1,12 @@
+rdi int32[int8]
+rsi int32[int8]
+rdx int32[int8]
+rcx int32[int8]
+r8 int32[int8]
+r9 int32[int8]
+S+0 int32[int8]
+S+8 int32[int8]
+S+16 int32[int8]
+S+24 int32[int8]
+=>
+rax int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_linux.expect
new file mode 100644
index 0000000..0bcad4b
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_linux.expect
@@ -0,0 +1,12 @@
+rdi int32[int8]
+rsi int32[int8]
+rdx int32[int8]
+rcx int32[int8]
+r8 int32[int8]
+r9 int32[int8]
+S+0 int32[int8]
+S+8 int32[int8]
+S+16 int32[int8]
+S+24 int32[int8]
+=>
+rax int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_macos.expect
new file mode 100644
index 0000000..0bcad4b
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_macos.expect
@@ -0,0 +1,12 @@
+rdi int32[int8]
+rsi int32[int8]
+rdx int32[int8]
+rcx int32[int8]
+r8 int32[int8]
+r9 int32[int8]
+S+0 int32[int8]
+S+8 int32[int8]
+S+16 int32[int8]
+S+24 int32[int8]
+=>
+rax int8
diff --git a/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_win.expect
new file mode 100644
index 0000000..94704e5
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/int8x10/x64_win.expect
@@ -0,0 +1,12 @@
+rcx int8
+rdx int8
+r8 int8
+r9 int8
+S+0 int8
+S+8 int8
+S+16 int8
+S+24 int8
+S+32 int8
+S+40 int8
+=>
+rax int8
diff --git a/runtime/vm/compiler/jit/compiler.cc b/runtime/vm/compiler/jit/compiler.cc
index cd282c3..90d3903 100644
--- a/runtime/vm/compiler/jit/compiler.cc
+++ b/runtime/vm/compiler/jit/compiler.cc
@@ -620,10 +620,13 @@
           CheckIfBackgroundCompilerIsBeingStopped(optimized());
         }
 
-        // Grab read program_lock outside of potential safepoint, that lock
+        // Grab write program_lock outside of potential safepoint, that lock
         // can't be waited for inside the safepoint.
-        SafepointReadRwLocker ml(thread(),
-                                 thread()->isolate_group()->program_lock());
+        // Initially read lock was added to guard direct_subclasses field
+        // access.
+        // Read lock was upgraded to write lock to guard dependent code updates.
+        SafepointWriteRwLocker ml(thread(),
+                                  thread()->isolate_group()->program_lock());
         // We have to ensure no mutators are running, because:
         //
         //   a) We allocate an instructions object, which might cause us to
diff --git a/runtime/vm/compiler/jit/jit_call_specializer.cc b/runtime/vm/compiler/jit/jit_call_specializer.cc
index 6ce72c4..05ce2af 100644
--- a/runtime/vm/compiler/jit/jit_call_specializer.cc
+++ b/runtime/vm/compiler/jit/jit_call_specializer.cc
@@ -205,6 +205,9 @@
       }
       ASSERT(field.IsOriginal());
       field.set_is_unboxing_candidate(false);
+      Thread* thread = Thread::Current();
+      SafepointWriteRwLocker ml(thread,
+                                thread->isolate_group()->program_lock());
       field.DeoptimizeDependentCode();
     } else {
       flow_graph()->parsed_function().AddToGuardedFields(&field);
diff --git a/runtime/vm/compiler/runtime_api.h b/runtime/vm/compiler/runtime_api.h
index 7611669..ce2d164 100644
--- a/runtime/vm/compiler/runtime_api.h
+++ b/runtime/vm/compiler/runtime_api.h
@@ -288,8 +288,10 @@
 static constexpr int kWordSize = 1 << kWordSizeLog2;
 static_assert(kWordSize == sizeof(word), "kWordSize should match sizeof(word)");
 // Our compiler code currently assumes this, so formally check it.
+#if !defined(FFI_UNIT_TESTS)
 static_assert(dart::kWordSize >= kWordSize,
               "Host word size smaller than target word size");
+#endif
 
 static constexpr word kBitsPerWordLog2 = kWordSizeLog2 + kBitsPerByteLog2;
 static constexpr word kBitsPerWord = 1 << kBitsPerWordLog2;
diff --git a/runtime/vm/constants_arm64.h b/runtime/vm/constants_arm64.h
index 21319ca..898f10e 100644
--- a/runtime/vm/constants_arm64.h
+++ b/runtime/vm/constants_arm64.h
@@ -1400,7 +1400,7 @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(Instr);
 };
 
-const uword kBreakInstructionFiller = 0xD4200000D4200000L;  // brk #0; brk #0
+const uint64_t kBreakInstructionFiller = 0xD4200000D4200000L;  // brk #0; brk #0
 
 }  // namespace dart
 
diff --git a/runtime/vm/constants_x64.h b/runtime/vm/constants_x64.h
index ae421fd..80e37ab 100644
--- a/runtime/vm/constants_x64.h
+++ b/runtime/vm/constants_x64.h
@@ -473,7 +473,7 @@
 // becomes important to us.
 const int MAX_NOP_SIZE = 8;
 
-const uword kBreakInstructionFiller = 0xCCCCCCCCCCCCCCCCL;
+const uint64_t kBreakInstructionFiller = 0xCCCCCCCCCCCCCCCCL;
 
 }  // namespace dart
 
diff --git a/runtime/vm/debugger.cc b/runtime/vm/debugger.cc
index 36394b0..ceb0e2e 100644
--- a/runtime/vm/debugger.cc
+++ b/runtime/vm/debugger.cc
@@ -1919,8 +1919,11 @@
 DebuggerStackTrace* Debugger::CollectAsyncLazyStackTrace() {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
 
   Code& code = Code::Handle(zone);
+  Code& inlined_code = Code::Handle(zone);
+  Array& deopt_frame = Array::Handle(zone);
   Smi& offset = Smi::Handle(zone);
   Function& function = Function::Handle(zone);
 
@@ -1932,8 +1935,16 @@
   const auto& pc_offset_array = GrowableObjectArray::ZoneHandle(
       zone, GrowableObjectArray::New(kDefaultStackAllocation));
   bool has_async = false;
+
+  std::function<void(StackFrame*)> on_sync_frame = [&](StackFrame* frame) {
+    code = frame->LookupDartCode();
+    AppendCodeFrames(thread, isolate, zone, stack_trace, frame, &code,
+                     &inlined_code, &deopt_frame);
+  };
+
   StackTraceUtils::CollectFramesLazy(thread, code_array, pc_offset_array,
-                                     /*skip_frames=*/0, &has_async);
+                                     /*skip_frames=*/0, &on_sync_frame,
+                                     &has_async);
 
   // If the entire stack is sync, return no trace.
   if (!has_async) {
@@ -1941,11 +1952,19 @@
   }
 
   const intptr_t length = code_array.Length();
-  for (intptr_t i = stack_trace->Length(); i < length; ++i) {
+  bool async_frames = false;
+  for (intptr_t i = 0; i < length; ++i) {
     code ^= code_array.At(i);
 
     if (code.raw() == StubCode::AsynchronousGapMarker().raw()) {
       stack_trace->AddMarker(ActivationFrame::kAsyncSuspensionMarker);
+      // Once we reach a gap, the rest is async.
+      async_frames = true;
+      continue;
+    }
+
+    // Skip the sync frames since they've been added (and un-inlined) above.
+    if (!async_frames) {
       continue;
     }
 
diff --git a/runtime/vm/heap/weak_code.cc b/runtime/vm/heap/weak_code.cc
index c1a3d53..97f832a 100644
--- a/runtime/vm/heap/weak_code.cc
+++ b/runtime/vm/heap/weak_code.cc
@@ -69,6 +69,9 @@
   }
 
   UpdateArrayTo(Object::null_array());
+
+  // TODO(dartbug.com/36097): This has to walk all mutator threads when
+  // disabling code.
   // Disable all code on stack.
   Code& code = Code::Handle();
   {
diff --git a/runtime/vm/isolate_reload.cc b/runtime/vm/isolate_reload.cc
index 4df27eb..b126b1c 100644
--- a/runtime/vm/isolate_reload.cc
+++ b/runtime/vm/isolate_reload.cc
@@ -1242,6 +1242,8 @@
   Class& cls = Class::Handle();
   Array& fields = Array::Handle();
   Field& field = Field::Handle();
+  Thread* thread = Thread::Current();
+  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
   for (intptr_t cls_idx = bottom; cls_idx < top; cls_idx++) {
     if (!class_table->HasValidClassAt(cls_idx)) {
       // Skip.
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 3395587..aeacffe 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -3889,7 +3889,15 @@
 }
 
 void Class::DisableCHAOptimizedCode(const Class& subclass) {
-  ASSERT(Thread::Current()->IsMutatorThread());
+  Thread* thread = Thread::Current();
+  ASSERT(thread->IsMutatorThread());
+  // TODO(dartbug.com/36097): The program_lock acquisition has to move up the
+  // call chain to ClassFinalizer::AllocateFinalizeClass() so that:
+  //   - no two threads allocate-finalize a class at the same time(we should
+  // use the logic similar to what is used in EnsureIsAllocateFinalized()).
+  //   - code is deoptimized before we violate optimization assumptions
+  // potentially done concurrently (AddDirectSubclass/AddDirectImplementor).
+  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
   CHACodeArray a(*this);
   if (FLAG_trace_deoptimization && a.HasCodes()) {
     if (subclass.IsNull()) {
@@ -3928,7 +3936,15 @@
 #endif
 }
 
+ArrayPtr Class::dependent_code() const {
+  DEBUG_ASSERT(
+      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
+  return raw_ptr()->dependent_code_;
+}
+
 void Class::set_dependent_code(const Array& array) const {
+  DEBUG_ASSERT(
+      IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
   StorePointer(&raw_ptr()->dependent_code_, array.raw());
 }
 
@@ -10405,11 +10421,15 @@
 }
 
 ArrayPtr Field::dependent_code() const {
+  DEBUG_ASSERT(
+      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
   return raw_ptr()->dependent_code_;
 }
 
 void Field::set_dependent_code(const Array& array) const {
   ASSERT(IsOriginal());
+  DEBUG_ASSERT(
+      IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
   StorePointer(&raw_ptr()->dependent_code_, array.raw());
 }
 
@@ -11058,6 +11078,8 @@
       THR_Print("    => %s\n", GuardedPropertiesAsCString());
     }
 
+    Thread* const thread = Thread::Current();
+    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
     DeoptimizeDependentCode();
   }
 }
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 11fed21..098db27 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -1541,7 +1541,7 @@
   // Return the list of code objects that were compiled using CHA of this class.
   // These code objects will be invalidated if new subclasses of this class
   // are finalized.
-  ArrayPtr dependent_code() const { return raw_ptr()->dependent_code_; }
+  ArrayPtr dependent_code() const;
   void set_dependent_code(const Array& array) const;
 
   bool TraceAllocation(Isolate* isolate) const;
diff --git a/runtime/vm/object_reload.cc b/runtime/vm/object_reload.cc
index bea8d14..447dbc2 100644
--- a/runtime/vm/object_reload.cc
+++ b/runtime/vm/object_reload.cc
@@ -468,6 +468,8 @@
     }
   }
 
+  Thread* thread = Thread::Current();
+  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
   const Array& field_list = Array::Handle(fields());
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < field_list.Length(); i++) {
diff --git a/runtime/vm/runtime_entry.cc b/runtime/vm/runtime_entry.cc
index 0b4ceb7..f2c86a2 100644
--- a/runtime/vm/runtime_entry.cc
+++ b/runtime/vm/runtime_entry.cc
@@ -2574,15 +2574,20 @@
 
   if (Compiler::CanOptimizeFunction(thread, function)) {
     if (FLAG_background_compilation) {
-      Field& field = Field::Handle(zone, isolate->GetDeoptimizingBoxedField());
-      while (!field.IsNull()) {
-        if (FLAG_trace_optimization || FLAG_trace_field_guards) {
-          THR_Print("Lazy disabling unboxing of %s\n", field.ToCString());
+      {
+        SafepointWriteRwLocker ml(thread,
+                                  thread->isolate_group()->program_lock());
+        Field& field =
+            Field::Handle(zone, isolate->GetDeoptimizingBoxedField());
+        while (!field.IsNull()) {
+          if (FLAG_trace_optimization || FLAG_trace_field_guards) {
+            THR_Print("Lazy disabling unboxing of %s\n", field.ToCString());
+          }
+          field.set_is_unboxing_candidate(false);
+          field.DeoptimizeDependentCode();
+          // Get next field.
+          field = isolate->GetDeoptimizingBoxedField();
         }
-        field.set_is_unboxing_candidate(false);
-        field.DeoptimizeDependentCode();
-        // Get next field.
-        field = isolate->GetDeoptimizingBoxedField();
       }
       if (!BackgroundCompiler::IsDisabled(isolate,
                                           /* optimizing_compiler = */ true) &&
diff --git a/runtime/vm/stack_trace.cc b/runtime/vm/stack_trace.cc
index 572c222..5b146ff 100644
--- a/runtime/vm/stack_trace.cc
+++ b/runtime/vm/stack_trace.cc
@@ -287,6 +287,7 @@
     const GrowableObjectArray& code_array,
     const GrowableObjectArray& pc_offset_array,
     int skip_frames,
+    std::function<void(StackFrame*)>* on_sync_frames,
     bool* has_async) {
   if (has_async != nullptr) {
     *has_async = false;
@@ -326,6 +327,9 @@
     ASSERT(pc_offset > 0 && pc_offset <= code.Size());
     offset = Smi::New(pc_offset);
     pc_offset_array.Add(offset);
+    if (on_sync_frames != nullptr) {
+      (*on_sync_frames)(frame);
+    }
 
     // Either continue the loop (sync-async case) or find all await'ers and
     // return.
diff --git a/runtime/vm/stack_trace.h b/runtime/vm/stack_trace.h
index e3fd332..660746a 100644
--- a/runtime/vm/stack_trace.h
+++ b/runtime/vm/stack_trace.h
@@ -80,11 +80,15 @@
   ///       closure = closure.context[Context::kAsyncCompleterVarIndex]._future
   ///           ._resultOrListeners.callback;
   ///     }
+  ///
+  /// If [on_sync_frames] is non-nullptr, it will be called for every
+  /// synchronous frame which is collected.
   static void CollectFramesLazy(
       Thread* thread,
       const GrowableObjectArray& code_array,
       const GrowableObjectArray& pc_offset_array,
       int skip_frames,
+      std::function<void(StackFrame*)>* on_sync_frames = nullptr,
       bool* has_async = nullptr);
 
   /// Counts the number of stack frames.
diff --git a/runtime/vm/vm_sources.gni b/runtime/vm/vm_sources.gni
index fda79fb..665d37b 100644
--- a/runtime/vm/vm_sources.gni
+++ b/runtime/vm/vm_sources.gni
@@ -451,3 +451,15 @@
   "virtual_memory_test.cc",
   "zone_test.cc",
 ]
+
+constants_sources = [
+  "constants_arm.cc",
+  "constants_arm.h",
+  "constants_arm64.cc",
+  "constants_arm64.h",
+  "constants_base.h",
+  "constants_ia32.cc",
+  "constants_ia32.h",
+  "constants_x64.cc",
+  "constants_x64.h",
+]
diff --git a/sdk/lib/html/html_common/conversions_dart2js.dart b/sdk/lib/html/html_common/conversions_dart2js.dart
index c1fb0be..f0ed6d2 100644
--- a/sdk/lib/html/html_common/conversions_dart2js.dart
+++ b/sdk/lib/html/html_common/conversions_dart2js.dart
@@ -13,7 +13,29 @@
   return dict;
 }
 
-/// Converts a flat Dart map into a JavaScript object with properties.
+/// Converts values that occur within a Dart map for map conversion.
+///
+/// This includes other maps, lists, or values that don't need a conversion e.g.
+/// bool, String.
+_convertDartToNative_Value(Object? value) {
+  if (value == null) return value;
+  if (value is String || value is num || value is bool) return value;
+  if (value is Map) return convertDartToNative_Dictionary(value);
+  if (value is List) {
+    var array = JS('var', '[]');
+    value.forEach((element) {
+      JS('void', '#.push(#)', array, _convertDartToNative_Value(element));
+    });
+    value = array;
+  }
+  return value;
+}
+
+/// Converts a potentially nested Dart map to a JavaScript object with
+/// properties.
+///
+/// This method requires that the values within the map are either maps
+/// themselves, lists, or do not need a conversion.
 convertDartToNative_Dictionary(Map? dict, [void postCreate(Object? f)?]) {
   if (dict == null) return null;
   var object = JS('var', '{}');
@@ -21,7 +43,7 @@
     postCreate(object);
   }
   dict.forEach((key, value) {
-    JS('void', '#[#] = #', object, key, value);
+    JS('void', '#[#] = #', object, key, _convertDartToNative_Value(value));
   });
   return object;
 }
diff --git a/tools/VERSION b/tools/VERSION
index f08a7cd..6296136 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 12
 PATCH 0
-PRERELEASE 49
+PRERELEASE 50
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/bots/test_matrix.json b/tools/bots/test_matrix.json
index 8d4be38..582dd82 100644
--- a/tools/bots/test_matrix.json
+++ b/tools/bots/test_matrix.json
@@ -418,6 +418,9 @@
     "flutter-frontend": {
       "__comment__": "This configuration is only used for a custom test runner. If it conflicts with a new configuration you are adding, you can make this configuration more specific by adding options."
     },
+    "vm-ffi-unit-test": {
+      "__comment__": "This configuration is only used for a custom test runner. If it conflicts with a new configuration you are adding, you can make this configuration more specific by adding options."
+    },
     "unittest-asserts-no-sdk-(linux|mac|win)": {
       "options": {
         "compiler": "dartk",
@@ -1102,10 +1105,26 @@
         "vm-precomp-ffi-qemu-linux-release-arm"
       ],
       "meta": {
-        "description": "This configuration is used for running FFI tests on qemu."
+        "description": "This configuration is used for running FFI tests on qemu and FFI unit tests."
       },
       "steps": [
         {
+          "name": "build run_ffi_unit_tests",
+          "script": "tools/build.py",
+          "arguments": [
+            "--arch=x64",
+            "--mode=debug",
+            "run_ffi_unit_tests"
+          ]
+        },
+        {
+          "name": "ffi unit tests",
+          "arguments": [
+            "-nvm-ffi-unit-test",
+            "ffi_unit"
+          ]
+        },
+        {
           "name": "build dart",
           "script": "tools/build.py",
           "arguments": [
@@ -2804,7 +2823,7 @@
         "analyzer-analysis-server-linux"
       ],
       "meta": {
-        "description": "Analyze analyzer related packages."
+        "description": "Analyze repository packages."
       },
       "steps": [
         {
@@ -2816,9 +2835,9 @@
         },
         {
           "name": "analyze runtime/tools/dartfuzz",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
             "runtime/tools/dartfuzz"
           ]
         },
@@ -2827,6 +2846,7 @@
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
             "analyze",
+            "--fatal-infos",
             "pkg/analysis_server"
           ]
         },
@@ -2835,6 +2855,7 @@
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
             "analyze",
+            "--fatal-infos",
             "pkg/analysis_server_client"
           ]
         },
@@ -2843,6 +2864,7 @@
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
             "analyze",
+            "--fatal-infos",
             "pkg/analyzer"
           ]
         },
@@ -2851,6 +2873,7 @@
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
             "analyze",
+            "--fatal-infos",
             "pkg/analyzer_cli"
           ]
         },
@@ -2859,14 +2882,15 @@
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
             "analyze",
+            "--fatal-infos",
             "pkg/analyzer_plugin"
           ]
         },
         {
           "name": "analyze pkg/async_helper",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
             "pkg/async_helper"
           ]
         },
@@ -2905,26 +2929,27 @@
         },
         {
           "name": "analyze pkg/dart_internal",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
+            "--fatal-infos",
             "pkg/dart_internal"
           ]
         },
         {
           "name": "analyze pkg/dev_compiler",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
-            "--fatal-lints",
+            "analyze",
+            "--fatal-infos",
             "pkg/dev_compiler"
           ]
         },
         {
           "name": "analyze pkg/expect",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
             "pkg/expect"
           ]
         },
@@ -2962,33 +2987,36 @@
         },
         {
           "name": "analyze pkg/meta",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
+            "--fatal-infos",
             "pkg/meta"
           ]
         },
         {
           "name": "analyze pkg/native_stack_traces",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
             "pkg/native_stack_traces"
           ]
         },
         {
           "name": "analyze pkg/smith",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
+            "--fatal-infos",
             "pkg/smith"
           ]
         },
         {
           "name": "analyze pkg/sourcemap_testing",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
+            "--fatal-infos",
             "pkg/sourcemap_testing"
           ]
         },
@@ -2997,6 +3025,7 @@
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
             "analyze",
+            "--fatal-infos",
             "pkg/status_file"
           ]
         },
@@ -3005,6 +3034,7 @@
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
             "analyze",
+            "--fatal-infos",
             "pkg/telemetry"
           ]
         },
@@ -3018,25 +3048,28 @@
         },
         {
           "name": "analyze pkg/testing",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
+            "--fatal-infos",
             "pkg/testing"
           ]
         },
         {
           "name": "analyze pkg/vm",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
+            "--fatal-infos",
             "pkg/vm"
           ]
         },
         {
           "name": "analyze pkg/vm_service",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
+            "--fatal-infos",
             "pkg/vm_service"
           ]
         },
@@ -3045,14 +3078,16 @@
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
             "analyze",
+            "--fatal-infos",
             "pkg/vm_snapshot_analysis"
           ]
         },
         {
           "name": "analyze pkg/dds",
-          "script": "out/ReleaseX64/dart-sdk/bin/dartanalyzer",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
-            "--fatal-warnings",
+            "analyze",
+            "--fatal-infos",
             "pkg/dds"
           ]
         },