diff --git a/CHANGELOG.md b/CHANGELOG.md
index b0d0877..685ce1b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,14 @@
 * `LinkedList` made it explicit that elements are compared by identity,
   and updated `contains` to take advantage of this.
 
+#### `dart:html`
+
+* `EventStreamSubscription.cancel` has been updated to retain its synchronous
+  timing when running in both sound and unsound null safety modes. See issue
+  [#44157][] for more details.
+
+[#44157]: https://github.com/dart-lang/sdk/issues/44157
+
 ### Dart VM
 
 *   **Breaking Change** [#42312][]: `Dart_WeakPersistentHandle`s will no longer
@@ -117,9 +125,23 @@
 * New command `dart pub add` that adds  new dependencies to your `pubspec.yaml`.
 
   And a corresponding `dart pub remove` that removes dependencies.
+* New option `dart pub upgrade --major-versions` will update constraints in
+  your `pubspec.yaml` to match the the _resolvable_ column reported in
+  `dart pub outdated`. This allows users to easily upgrade to latest version for
+  all dependencies where this is possible, even if such upgrade requires an
+  update to the version constraint in `pubspec.yaml`.
+
+  It is also possible to only upgrade the major version for a subset of your
+  dependencies using `dart pub upgrade --major-versions <dependencies...>`.
+* New option `dart pub upgrade --null-safety` will attempt to update constraints
+  in your `pubspec.yaml`, such that only null-safety migrated versions of
+  dependencies are allowed.
 * New option `dart pub outdated --mode=null-safety` that will analyze your
   dependencies for null-safety.
 * `dart pub publish` will now check your pubspec keys for likely typos.
+* `dart pub upgrade package_foo` will fetch dependencies, but ignore the
+  `pubspec.lock` for `package_foo`, allowing users to only upgrade a subset of
+  dependencies.
 * New command `dart pub login` that logs in to pub.dev.
 * The `--server` option to `dart pub publish` and `dart pub uploader` have been
   deprecated. Use `publish_to` in your `pubspec.yaml` or set the
diff --git a/DEPS b/DEPS
index 113420e..5eb902f 100644
--- a/DEPS
+++ b/DEPS
@@ -108,7 +108,7 @@
   "glob_rev": "7c0ef8d4fa086f6b185c4dd724b700e7d7ad8f79",
   "html_rev": "22f17e97fedeacaa1e945cf84d8016284eed33a6",
   "http_io_rev": "2fa188caf7937e313026557713f7feffedd4978b",
-  "http_multi_server_rev" : "f1d1c9c024a293ab0a0e16f8b7632e87c708b448",
+  "http_multi_server_rev" : "e8c8be7f15b4fb50757ff5bf29766721fbe24fe4",
   "http_parser_rev": "5dd4d16693242049dfb43b5efa429fedbf932e98",
   "http_retry_tag": "0.1.1",
   "http_rev": "1617b728fc48f64fb0ed7dc16078c03adcc64179",
@@ -133,7 +133,7 @@
   "ply_rev": "604b32590ffad5cbb82e4afef1d305512d06ae93",
   "pool_rev": "7abe634002a1ba8a0928eded086062f1307ccfae",
   "protobuf_rev": "0d03fd588df69e9863e2a2efc0059dee8f18d5b2",
-  "pub_rev": "228e69e53862879c283c42b98086aa7536012a66",
+  "pub_rev": "8ea96121dbb3f762f63e641d49141927dc30aac1",
   "pub_semver_rev": "10569a1e867e909cf5db201f73118020453e5db8",
   "resource_rev": "6b79867d0becf5395e5819a75720963b8298e9a7",
   "root_certificates_rev": "7e5ec82c99677a2e5b95ce296c4d68b0d3378ed8",
@@ -141,7 +141,7 @@
   "shelf_static_rev": "779a6e99b320ce9ed4ff6b88bd0cdc40ea5c62c4",
   "shelf_packages_handler_tag": "2.0.0",
   "shelf_proxy_tag": "0.1.0+7",
-  "shelf_rev": "5a77d25861db91db4343b19dfe213b8992e0a837",
+  "shelf_rev": "fa5afaa38bd51dedeeaa25b7bfd8822cabbcc57f",
   "shelf_web_socket_rev": "8050a55b16faa5052a3e5d7dcdc170c59b6644f2",
   "source_map_stack_trace_rev": "1c3026f69d9771acf2f8c176a1ab750463309cce",
   "source_maps-0.9.4_rev": "38524",
diff --git a/pkg/analysis_server/lib/src/context_manager.dart b/pkg/analysis_server/lib/src/context_manager.dart
index c37c64c..62cf759 100644
--- a/pkg/analysis_server/lib/src/context_manager.dart
+++ b/pkg/analysis_server/lib/src/context_manager.dart
@@ -31,6 +31,7 @@
 import 'package:analyzer/src/task/options.dart';
 import 'package:analyzer/src/util/glob.dart';
 import 'package:analyzer/src/util/yaml.dart';
+import 'package:analyzer/src/workspace/bazel.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart' as protocol;
 import 'package:analyzer_plugin/utilities/analyzer_converter.dart';
 import 'package:path/path.dart' as pathos;
@@ -393,6 +394,11 @@
   final Map<Folder, StreamSubscription<WatchEvent>> changeSubscriptions =
       <Folder, StreamSubscription<WatchEvent>>{};
 
+  /// For each root directory stores subscriptions and watchers that we
+  /// established to detect changes to Bazel generated files.
+  final Map<Folder, _BazelWorkspaceSubscription> bazelSubscriptions =
+      <Folder, _BazelWorkspaceSubscription>{};
+
   ContextManagerImpl(
     this.resourceProvider,
     this.sdkManager,
@@ -1016,6 +1022,7 @@
       contextRoot.optionsFilePath = optionsFile.path;
     }
     info.analysisDriver = callbacks.addAnalysisDriver(folder, contextRoot);
+    _watchBazelFilesIfNeeded(folder, info.analysisDriver);
     if (optionsFile != null) {
       _analyzeAnalysisOptionsFile(info.analysisDriver, optionsFile.path);
     }
@@ -1116,6 +1123,7 @@
   /// Clean up and destroy the context associated with the given folder.
   void _destroyContext(ContextInfo info) {
     changeSubscriptions.remove(info.folder)?.cancel();
+    bazelSubscriptions.remove(info.folder)?.cancel();
     callbacks.removeContext(info.folder, _computeFlushedFiles(info));
     var wasRemoved = info.parent.children.remove(info);
     assert(wasRemoved);
@@ -1220,6 +1228,47 @@
     return rootInfo;
   }
 
+  /// Establishes watch(es) for the Bazel generated files provided in
+  /// [notification].
+  ///
+  /// Whenever the files change, we trigger re-analysis. This allows us to react
+  /// to creation/modification of files that were generated by Bazel.
+  void _handleBazelFileNotification(
+      Folder folder, BazelFileNotification notification) {
+    var fileSubscriptions = bazelSubscriptions[folder].fileSubscriptions;
+    if (fileSubscriptions.containsKey(notification.requested)) {
+      // We have already established a Watcher for this particular path.
+      return;
+    }
+    var watcher = notification.watcher(
+        pollingDelayShort: Duration(seconds: 10),
+        pollingDelayLong: Duration(seconds: 30));
+    var subscription = watcher.events.listen(_handleBazelWatchEvent);
+    fileSubscriptions[notification.requested] =
+        _BazelFilesSubscription(watcher, subscription);
+    watcher.start();
+  }
+
+  /// Notifies the drivers that a generated Bazel file has changed.
+  void _handleBazelWatchEvent(WatchEvent event) {
+    if (event.type == ChangeType.ADD) {
+      for (var driver in driverMap.values) {
+        driver.addFile(event.path);
+        // Since the file has been created after we've searched for it, the
+        // URI resolution is likely wrong, so we need to reset it.
+        driver.resetUriResolution();
+      }
+    } else if (event.type == ChangeType.MODIFY) {
+      for (var driver in driverMap.values) {
+        driver.changeFile(event.path);
+      }
+    } else if (event.type == ChangeType.REMOVE) {
+      for (var driver in driverMap.values) {
+        driver.removeFile(event.path);
+      }
+    }
+  }
+
   void _handleWatchEvent(WatchEvent event) {
     callbacks.broadcastWatchEvent(event);
     _handleWatchEventImpl(event);
@@ -1504,6 +1553,22 @@
     driver.configure(sourceFactory: sourceFactory);
   }
 
+  /// Listens to files generated by Bazel that were found or searched for.
+  ///
+  /// This is handled specially because the files are outside the package
+  /// folder, but we still want to watch for changes to them.
+  ///
+  /// Does nothing if the [driver] is not in a Bazel workspace.
+  void _watchBazelFilesIfNeeded(Folder folder, AnalysisDriver analysisDriver) {
+    var workspace = analysisDriver.analysisContext.workspace;
+    if (workspace is BazelWorkspace &&
+        !bazelSubscriptions.containsKey(folder)) {
+      var subscription = workspace.bazelCandidateFiles.listen(
+          (notification) => _handleBazelFileNotification(folder, notification));
+      bazelSubscriptions[folder] = _BazelWorkspaceSubscription(subscription);
+    }
+  }
+
   /// Create and return a source representing the given [file] within the given
   /// [driver].
   static Source createSourceInContext(AnalysisDriver driver, File file) {
@@ -1622,3 +1687,36 @@
     return _embedderLocator;
   }
 }
+
+/// A watcher with subscription used to detect changes to some file.
+class _BazelFilesSubscription {
+  final BazelFileWatcher watcher;
+  final StreamSubscription<WatchEvent> subscription;
+
+  _BazelFilesSubscription(this.watcher, this.subscription);
+
+  void cancel() {
+    subscription.cancel();
+    watcher.stop();
+  }
+}
+
+/// A subscription to notifications from a Bazel workspace.
+class _BazelWorkspaceSubscription {
+  final StreamSubscription<BazelFileNotification> workspaceSubscription;
+
+  /// For each absolute path that we searched for, provides the subscriptions
+  /// that we established to watch for changes.
+  ///
+  /// Note that the absolute path used when searching for a file is not
+  /// necessarily the actual path of the file (see [BazelWorkspace.findFile] for
+  /// details on how the files are searched).
+  final fileSubscriptions = <String, _BazelFilesSubscription>{};
+
+  _BazelWorkspaceSubscription(this.workspaceSubscription);
+
+  void cancel() {
+    workspaceSubscription.cancel();
+    fileSubscriptions.values.forEach((sub) => sub.cancel());
+  }
+}
diff --git a/pkg/analysis_server/test/analysis/bazel_changes_test.dart b/pkg/analysis_server/test/analysis/bazel_changes_test.dart
new file mode 100644
index 0000000..168f461
--- /dev/null
+++ b/pkg/analysis_server/test/analysis/bazel_changes_test.dart
@@ -0,0 +1,83 @@
+// 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 'dart:async';
+
+import 'package:analysis_server/protocol/protocol.dart';
+import 'package:analysis_server/protocol/protocol_constants.dart';
+import 'package:analysis_server/protocol/protocol_generated.dart';
+import 'package:analyzer_plugin/protocol/protocol_common.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../analysis_abstract.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(BazelChangesTest);
+  });
+}
+
+@reflectiveTest
+class BazelChangesTest extends AbstractAnalysisTest {
+  Map<String, List<AnalysisError>> filesErrors = {};
+  Completer<void> processedNotification;
+
+  @override
+  void processNotification(Notification notification) {
+    if (notification.event == ANALYSIS_NOTIFICATION_ERRORS) {
+      var decoded = AnalysisErrorsParams.fromNotification(notification);
+      filesErrors[decoded.file] = decoded.errors;
+      processedNotification?.complete();
+    }
+  }
+
+  @override
+  void setUp() {
+    super.setUp();
+
+    projectPath = convertPath('/workspaceRoot/third_party/dart/project');
+    testFile =
+        convertPath('/workspaceRoot/third_party/dart/project/lib/test.dart');
+    newFile('/workspaceRoot/WORKSPACE');
+    newFolder('/workspaceRoot/bazel-lib/project');
+    newFolder('/workspaceRoot/bazel-genfiles/project');
+  }
+
+  @override
+  void tearDown() {
+    // Make sure to destroy all the contexts and cancel all subscriptions to
+    // file watchers.
+    server.contextManager.setRoots([], []);
+
+    super.tearDown();
+  }
+
+  Future<void> test_findingFileInGenfiles() async {
+    processedNotification = Completer();
+
+    newFile(testFile, content: r'''
+import 'generated.dart';
+void main() { fun(); }
+''');
+    createProject();
+
+    // We should have some errors since the `generated.dart` is not there yet.
+    await processedNotification.future;
+    expect(filesErrors[testFile], isNotEmpty);
+
+    // Clear errors, so that we'll notice new results.
+    filesErrors.clear();
+    processedNotification = Completer();
+
+    // Simulate the creation of a generated file.
+    newFile(
+        '/workspaceRoot/bazel-genfiles/'
+        'third_party/dart/project/lib/generated.dart',
+        content: 'fun() {}');
+
+    // No errors.
+    await processedNotification.future;
+    expect(filesErrors[testFile], isEmpty);
+  }
+}
diff --git a/pkg/analysis_server/test/analysis/test_all.dart b/pkg/analysis_server/test/analysis/test_all.dart
index 1187065..3329d7f 100644
--- a/pkg/analysis_server/test/analysis/test_all.dart
+++ b/pkg/analysis_server/test/analysis/test_all.dart
@@ -4,6 +4,7 @@
 
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
+import 'bazel_changes_test.dart' as bazel_changes;
 import 'get_errors_test.dart' as get_errors;
 import 'get_hover_test.dart' as get_hover;
 import 'get_navigation_test.dart' as get_navigation;
@@ -26,6 +27,7 @@
 
 void main() {
   defineReflectiveSuite(() {
+    bazel_changes.main();
     get_errors.main();
     get_hover.main();
     get_navigation.main();
diff --git a/pkg/analyzer/lib/src/context/builder.dart b/pkg/analyzer/lib/src/context/builder.dart
index 7a43df7..c91e372 100644
--- a/pkg/analyzer/lib/src/context/builder.dart
+++ b/pkg/analyzer/lib/src/context/builder.dart
@@ -114,7 +114,10 @@
     if (builderOptions.librarySummaryPaths != null) {
       summaryData = SummaryDataStore(builderOptions.librarySummaryPaths);
     }
-    final sf = createSourceFactory(path, summaryData: summaryData);
+    Workspace workspace =
+        ContextBuilder.createWorkspace(resourceProvider, path, this);
+    final sf =
+        createSourceFactoryFromWorkspace(workspace, summaryData: summaryData);
 
     AnalysisDriver driver = AnalysisDriver(
       analysisDriverScheduler,
@@ -143,6 +146,7 @@
         resourceProvider,
         apiContextRoots.first,
         driver,
+        workspace: workspace,
       ),
     );
 
@@ -209,6 +213,15 @@
     return workspace.createSourceFactory(sdk, summaryData);
   }
 
+  SourceFactory createSourceFactoryFromWorkspace(Workspace workspace,
+      {SummaryDataStore summaryData}) {
+    DartSdk sdk = findSdk(workspace);
+    if (summaryData != null && sdk is SummaryBasedDartSdk) {
+      summaryData.addBundle(null, sdk.bundle);
+    }
+    return workspace.createSourceFactory(sdk, summaryData);
+  }
+
   /// Add any [declaredVariables] to the list of declared variables used by the
   /// given analysis [driver].
   void declareVariablesInDriver(AnalysisDriver driver) {
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver_based_analysis_context.dart b/pkg/analyzer/lib/src/dart/analysis/driver_based_analysis_context.dart
index d02bc2c..0b09d2e 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver_based_analysis_context.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver_based_analysis_context.dart
@@ -29,7 +29,9 @@
   /// to access the file system and that is based on the given analysis
   /// [driver].
   DriverBasedAnalysisContext(
-      this.resourceProvider, this.contextRoot, this.driver) {
+      this.resourceProvider, this.contextRoot, this.driver,
+      {Workspace workspace})
+      : _workspace = workspace {
     driver.analysisContext = this;
   }
 
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 1f98644..5a9f210 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -4357,10 +4357,15 @@
     List<DartType> typeArguments,
     NullabilitySuffix nullabilitySuffix,
   }) {
-    return super.instantiate(
+    var type = super.instantiate(
       typeArguments: typeArguments,
       nullabilitySuffix: nullabilitySuffix,
-    ) as FunctionType;
+    );
+    if (type is FunctionType) {
+      return type;
+    } else {
+      return _errorFunctionType(nullabilitySuffix);
+    }
   }
 }
 
diff --git a/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
index 32e61ba..3413ad8 100644
--- a/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
@@ -132,6 +132,13 @@
           name,
           _resolver.typeProvider.typeType.element,
         );
+      } else if (element is TypeAliasElement) {
+        var aliasedType = element.aliasedType;
+        if (aliasedType is InterfaceType) {
+          _resolveReceiverTypeLiteral(
+              node, aliasedType.element, nameNode, name);
+          return;
+        }
       }
     }
 
diff --git a/pkg/analyzer/lib/src/dart/resolver/property_element_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/property_element_resolver.dart
index a271757e..a649b31 100644
--- a/pkg/analyzer/lib/src/dart/resolver/property_element_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/property_element_resolver.dart
@@ -298,15 +298,24 @@
     if (target is Identifier) {
       var targetElement = target.staticElement;
       if (targetElement is ClassElement) {
-        if (isCascaded) {
-          targetElement = _resolver.typeProvider.typeType.element;
-        }
         return _resolveTargetClassElement(
           typeReference: targetElement,
+          isCascaded: isCascaded,
           propertyName: propertyName,
           hasRead: hasRead,
           hasWrite: hasWrite,
         );
+      } else if (targetElement is TypeAliasElement) {
+        var aliasedType = targetElement.aliasedType;
+        if (aliasedType is InterfaceType) {
+          return _resolveTargetClassElement(
+            typeReference: aliasedType.element,
+            isCascaded: isCascaded,
+            propertyName: propertyName,
+            hasRead: hasRead,
+            hasWrite: hasWrite,
+          );
+        }
       }
     }
 
@@ -382,10 +391,15 @@
 
   PropertyElementResolverResult _resolveTargetClassElement({
     @required ClassElement typeReference,
+    @required bool isCascaded,
     @required SimpleIdentifier propertyName,
     @required bool hasRead,
     @required bool hasWrite,
   }) {
+    if (isCascaded) {
+      typeReference = _resolver.typeProvider.typeType.element;
+    }
+
     ExecutableElement readElement;
     if (hasRead) {
       readElement = typeReference.getGetter(propertyName.name);
diff --git a/pkg/analyzer/lib/src/dart/resolver/simple_identifier_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/simple_identifier_resolver.dart
index d3b354b..785ea9f 100644
--- a/pkg/analyzer/lib/src/dart/resolver/simple_identifier_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/simple_identifier_resolver.dart
@@ -246,9 +246,8 @@
       }
       return;
     } else if (element is TypeAliasElement) {
-      if (node.inDeclarationContext() || node.parent is TypeName) {
-        // no type
-      } else {
+      if (_isExpressionIdentifier(node) ||
+          element.aliasedType is! InterfaceType) {
         node.staticType = _typeProvider.typeType;
       }
       return;
diff --git a/pkg/analyzer/lib/src/generated/element_resolver.dart b/pkg/analyzer/lib/src/generated/element_resolver.dart
index 5864421..54fb25c 100644
--- a/pkg/analyzer/lib/src/generated/element_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/element_resolver.dart
@@ -723,9 +723,14 @@
   /// returned.
   static ClassElement getTypeReference(Expression expression) {
     if (expression is Identifier) {
-      Element staticElement = expression.staticElement;
-      if (staticElement is ClassElement) {
-        return staticElement;
+      var element = expression.staticElement;
+      if (element is ClassElement) {
+        return element;
+      } else if (element is TypeAliasElement) {
+        var aliasedType = element.aliasedType;
+        if (aliasedType is InterfaceType) {
+          return aliasedType.element;
+        }
       }
     }
     return null;
diff --git a/pkg/analyzer/lib/src/summary2/type_alias.dart b/pkg/analyzer/lib/src/summary2/type_alias.dart
index f69f097..303646c 100644
--- a/pkg/analyzer/lib/src/summary2/type_alias.dart
+++ b/pkg/analyzer/lib/src/summary2/type_alias.dart
@@ -43,12 +43,8 @@
   }
 
   void genericTypeAlias(GenericTypeAlias node) {
-    var functionType = node.functionType;
-    if (functionType != null) {
-      _typeParameterList(functionType.typeParameters);
-      _formalParameterList(functionType.parameters);
-      _visit(functionType.returnType);
-    }
+    _typeParameterList(node.typeParameters);
+    _visit(node.type);
   }
 
   void _argumentList(TypeArgumentList node) {
diff --git a/pkg/analyzer/lib/src/workspace/bazel.dart b/pkg/analyzer/lib/src/workspace/bazel.dart
index da3cafa..d32be7a 100644
--- a/pkg/analyzer/lib/src/workspace/bazel.dart
+++ b/pkg/analyzer/lib/src/workspace/bazel.dart
@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'dart:async';
 import 'dart:collection';
 import 'dart:core';
 
@@ -14,8 +15,43 @@
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/util/uri.dart';
 import 'package:analyzer/src/workspace/workspace.dart';
+import 'package:meta/meta.dart';
 import 'package:path/path.dart' as path;
 import 'package:pub_semver/pub_semver.dart';
+import 'package:watcher/watcher.dart';
+
+/// Notification that we issue in [BazelWorkspace.findFile] when searching for
+/// generated files.
+///
+/// This allows clients to watch for changes to the generated files.
+class BazelFileNotification {
+  /// Candidate paths that we searched.
+  ///
+  /// If it's a singleton, then the file was found/resolved.
+  final List<String> candidates;
+
+  /// Absolute path that we tried searching for.
+  ///
+  /// This is not necessarily the path of the actual file that will be used. See
+  /// [BazelWorkspace.findFile] for details.
+  final String requested;
+
+  final ResourceProvider _provider;
+
+  BazelFileNotification(this.requested, this.candidates, this._provider);
+
+  BazelFileWatcher watcher(
+          {@required Duration pollingDelayShort,
+          @required Duration pollingDelayLong,
+          Timer Function(Duration, void Function(Timer)) timerFactory =
+              _defaultTimerFactory}) =>
+      BazelFileWatcher(candidates, _provider, pollingDelayShort,
+          pollingDelayLong, timerFactory);
+
+  static Timer _defaultTimerFactory(
+          Duration duration, void Function(Timer) callback) =>
+      Timer.periodic(duration, callback);
+}
 
 /// Instances of the class `BazelFileUriResolver` resolve `file` URI's by first
 /// resolving file uri's in the expected way, and then by looking in the
@@ -41,6 +77,140 @@
   }
 }
 
+/// Watches a list of files that should be generated by Bazel.
+///
+/// If we didn't find the file initially, we'll have more that one potential
+/// path. We'll poll them with a shorter delay waiting for at least one
+/// of the paths to become valid (we assume that users will generate the rather
+/// sooner than later since they will likely see errors due to unresolved
+/// files). Once a file appears, we switch to a different mode, where we only
+/// watch that particular file and poll it less frequently. If the file is
+/// deleted we go back to the initial mode of eager polling for all paths.
+class BazelFileWatcher {
+  /// The paths of files that we watch for.
+  ///
+  /// If it's a singleton, then the file was found/resolved by the
+  /// [BazelWorkspace].
+  final List<String> _candidates;
+
+  final _eventsController = StreamController<WatchEvent>.broadcast();
+
+  /// The time of last modification of the file under [_validPath].
+  int _lastModified;
+
+  /// How often do we poll a file that we have found.
+  final Duration _pollingDelayLong;
+
+  /// How often do we poll when none of potential files exist.
+  final Duration _pollingDelayShort;
+
+  final ResourceProvider _provider;
+
+  /// One of the [_candidates] that is valid, i.e., we found a file with that
+  /// path.
+  String _validPath;
+
+  Timer _timer;
+
+  /// Used to contruct a [Timer] for polling.
+  final Timer Function(Duration, void Function(Timer)) _timerFactory;
+
+  BazelFileWatcher(this._candidates, this._provider, this._pollingDelayShort,
+      this._pollingDelayLong, this._timerFactory);
+
+  Stream<WatchEvent> get events => _eventsController.stream;
+
+  /// Starts watching the files.
+  ///
+  /// To avoid missing events, the clients should first start listening on
+  /// [events] and then call [start].
+  void start() {
+    assert(_timer == null);
+    var info = _pollAll();
+    if (info != null) {
+      _validPath = info.path;
+      _lastModified = info.modified;
+      _setPollingDelayToLong();
+    } else {
+      _setPollingDelayToShort();
+    }
+  }
+
+  void stop() {
+    _timer.cancel();
+    _eventsController.close();
+  }
+
+  void _poll() {
+    if (_eventsController.isClosed) return;
+
+    int modified;
+    if (_validPath == null) {
+      var info = _pollAll();
+      if (info != null) {
+        _validPath = info.path;
+        modified = info.modified;
+      }
+    } else {
+      modified = _pollOne(_validPath);
+    }
+
+    // If there is no file, then we have nothing to do.
+    if (_validPath == null) return;
+
+    if (modified == null && _lastModified != null) {
+      // The file is no longer there, so let's issue a REMOVE event, unset
+      // `_validPath` and set the timer to poll more frequently.
+      _eventsController.add(WatchEvent(ChangeType.REMOVE, _validPath));
+      _validPath = null;
+      _setPollingDelayToShort();
+    } else if (modified != null && _lastModified == null) {
+      _eventsController.add(WatchEvent(ChangeType.ADD, _validPath));
+      _setPollingDelayToLong();
+    } else if (_lastModified != null && modified != _lastModified) {
+      _eventsController.add(WatchEvent(ChangeType.MODIFY, _validPath));
+    }
+    _lastModified = modified;
+  }
+
+  /// Tries polling all the possible paths.
+  ///
+  /// Will set [_validPath] and return its modified time if a file is found.
+  /// Returns [null] if nothing is found.
+  FileInfo _pollAll() {
+    assert(_validPath == null);
+    for (var path in _candidates) {
+      var modified = _pollOne(path);
+      if (modified != null) {
+        return FileInfo(path, modified);
+      }
+    }
+    return null;
+  }
+
+  /// Returns the modified time of the path or `null` if the file does not
+  /// exist.
+  int _pollOne(String path) {
+    try {
+      var file = _provider.getFile(path);
+      return file.modificationStamp;
+    } on FileSystemException catch (_) {
+      // File doesn't exist, so return null.
+      return null;
+    }
+  }
+
+  void _setPollingDelayToLong() {
+    _timer?.cancel();
+    _timer = _timerFactory(_pollingDelayLong, (_) => _poll());
+  }
+
+  void _setPollingDelayToShort() {
+    _timer?.cancel();
+    _timer = _timerFactory(_pollingDelayShort, (_) => _poll());
+  }
+}
+
 /// The [UriResolver] that can resolve `package` URIs in [BazelWorkspace].
 class BazelPackageUriResolver extends UriResolver {
   final BazelWorkspace _workspace;
@@ -189,9 +359,17 @@
   /// The absolute path to the `bazel-genfiles` folder.
   final String genfiles;
 
+  final _bazelCandidateFiles =
+      StreamController<BazelFileNotification>.broadcast();
+
   BazelWorkspace._(
       this.provider, this.root, this.readonly, this.binPaths, this.genfiles);
 
+  /// Stream of files that we tried to find along with their potential or actual
+  /// paths.
+  Stream<BazelFileNotification> get bazelCandidateFiles =>
+      _bazelCandidateFiles.stream;
+
   @override
   bool get isBazel => true;
 
@@ -224,17 +402,16 @@
       if (relative == '.') {
         return null;
       }
-      // genfiles
-      if (genfiles != null) {
-        File file = provider.getFile(context.join(genfiles, relative));
+      // First check genfiles and bin directories
+      var generatedCandidates = <String>[
+        if (genfiles != null) genfiles,
+        ...?binPaths
+      ].map((prefix) => context.join(prefix, relative));
+      for (var path in generatedCandidates) {
+        File file = provider.getFile(path);
         if (file.exists) {
-          return file;
-        }
-      }
-      // bin
-      for (String bin in binPaths) {
-        File file = provider.getFile(context.join(bin, relative));
-        if (file.exists) {
+          _bazelCandidateFiles.add(BazelFileNotification(
+              relative, generatedCandidates.toList(), provider));
           return file;
         }
       }
@@ -250,6 +427,10 @@
           return file;
         }
       }
+      // If we couldn't find the file, assume that it has not yet been
+      // generated, so send an event with all the paths that we tried.
+      _bazelCandidateFiles.add(BazelFileNotification(
+          relative, generatedCandidates.toList(), provider));
       // Not generated, return the default one.
       return writableFile;
     } catch (_) {
@@ -613,3 +794,9 @@
     }
   }
 }
+
+class FileInfo {
+  String path;
+  int modified;
+  FileInfo(this.path, this.modified);
+}
diff --git a/pkg/analyzer/pubspec.yaml b/pkg/analyzer/pubspec.yaml
index c14bbd5..7c09d2c 100644
--- a/pkg/analyzer/pubspec.yaml
+++ b/pkg/analyzer/pubspec.yaml
@@ -24,6 +24,7 @@
 dev_dependencies:
   analyzer_utilities:
     path: ../analyzer_utilities
+  async: ^2.0.0
   linter: any
   matcher: ^0.12.3
   pedantic: ^1.9.0
diff --git a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
index d07c1ac..ee34035 100644
--- a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
@@ -13,6 +13,9 @@
   defineReflectiveSuite(() {
     defineReflectiveTests(AssignmentDriverResolutionTest);
     defineReflectiveTests(AssignmentDriverResolutionWithNullSafetyTest);
+    defineReflectiveTests(
+      AssignmentDriverResolutionWithNonFunctionTypeAliasesTest,
+    );
   });
 }
 
@@ -2572,6 +2575,49 @@
 }
 
 @reflectiveTest
+class AssignmentDriverResolutionWithNonFunctionTypeAliasesTest
+    extends PubPackageResolutionTest with WithNonFunctionTypeAliasesMixin {
+  test_prefixedIdentifier_typeAlias_static_compound() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  static int get x => 0;
+  static set x(int _) {}
+}
+
+typedef B = A;
+
+void f() {
+  B.x += 2;
+}
+''');
+
+    var assignment = findNode.assignment('x += 2');
+    assertAssignment(
+      assignment,
+      readElement: findElement.getter('x'),
+      readType: 'int',
+      writeElement: findElement.setter('x'),
+      writeType: 'int',
+      operatorElement: elementMatcher(
+        numElement.getMethod('+'),
+        isLegacy: isNullSafetySdkAndLegacyLibrary,
+      ),
+      type: 'int',
+    );
+
+    var prefixed = assignment.leftHandSide as PrefixedIdentifier;
+    assertSimpleIdentifierAssignmentTarget(
+      prefixed.identifier,
+      readElement: null,
+      writeElement: null,
+      type: 'dynamic',
+    );
+
+    assertType(assignment.rightHandSide, 'int');
+  }
+}
+
+@reflectiveTest
 class AssignmentDriverResolutionWithNullSafetyTest
     extends PubPackageResolutionTest
     with WithNullSafetyMixin, AssignmentDriverResolutionTestCases {}
diff --git a/pkg/analyzer/test/src/dart/resolution/method_invocation_test.dart b/pkg/analyzer/test/src/dart/resolution/method_invocation_test.dart
index bdd82f2..4421117e 100644
--- a/pkg/analyzer/test/src/dart/resolution/method_invocation_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/method_invocation_test.dart
@@ -15,6 +15,9 @@
   defineReflectiveSuite(() {
     defineReflectiveTests(MethodInvocationResolutionTest);
     defineReflectiveTests(MethodInvocationResolutionWithNullSafetyTest);
+    defineReflectiveTests(
+      MethodInvocationResolutionWithNonFunctionTypeAliasesTest,
+    );
   });
 }
 
@@ -2342,6 +2345,60 @@
 }
 
 @reflectiveTest
+class MethodInvocationResolutionWithNonFunctionTypeAliasesTest
+    extends PubPackageResolutionTest with WithNonFunctionTypeAliasesMixin {
+  test_hasReceiver_typeAlias_staticMethod() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  static void foo(int _) {}
+}
+
+typedef B = A;
+
+void f() {
+  B.foo(0);
+}
+''');
+
+    assertMethodInvocation(
+      findNode.methodInvocation('foo(0)'),
+      findElement.method('foo'),
+      'void Function(int)',
+    );
+
+    assertTypeAliasRef(
+      findNode.simple('B.foo'),
+      findElement.typeAlias('B'),
+    );
+  }
+
+  test_hasReceiver_typeAlias_staticMethod_generic() async {
+    await assertNoErrorsInCode(r'''
+class A<T> {
+  static void foo(int _) {}
+}
+
+typedef B<T> = A<T>;
+
+void f() {
+  B.foo(0);
+}
+''');
+
+    assertMethodInvocation(
+      findNode.methodInvocation('foo(0)'),
+      findElement.method('foo'),
+      'void Function(int)',
+    );
+
+    assertTypeAliasRef(
+      findNode.simple('B.foo'),
+      findElement.typeAlias('B'),
+    );
+  }
+}
+
+@reflectiveTest
 class MethodInvocationResolutionWithNullSafetyTest
     extends PubPackageResolutionTest
     with WithNullSafetyMixin, MethodInvocationResolutionTestCases {
diff --git a/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart b/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart
index 50f5527..b952a96 100644
--- a/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart
@@ -12,6 +12,9 @@
   defineReflectiveSuite(() {
     defineReflectiveTests(PrefixedIdentifierResolutionTest);
     defineReflectiveTests(PrefixedIdentifierResolutionWithNullSafetyTest);
+    defineReflectiveTests(
+      PrefixedIdentifierResolutionWithNonFunctionTypeAliasesTest,
+    );
   });
 }
 
@@ -271,6 +274,42 @@
 }
 
 @reflectiveTest
+class PrefixedIdentifierResolutionWithNonFunctionTypeAliasesTest
+    extends PubPackageResolutionTest with WithNonFunctionTypeAliasesMixin {
+  test_hasReceiver_typeAlias_staticGetter() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  static int get foo => 0;
+}
+
+typedef B = A;
+
+void f() {
+  B.foo;
+}
+''');
+
+    assertPrefixedIdentifier(
+      findNode.prefixed('B.foo'),
+      element: findElement.getter('foo'),
+      type: 'int',
+    );
+
+    assertTypeAliasRef(
+      findNode.simple('B.foo'),
+      findElement.typeAlias('B'),
+    );
+
+    assertSimpleIdentifier(
+      findNode.simple('foo;'),
+      readElement: findElement.getter('foo'),
+      writeElement: null,
+      type: 'int',
+    );
+  }
+}
+
+@reflectiveTest
 class PrefixedIdentifierResolutionWithNullSafetyTest
     extends PrefixedIdentifierResolutionTest with WithNullSafetyMixin {
   test_deferredImportPrefix_loadLibrary_optIn_fromOptOut() async {
diff --git a/pkg/analyzer/test/src/dart/resolution/resolution.dart b/pkg/analyzer/test/src/dart/resolution/resolution.dart
index 31bed01..3b735c3 100644
--- a/pkg/analyzer/test/src/dart/resolution/resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/resolution.dart
@@ -760,6 +760,15 @@
     }
   }
 
+  /// Assert that the given [identifier] is a reference to a type alias, in the
+  /// form that is not a separate expression, e.g. in a static method
+  /// invocation like `C.staticMethod()`, or a type annotation `C c = null`.
+  void assertTypeAliasRef(
+      SimpleIdentifier identifier, TypeAliasElement expected) {
+    assertElement(identifier, expected);
+    assertTypeNull(identifier);
+  }
+
   void assertTypeArgumentTypes(
     InvocationExpression node,
     List<String> expected,
diff --git a/pkg/analyzer/test/src/diagnostics/type_alias_cannot_reference_itself_test.dart b/pkg/analyzer/test/src/diagnostics/type_alias_cannot_reference_itself_test.dart
index af8a61a..4c9ceb3 100644
--- a/pkg/analyzer/test/src/diagnostics/type_alias_cannot_reference_itself_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/type_alias_cannot_reference_itself_test.dart
@@ -10,11 +10,22 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TypeAliasCannotReferenceItselfTest);
+    defineReflectiveTests(
+      TypeAliasCannotReferenceItselfWithNonFunctionTypeAliasesTest,
+    );
   });
 }
 
 @reflectiveTest
 class TypeAliasCannotReferenceItselfTest extends PubPackageResolutionTest {
+  test_functionTypeAlias_typeParameterBounds() async {
+    await assertErrorsInCode('''
+typedef A<T extends A<int>>();
+''', [
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 30),
+    ]);
+  }
+
   test_functionTypedParameter_returnType() async {
     await assertErrorsInCode('''
 typedef A(A b());
@@ -37,6 +48,14 @@
     ]);
   }
 
+  test_genericTypeAlias_typeParameterBounds() async {
+    await assertErrorsInCode('''
+typedef A<T extends A<int>> = void Function();
+''', [
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 46),
+    ]);
+  }
+
   test_infiniteParameterBoundCycle() async {
     await assertErrorsInCode(r'''
 typedef F<X extends F<X>> = F Function();
@@ -141,12 +160,58 @@
       error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 15, 14),
     ]);
   }
+}
 
-  test_typeVariableBounds() async {
+@reflectiveTest
+class TypeAliasCannotReferenceItselfWithNonFunctionTypeAliasesTest
+    extends PubPackageResolutionTest with WithNonFunctionTypeAliasesMixin {
+  test_nonFunction_aliasedType_cycleOf2() async {
     await assertErrorsInCode('''
-typedef A<T extends A<int>>();
+typedef T1 = T2;
+typedef T2 = T1;
 ''', [
-      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 30),
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 16),
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 17, 16),
+    ]);
+  }
+
+  test_nonFunction_aliasedType_directly_functionWithIt() async {
+    await assertErrorsInCode('''
+typedef T = void Function(T);
+''', [
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 29),
+    ]);
+  }
+
+  test_nonFunction_aliasedType_directly_it_none() async {
+    await assertErrorsInCode('''
+typedef T = T;
+''', [
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 14),
+    ]);
+  }
+
+  test_nonFunction_aliasedType_directly_it_question() async {
+    await assertErrorsInCode('''
+typedef T = T?;
+''', [
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 15),
+    ]);
+  }
+
+  test_nonFunction_aliasedType_directly_ListOfIt() async {
+    await assertErrorsInCode('''
+typedef T = List<T>;
+''', [
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 20),
+    ]);
+  }
+
+  test_nonFunction_typeParameterBounds() async {
+    await assertErrorsInCode('''
+typedef T<X extends T<Never>> = List<X>;
+''', [
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 40),
     ]);
   }
 }
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 7ff0b3a..f3e7722 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -10690,7 +10690,7 @@
 typedef F<T extends F> = void Function();
 ''');
     checkElementText(library, r'''
-notSimplyBounded typedef F<T extends void Function()> = void Function();
+notSimplyBounded typedef F<T extends dynamic Function()> = void Function();
 ''');
   }
 
diff --git a/pkg/analyzer/test/src/workspace/bazel_test.dart b/pkg/analyzer/test/src/workspace/bazel_test.dart
index 2129789..f64cfc9 100644
--- a/pkg/analyzer/test/src/workspace/bazel_test.dart
+++ b/pkg/analyzer/test/src/workspace/bazel_test.dart
@@ -2,13 +2,17 @@
 // 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 'dart:async';
+
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/test_utilities/resource_provider_mixin.dart';
 import 'package:analyzer/src/workspace/bazel.dart';
+import 'package:async/async.dart';
 import 'package:meta/meta.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
+import 'package:watcher/watcher.dart';
 
 import '../../generated/test_support.dart';
 
@@ -766,6 +770,152 @@
 class BazelWorkspaceTest with ResourceProviderMixin {
   BazelWorkspace workspace;
 
+  void test_bazelFileWatcher() async {
+    _addResources([
+      '/workspace/WORKSPACE',
+    ]);
+    _MockTimer timer;
+    var timerFactory = (Duration _, void Function(Timer) callback) {
+      timer = _MockTimer(callback);
+      return timer;
+    };
+    var candidates = [
+      convertPath('/workspace/bazel-bin/my/module/test1.dart'),
+      convertPath('/workspace/bazel-genfiles/my/module/test1.dart'),
+    ];
+    var watcher = BazelFileWatcher(candidates, resourceProvider, Duration.zero,
+        Duration.zero, timerFactory);
+    var events = StreamQueue(watcher.events);
+    watcher.start();
+
+    // First do some tests with the first candidate path.
+    _addResources([candidates[0]]);
+    timer.triggerCallback();
+
+    var event = await events.next;
+    expect(event.type, ChangeType.ADD);
+    expect(event.path, candidates[0]);
+
+    modifyFile(candidates[0], 'const foo = 42;');
+    timer.triggerCallback();
+
+    event = await events.next;
+    expect(event.type, ChangeType.MODIFY);
+    expect(event.path, candidates[0]);
+
+    _deleteResources([candidates[0]]);
+    timer.triggerCallback();
+
+    event = await events.next;
+    expect(event.type, ChangeType.REMOVE);
+    expect(event.path, candidates[0]);
+
+    // Now check that if we add the *second* candidate, we'll get the
+    // notification for it.
+    _addResources([candidates[1]]);
+    timer.triggerCallback();
+
+    event = await events.next;
+    expect(event.type, ChangeType.ADD);
+    expect(event.path, candidates[1]);
+
+    watcher.stop();
+    expect(await events.rest.isEmpty, true);
+  }
+
+  void test_bazelFileWatcher_existingFile() async {
+    _addResources([
+      '/workspace/WORKSPACE',
+      '/workspace/bazel-bin/my/module/test1.dart',
+    ]);
+    BazelWorkspace workspace = BazelWorkspace.find(
+        resourceProvider, convertPath('/workspace/my/module'));
+    _MockTimer timer;
+    var timerFactory = (Duration _, void Function(Timer) callback) {
+      timer = _MockTimer(callback);
+      return timer;
+    };
+    var watcherCompleter = Completer<BazelFileWatcher>();
+    workspace.bazelCandidateFiles.listen((notification) =>
+        watcherCompleter.complete(notification.watcher(
+            pollingDelayLong: Duration.zero,
+            pollingDelayShort: Duration.zero,
+            timerFactory: timerFactory)));
+
+    var file1 =
+        workspace.findFile(convertPath('/workspace/my/module/test1.dart'));
+    expect(file1.exists, true);
+    var watcher = await watcherCompleter.future;
+    var events = StreamQueue(watcher.events);
+    watcher.start();
+
+    // Make sure that triggering the callback, will not generate extra events.
+    timer.triggerCallback();
+
+    var convertedPath =
+        convertPath('/workspace/bazel-bin/my/module/test1.dart');
+
+    // Change the file -- we should get a single MODIFY event and not an ADD
+    // event, since the file already existed.
+    modifyFile(convertedPath, 'const foo = 42;');
+    timer.triggerCallback();
+    var event = await events.next;
+
+    expect(event.type, ChangeType.MODIFY);
+    expect(event.path, convertedPath);
+
+    // But if we delete the file and then re-create it, we should get an ADD
+    // event (after the REMOVE one).
+    deleteFile(convertedPath);
+    timer.triggerCallback();
+    event = await events.next;
+
+    expect(event.type, ChangeType.REMOVE);
+    expect(event.path, convertedPath);
+
+    newFile(convertedPath);
+    timer.triggerCallback();
+    event = await events.next;
+
+    expect(event.type, ChangeType.ADD);
+    expect(event.path, convertedPath);
+
+    watcher.stop();
+    expect(await events.rest.isEmpty, true);
+  }
+
+  void test_bazelNotifications() async {
+    _addResources([
+      '/workspace/WORKSPACE',
+      '/workspace/bazel-bin/my/module/test1.dart',
+    ]);
+    BazelWorkspace workspace = BazelWorkspace.find(
+        resourceProvider, convertPath('/workspace/my/module'));
+    var notifications = StreamQueue(workspace.bazelCandidateFiles);
+
+    var file1 =
+        workspace.findFile(convertPath('/workspace/my/module/test1.dart'));
+    expect(file1.exists, true);
+    var notification = await notifications.next;
+    expect(notification.requested, convertPath('my/module/test1.dart'));
+    expect(
+        notification.candidates,
+        containsAll(
+            [convertPath('/workspace/bazel-bin/my/module/test1.dart')]));
+
+    var file2 =
+        workspace.findFile(convertPath('/workspace/my/module/test2.dart'));
+    expect(file2.exists, false);
+    notification = await notifications.next;
+    expect(notification.requested, convertPath('my/module/test2.dart'));
+    expect(
+        notification.candidates,
+        containsAll([
+          convertPath('/workspace/bazel-bin/my/module/test2.dart'),
+          convertPath('/workspace/bazel-genfiles/my/module/test2.dart'),
+        ]));
+  }
+
   void test_find_fail_notAbsolute() {
     expect(
         () =>
@@ -1015,6 +1165,17 @@
     }
   }
 
+  /// Create new files and directories from [paths].
+  void _deleteResources(List<String> paths) {
+    for (String path in paths) {
+      if (path.endsWith('/')) {
+        deleteFolder(path.substring(0, path.length - 1));
+      } else {
+        deleteFile(path);
+      }
+    }
+  }
+
   /// Expect that [BazelWorkspace.findFile], given [path], returns [equals].
   void _expectFindFile(String path, {@required String equals}) =>
       expect(workspace.findFile(convertPath(path)).path, convertPath(equals));
@@ -1031,3 +1192,20 @@
     throw StateError('Unexpected invocation of ${invocation.memberName}');
   }
 }
+
+class _MockTimer implements Timer {
+  final void Function(Timer) callback;
+
+  @override
+  bool isActive = true;
+
+  _MockTimer(this.callback);
+
+  @override
+  int get tick => throw UnimplementedError();
+
+  @override
+  void cancel() => isActive = false;
+
+  void triggerCallback() => callback(this);
+}
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index 8800d4c..87fed8f 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -5530,27 +5530,6 @@
   js_ast.Expression visitAsExpression(AsExpression node) {
     var fromExpr = node.operand;
     var jsFrom = _visitExpression(fromExpr);
-
-    // The `_EventStreamSubscription.cancel()` method dart:html returns null in
-    // weak mode. This causes unwanted warnings/failures when you turn on the
-    // weak mode warnings/errors so we remove these specific runtime casts.
-    // TODO(44157) Remove this workaround once it returns a consistent type.
-    if (_isWebLibrary(currentLibraryUri) && node.parent is ReturnStatement) {
-      var parent = node.parent;
-      while (parent != null && parent is! FunctionNode) {
-        parent = parent?.parent;
-      }
-      parent = parent?.parent;
-      if (parent is Procedure) {
-        if (parent.enclosingClass != null &&
-            parent.enclosingClass.name == '_EventStreamSubscription' &&
-            parent.name.name == 'cancel') {
-          // Ignore these casts and just emit the expression.
-          return jsFrom;
-        }
-      }
-    }
-
     var to = node.type;
     var from = fromExpr.getStaticType(_staticTypeContext);
 
diff --git a/pkg/dev_compiler/tool/dart2js_nnbd_sdk_error_golden.txt b/pkg/dev_compiler/tool/dart2js_nnbd_sdk_error_golden.txt
index d85029a..22d60a1 100644
--- a/pkg/dev_compiler/tool/dart2js_nnbd_sdk_error_golden.txt
+++ b/pkg/dev_compiler/tool/dart2js_nnbd_sdk_error_golden.txt
@@ -1,12 +1,12 @@
-ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1706|7|5|Superinterfaces don't have a valid override for '&': JSNumber.& (num Function(num)), int.& (int Function(int)).
-ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1706|7|5|Superinterfaces don't have a valid override for '<<': JSNumber.<< (num Function(num)), int.<< (int Function(int)).
-ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1706|7|5|Superinterfaces don't have a valid override for '>>': JSNumber.>> (num Function(num)), int.>> (int Function(int)).
-ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1706|7|5|Superinterfaces don't have a valid override for '\|': JSNumber.\| (num Function(num)), int.\| (int Function(int)).
-ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1706|7|5|Superinterfaces don't have a valid override for '^': JSNumber.^ (num Function(num)), int.^ (int Function(int)).
-ERROR|COMPILE_TIME_ERROR|RETURN_OF_INVALID_TYPE|lib/_internal/js_runtime/lib/interceptors.dart|1561|14|45|A value of type 'double' can't be returned from method '%' because it has a return type of 'JSNumber'.
-ERROR|COMPILE_TIME_ERROR|RETURN_OF_INVALID_TYPE|lib/_internal/js_runtime/lib/interceptors.dart|1563|14|45|A value of type 'double' can't be returned from method '%' because it has a return type of 'JSNumber'.
-ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1723|28|1|The operator '&' isn't defined for the type 'JSInt'.
-ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1725|27|1|The operator '&' isn't defined for the type 'JSInt'.
-ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1728|17|1|The operator '&' isn't defined for the type 'JSInt'.
-ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1733|18|1|The operator '&' isn't defined for the type 'JSInt'.
-ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1733|44|1|The operator '&' isn't defined for the type 'JSInt'.
+ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1718|7|5|Superinterfaces don't have a valid override for '&': JSNumber.& (num Function(num)), int.& (int Function(int)).
+ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1718|7|5|Superinterfaces don't have a valid override for '<<': JSNumber.<< (num Function(num)), int.<< (int Function(int)).
+ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1718|7|5|Superinterfaces don't have a valid override for '>>': JSNumber.>> (num Function(num)), int.>> (int Function(int)).
+ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1718|7|5|Superinterfaces don't have a valid override for '\|': JSNumber.\| (num Function(num)), int.\| (int Function(int)).
+ERROR|COMPILE_TIME_ERROR|INCONSISTENT_INHERITANCE|lib/_internal/js_runtime/lib/interceptors.dart|1718|7|5|Superinterfaces don't have a valid override for '^': JSNumber.^ (num Function(num)), int.^ (int Function(int)).
+ERROR|COMPILE_TIME_ERROR|RETURN_OF_INVALID_TYPE|lib/_internal/js_runtime/lib/interceptors.dart|1573|14|45|A value of type 'double' can't be returned from method '%' because it has a return type of 'JSNumber'.
+ERROR|COMPILE_TIME_ERROR|RETURN_OF_INVALID_TYPE|lib/_internal/js_runtime/lib/interceptors.dart|1575|14|45|A value of type 'double' can't be returned from method '%' because it has a return type of 'JSNumber'.
+ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1735|28|1|The operator '&' isn't defined for the type 'JSInt'.
+ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1737|27|1|The operator '&' isn't defined for the type 'JSInt'.
+ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1740|17|1|The operator '&' isn't defined for the type 'JSInt'.
+ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1745|18|1|The operator '&' isn't defined for the type 'JSInt'.
+ERROR|COMPILE_TIME_ERROR|UNDEFINED_OPERATOR|lib/_internal/js_runtime/lib/interceptors.dart|1745|44|1|The operator '&' isn't defined for the type 'JSInt'.
diff --git a/runtime/lib/isolate.cc b/runtime/lib/isolate.cc
index 3a41006..85286cb 100644
--- a/runtime/lib/isolate.cc
+++ b/runtime/lib/isolate.cc
@@ -634,11 +634,7 @@
     char* error = nullptr;
 
     auto group = state_->isolate_group();
-#if defined(DART_PRECOMPILED_RUNTIME)
-    Isolate* isolate = CreateWithinExistingIsolateGroupAOT(group, name, &error);
-#else
     Isolate* isolate = CreateWithinExistingIsolateGroup(group, name, &error);
-#endif
     parent_isolate_->DecrementSpawnCount();
     parent_isolate_ = nullptr;
 
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index 9f63a72..7100f1a 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -687,28 +687,17 @@
   return isolate;
 }
 
-#if defined(DART_PRECOMPILED_RUNTIME)
-static bool CloneIntoChildIsolateAOT(Thread* T,
-                                     Isolate* I,
-                                     IsolateGroup* source_isolate_group) {
-  // In AOT we speed up isolate spawning by copying donor's isolate structure.
-  if (source_isolate_group == nullptr) {
-    return false;
-  }
-  I->isolate_object_store()->Init();
-  I->isolate_object_store()->PreallocateObjects();
-  I->set_field_table(T, source_isolate_group->initial_field_table()->Clone(I));
-
-  return true;
-}
-#endif
-
 ErrorPtr Dart::InitIsolateFromSnapshot(Thread* T,
                                        Isolate* I,
                                        const uint8_t* snapshot_data,
                                        const uint8_t* snapshot_instructions,
                                        const uint8_t* kernel_buffer,
                                        intptr_t kernel_buffer_size) {
+  if (kernel_buffer != nullptr) {
+    SafepointReadRwLocker reader(T, I->group()->program_lock());
+    I->field_table()->MarkReadyToUse();
+  }
+
   Error& error = Error::Handle(T->zone());
   error = Object::Init(I, kernel_buffer, kernel_buffer_size);
   if (!error.IsNull()) {
@@ -742,7 +731,11 @@
       return error.raw();
     }
 
-    I->set_field_table(T, I->group()->initial_field_table()->Clone(I));
+    {
+      SafepointReadRwLocker reader(T, I->group()->program_lock());
+      I->set_field_table(T, I->group()->initial_field_table()->Clone(I));
+      I->field_table()->MarkReadyToUse();
+    }
 
 #if defined(SUPPORT_TIMELINE)
     if (tbes.enabled()) {
@@ -883,37 +876,58 @@
   StackZone zone(T);
   HandleScope handle_scope(T);
   bool was_child_cloned_into_existing_isolate = false;
-#if defined(DART_PRECOMPILED_RUNTIME)
-  if (CloneIntoChildIsolateAOT(T, I, source_isolate_group)) {
+  if (source_isolate_group != nullptr) {
+    I->isolate_object_store()->Init();
+    I->isolate_object_store()->PreallocateObjects();
+
+    // If a static field gets registered in [IsolateGroup::RegisterStaticField]:
+    //
+    //   * before this block it will ignore this isolate. The [Clone] of the
+    //     initial field table will pick up the new value.
+    //   * after this block it will add the new static field to this isolate.
+    {
+      SafepointReadRwLocker reader(T, source_isolate_group->program_lock());
+      I->set_field_table(T,
+                         source_isolate_group->initial_field_table()->Clone(I));
+      I->field_table()->MarkReadyToUse();
+    }
+
     was_child_cloned_into_existing_isolate = true;
   } else {
-#endif
     const Error& error = Error::Handle(
         InitIsolateFromSnapshot(T, I, snapshot_data, snapshot_instructions,
                                 kernel_buffer, kernel_buffer_size));
     if (!error.IsNull()) {
       return error.raw();
     }
-#if defined(DART_PRECOMPILED_RUNTIME)
   }
-#endif
 
   Object::VerifyBuiltinVtables();
   DEBUG_ONLY(I->heap()->Verify(kForbidMarked));
 
 #if defined(DART_PRECOMPILED_RUNTIME)
-  ASSERT(I->object_store()->build_method_extractor_code() != Code::null());
-  if (FLAG_print_llvm_constant_pool) {
-    PrintLLVMConstantPool(T, I);
-  }
+  const bool kIsAotRuntime = true;
 #else
-#if !defined(TARGET_ARCH_IA32)
-  if (I != Dart::vm_isolate()) {
-    I->object_store()->set_build_method_extractor_code(
-        Code::Handle(StubCode::GetBuildMethodExtractorStub(nullptr)));
-  }
+  const bool kIsAotRuntime = false;
 #endif
+
+  if (kIsAotRuntime || was_child_cloned_into_existing_isolate) {
+#if !defined(TARGET_ARCH_IA32)
+    ASSERT(I->object_store()->build_method_extractor_code() != Code::null());
+#endif
+#if defined(DART_PRECOMPILED_RUNTIME)
+    if (FLAG_print_llvm_constant_pool) {
+      PrintLLVMConstantPool(T, I);
+    }
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
+  } else {
+#if !defined(TARGET_ARCH_IA32)
+    if (I != Dart::vm_isolate()) {
+      I->object_store()->set_build_method_extractor_code(
+          Code::Handle(StubCode::GetBuildMethodExtractorStub(nullptr)));
+    }
+#endif  // !defined(TARGET_ARCH_IA32)
+  }
 
   I->set_ic_miss_code(StubCode::SwitchableCallMiss());
 
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index 92fa101..60f008d 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -1308,10 +1308,9 @@
   return false;
 }
 
-Isolate* CreateWithinExistingIsolateGroupAOT(IsolateGroup* group,
-                                             const char* name,
-                                             char** error) {
-#if defined(DART_PRECOMPILED_RUNTIME)
+Isolate* CreateWithinExistingIsolateGroup(IsolateGroup* group,
+                                          const char* name,
+                                          char** error) {
   API_TIMELINE_DURATION(Thread::Current());
   CHECK_NO_ISOLATE(Isolate::Current());
 
@@ -1326,171 +1325,6 @@
   ASSERT(isolate->source() == source);
 
   return isolate;
-#else
-  UNREACHABLE();
-#endif
-}
-
-Isolate* CreateWithinExistingIsolateGroup(IsolateGroup* group,
-                                          const char* name,
-                                          char** error) {
-#if !defined(DART_PRECOMPILED_RUNTIME)
-  API_TIMELINE_DURATION(Thread::Current());
-  CHECK_NO_ISOLATE(Isolate::Current());
-
-  // During isolate start we'll make a temporary anonymous group from the same
-  // [source]. Once the isolate has been fully loaded we will merge it's heap
-  // into the shared heap.
-  auto spawning_group = new IsolateGroup(group->shareable_source(),
-                                         /*isolate_group_data=*/nullptr);
-  IsolateGroup::RegisterIsolateGroup(spawning_group);
-  spawning_group->CreateHeap(
-      /*is_vm_isolate=*/false,
-      IsServiceOrKernelIsolateName(group->source()->name));
-
-  Isolate* isolate = reinterpret_cast<Isolate*>(
-      CreateIsolate(spawning_group, /*is_new_group=*/false, name,
-                    /*isolate_data=*/nullptr, error));
-  if (isolate == nullptr) return nullptr;
-
-  auto source = spawning_group->source();
-  ASSERT(isolate->source() == source);
-
-  if (source->script_kernel_buffer != nullptr) {
-    Dart_EnterScope();
-    {
-      Thread* T = Thread::Current();
-      TransitionNativeToVM transition(T);
-      HANDLESCOPE(T);
-      StackZone zone(T);
-
-      // NOTE: We do not attach a finalizer for this object, because the
-      // embedder will free it once the isolate group has shutdown.
-      const auto& td = ExternalTypedData::Handle(ExternalTypedData::New(
-          kExternalTypedDataUint8ArrayCid,
-          const_cast<uint8_t*>(source->script_kernel_buffer),
-          source->script_kernel_size, Heap::kOld));
-
-      std::unique_ptr<kernel::Program> program =
-          kernel::Program::ReadFromTypedData(td,
-                                             const_cast<const char**>(error));
-      if (program == nullptr) {
-        UNIMPLEMENTED();
-      }
-      const Object& tmp =
-          kernel::KernelLoader::LoadEntireProgram(program.get());
-
-      // If the existing isolate could spawn with a root library we should be
-      // able to do the same
-      RELEASE_ASSERT(!tmp.IsNull() && tmp.IsLibrary());
-      isolate->object_store()->set_root_library(Library::Cast(tmp));
-    }
-    Dart_ExitScope();
-  }
-
-  // If we are running in AppJIT training mode we'll have to remap class ids.
-  if (auto permutation_map = group->source()->cid_permutation_map.get()) {
-    Dart_EnterScope();
-    {
-      auto T = Thread::Current();
-      TransitionNativeToVM transition(T);
-      HANDLESCOPE(T);
-
-      // Remap all class ids loaded atm (e.g. from snapshot) and do appropriate
-      // re-hashing of constants and types.
-      ClassFinalizer::RemapClassIds(permutation_map);
-      // Types use cid's as part of their hashes.
-      ClassFinalizer::RehashTypes();
-      // Const objects use cid's as part of their hashes.
-      isolate->RehashConstants();
-    }
-    Dart_ExitScope();
-  }
-
-  auto thread = Thread::Current();
-  {
-    TransitionNativeToVM native_to_vm(thread);
-
-    // Ensure there are no helper threads running.
-    BackgroundCompiler::Stop(isolate);
-    isolate->heap()->WaitForMarkerTasks(thread);
-    isolate->heap()->WaitForSweeperTasks(thread);
-    SafepointOperationScope safepoint_operation(thread);
-    isolate->group()->ReleaseStoreBuffers();
-    RELEASE_ASSERT(isolate->heap()->old_space()->tasks() == 0);
-  }
-
-  Dart_ExitIsolate();
-  {
-    const bool kBypassSafepoint = false;
-    Thread::EnterIsolateGroupAsHelper(group, Thread::kUnknownTask,
-                                      kBypassSafepoint);
-    ASSERT(group == IsolateGroup::Current());
-
-    {
-      auto thread = Thread::Current();
-
-      // Prevent additions of new isolates to [group] until we're done.
-      group->RunWithLockedGroup([&]() {
-        // Ensure no other old space GC tasks are running and "occupy" the old
-        // space.
-        SafepointOperationScope safepoint_scope(thread);
-        {
-          auto old_space = group->heap()->old_space();
-          MonitorLocker ml(old_space->tasks_lock());
-          while (old_space->tasks() > 0) {
-            ml.Wait();
-          }
-          old_space->set_tasks(1);
-        }
-
-        // Merge the heap from [spawning_group] to [group].
-        group->heap()->MergeFrom(isolate->group()->heap());
-
-        spawning_group->UnregisterIsolate(isolate);
-        const bool shutdown_group =
-            spawning_group->UnregisterIsolateDecrementCount(isolate);
-        ASSERT(shutdown_group);
-
-        isolate->isolate_group_ = group;
-        group->RegisterIsolateLocked(isolate);
-        isolate->class_table()->shared_class_table_ =
-            group->shared_class_table();
-        isolate->set_shared_class_table(group->shared_class_table());
-
-        // Even though the mutator thread was descheduled, it will still
-        // retain its [Thread] structure with valid isolate/isolate_group
-        // pointers.
-        // If GC happens before the mutator gets scheduled again, we have to
-        // ensure the isolate group change is reflected in the threads
-        // structure.
-        ASSERT(isolate->mutator_thread() != nullptr);
-        ASSERT(isolate->mutator_thread()->isolate_group() == spawning_group);
-        isolate->mutator_thread()->isolate_group_ = group;
-
-        // Allow other old space GC tasks to run again.
-        {
-          auto old_space = group->heap()->old_space();
-          MonitorLocker ml(old_space->tasks_lock());
-          ASSERT(old_space->tasks() == 1);
-          old_space->set_tasks(0);
-          ml.NotifyAll();
-        }
-      });
-    }
-
-    Thread::ExitIsolateGroupAsHelper(kBypassSafepoint);
-  }
-
-  spawning_group->Shutdown();
-
-  Dart_EnterIsolate(Api::CastIsolate(isolate));
-  ASSERT(Thread::Current()->isolate_group() == isolate->group());
-
-  return isolate;
-#else
-  UNREACHABLE();
-#endif
 }
 
 DART_EXPORT void Dart_IsolateFlagsInitialize(Dart_IsolateFlags* flags) {
@@ -1589,7 +1423,7 @@
 
   Isolate* isolate;
 #if defined(DART_PRECOMPILED_RUNTIME)
-  isolate = CreateWithinExistingIsolateGroupAOT(member->group(), name, error);
+  isolate = CreateWithinExistingIsolateGroup(member->group(), name, error);
   if (isolate != nullptr) {
     isolate->set_origin_id(member->origin_id());
     isolate->set_init_callback_data(child_isolate_data);
diff --git a/runtime/vm/dart_api_impl.h b/runtime/vm/dart_api_impl.h
index 80f0462..7c58510 100644
--- a/runtime/vm/dart_api_impl.h
+++ b/runtime/vm/dart_api_impl.h
@@ -353,9 +353,6 @@
 Isolate* CreateWithinExistingIsolateGroup(IsolateGroup* group,
                                           const char* name,
                                           char** error);
-Isolate* CreateWithinExistingIsolateGroupAOT(IsolateGroup* group,
-                                             const char* name,
-                                             char** error);
 
 }  // namespace dart.
 
diff --git a/runtime/vm/field_table.cc b/runtime/vm/field_table.cc
index a6358a1..fe40d10 100644
--- a/runtime/vm/field_table.cc
+++ b/runtime/vm/field_table.cc
@@ -22,6 +22,25 @@
   free(table_);        // Allocated in FieldTable::Grow()
 }
 
+bool FieldTable::IsReadyToUse() const {
+  DEBUG_ASSERT(
+      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
+  return is_ready_to_use_;
+}
+
+void FieldTable::MarkReadyToUse() {
+  // The isolate will mark it's field table ready-to-use upon initialization of
+  // the isolate. Only after it was marked as ready-to-use will it participate
+  // in new static field registrations.
+  //
+  // By requiring a read lock here we ensure no other thread is is registering a
+  // new static field at this moment (it would need exlusive writer lock).
+  DEBUG_ASSERT(
+      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
+  ASSERT(!is_ready_to_use_);
+  is_ready_to_use_ = true;
+}
+
 void FieldTable::FreeOldTables() {
   while (old_tables_->length() > 0) {
     free(old_tables_->RemoveLast());
@@ -32,21 +51,27 @@
   return field_id * sizeof(InstancePtr);  // NOLINT
 }
 
-void FieldTable::Register(const Field& field) {
+bool FieldTable::Register(const Field& field, intptr_t expected_field_id) {
+  DEBUG_ASSERT(
+      IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
   ASSERT(Thread::Current()->IsMutatorThread());
+  ASSERT(is_ready_to_use_);
+
   if (free_head_ < 0) {
+    bool grown_backing_store = false;
     if (top_ == capacity_) {
       const intptr_t new_capacity = capacity_ + kCapacityIncrement;
       Grow(new_capacity);
+      grown_backing_store = true;
     }
 
     ASSERT(top_ < capacity_);
-
+    ASSERT(expected_field_id == -1 || expected_field_id == top_);
     field.set_field_id(top_);
     table_[top_] = Object::sentinel().raw();
 
     ++top_;
-    return;
+    return grown_backing_store;
   }
 
   // Reuse existing free element. This is "slow path" that should only be
@@ -55,6 +80,7 @@
   free_head_ = Smi::Value(Smi::RawCast(table_[free_head_]));
   field.set_field_id(reused_free);
   table_[reused_free] = Object::sentinel().raw();
+  return false;
 }
 
 void FieldTable::Free(intptr_t field_id) {
@@ -104,6 +130,9 @@
 }
 
 FieldTable* FieldTable::Clone(Isolate* for_isolate) {
+  DEBUG_ASSERT(
+      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
+
   FieldTable* clone = new FieldTable(for_isolate);
   auto new_table = static_cast<InstancePtr*>(
       malloc(capacity_ * sizeof(InstancePtr)));  // NOLINT
diff --git a/runtime/vm/field_table.h b/runtime/vm/field_table.h
index 4fc1ca8..4350745 100644
--- a/runtime/vm/field_table.h
+++ b/runtime/vm/field_table.h
@@ -27,10 +27,14 @@
         free_head_(-1),
         table_(nullptr),
         old_tables_(new MallocGrowableArray<InstancePtr*>()),
-        isolate_(isolate) {}
+        isolate_(isolate),
+        is_ready_to_use_(isolate == nullptr) {}
 
   ~FieldTable();
 
+  bool IsReadyToUse() const;
+  void MarkReadyToUse();
+
   intptr_t NumFieldIds() const { return top_; }
   intptr_t Capacity() const { return capacity_; }
 
@@ -43,7 +47,9 @@
 
   bool IsValidIndex(intptr_t index) const { return index >= 0 && index < top_; }
 
-  void Register(const Field& field);
+  // Returns whether registering this field caused a growth in the backing
+  // store.
+  bool Register(const Field& field, intptr_t expected_field_id = -1);
   void AllocateIndex(intptr_t index);
 
   // Static field elements are being freed only during isolate reload
@@ -89,6 +95,10 @@
   // mutator thread up-to-date.
   Isolate* isolate_;
 
+  // Whether this field table is ready to use by e.g. registering new static
+  // fields.
+  bool is_ready_to_use_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(FieldTable);
 };
 
diff --git a/runtime/vm/heap/freelist.cc b/runtime/vm/heap/freelist.cc
index 2923aee..e2fd5f8 100644
--- a/runtime/vm/heap/freelist.cc
+++ b/runtime/vm/heap/freelist.cc
@@ -373,41 +373,4 @@
   return NULL;
 }
 
-void FreeList::MergeFrom(FreeList* donor, bool is_protected) {
-  // The [other] free list is from a dying isolate. There are no other threads
-  // accessing it, so there is no need to lock here.
-  MutexLocker ml(&mutex_);
-  for (intptr_t i = 0; i < (kNumLists + 1); ++i) {
-    FreeListElement* donor_head = donor->free_lists_[i];
-    if (donor_head != nullptr) {
-      // If we didn't have a freelist element before we have to set the bit now,
-      // since we will get 1+ elements from [other].
-      FreeListElement* old_head = free_lists_[i];
-      if (old_head == nullptr && i != kNumLists) {
-        free_map_.Set(i, true);
-      }
-
-      // Chain other's list in.
-      FreeListElement* last = donor_head;
-      while (last->next() != nullptr) {
-        last = last->next();
-      }
-
-      if (is_protected) {
-        VirtualMemory::Protect(reinterpret_cast<void*>(last), sizeof(*last),
-                               VirtualMemory::kReadWrite);
-      }
-      last->set_next(old_head);
-      if (is_protected) {
-        VirtualMemory::Protect(reinterpret_cast<void*>(last), sizeof(*last),
-                               VirtualMemory::kReadExecute);
-      }
-      free_lists_[i] = donor_head;
-    }
-  }
-
-  last_free_small_size_ =
-      Utils::Maximum(last_free_small_size_, donor->last_free_small_size_);
-}
-
 }  // namespace dart
diff --git a/runtime/vm/heap/freelist.h b/runtime/vm/heap/freelist.h
index 677a0f2..b868c19 100644
--- a/runtime/vm/heap/freelist.h
+++ b/runtime/vm/heap/freelist.h
@@ -154,8 +154,6 @@
   void set_end(uword value) { end_ = value; }
   void AddUnaccountedSize(intptr_t size) { unaccounted_size_ += size; }
 
-  void MergeFrom(FreeList* donor, bool is_protected);
-
  private:
   static const int kNumLists = 128;
   static const intptr_t kInitialFreeListSearchBudget = 1000;
diff --git a/runtime/vm/heap/heap.cc b/runtime/vm/heap/heap.cc
index a1d5866..e5c2426 100644
--- a/runtime/vm/heap/heap.cc
+++ b/runtime/vm/heap/heap.cc
@@ -717,30 +717,6 @@
   gc_on_nth_allocation_ = num_allocations;
 }
 
-void Heap::MergeFrom(Heap* donor) {
-  ASSERT(!donor->read_only_);
-  ASSERT(donor->old_space()->tasks() == 0);
-
-  new_space_.MergeFrom(donor->new_space());
-  old_space_.MergeFrom(donor->old_space());
-
-  for (intptr_t i = 0; i < kNumWeakSelectors; ++i) {
-    // The new space rehashing should not be necessary.
-    new_weak_tables_[i]->MergeFrom(donor->new_weak_tables_[i]);
-    old_weak_tables_[i]->MergeFrom(donor->old_weak_tables_[i]);
-  }
-
-  StoreBufferBlock* block =
-      donor->isolate_group()->store_buffer()->TakeBlocks();
-  while (block != nullptr) {
-    StoreBufferBlock* next = block->next();
-    block->set_next(nullptr);
-    isolate_group()->store_buffer()->PushBlock(block,
-                                               StoreBuffer::kIgnoreThreshold);
-    block = next;
-  }
-}
-
 void Heap::CollectForDebugging() {
   if (gc_on_nth_allocation_ == kNoForcedGarbageCollection) return;
   if (Thread::Current()->IsAtSafepoint()) {
diff --git a/runtime/vm/heap/heap.h b/runtime/vm/heap/heap.h
index 026d793..f303a15 100644
--- a/runtime/vm/heap/heap.h
+++ b/runtime/vm/heap/heap.h
@@ -322,8 +322,6 @@
 
   void CollectOnNthAllocation(intptr_t num_allocations);
 
-  void MergeFrom(Heap* donor);
-
  private:
   class GCStats : public ValueObject {
    public:
diff --git a/runtime/vm/heap/pages.cc b/runtime/vm/heap/pages.cc
index d3b62fa..39180e8 100644
--- a/runtime/vm/heap/pages.cc
+++ b/runtime/vm/heap/pages.cc
@@ -1447,95 +1447,6 @@
   return false;
 }
 
-static void AppendList(OldPage** pages,
-                       OldPage** pages_tail,
-                       OldPage** other_pages,
-                       OldPage** other_pages_tail) {
-  ASSERT((*pages == nullptr) == (*pages_tail == nullptr));
-  ASSERT((*other_pages == nullptr) == (*other_pages_tail == nullptr));
-
-  if (*other_pages != nullptr) {
-    if (*pages_tail == nullptr) {
-      *pages = *other_pages;
-      *pages_tail = *other_pages_tail;
-    } else {
-      const bool is_execute = FLAG_write_protect_code &&
-                              (*pages_tail)->type() == OldPage::kExecutable;
-      if (is_execute) {
-        (*pages_tail)->WriteProtect(false);
-      }
-      (*pages_tail)->set_next(*other_pages);
-      if (is_execute) {
-        (*pages_tail)->WriteProtect(true);
-      }
-      *pages_tail = *other_pages_tail;
-    }
-    *other_pages = nullptr;
-    *other_pages_tail = nullptr;
-  }
-}
-
-static void EnsureEqualImagePages(OldPage* pages, OldPage* other_pages) {
-#if defined(DEBUG)
-  while (pages != nullptr) {
-    ASSERT((pages == nullptr) == (other_pages == nullptr));
-    ASSERT(pages->object_start() == other_pages->object_start());
-    ASSERT(pages->object_end() == other_pages->object_end());
-    pages = pages->next();
-    other_pages = other_pages->next();
-  }
-#endif
-}
-
-void PageSpace::MergeFrom(PageSpace* donor) {
-  donor->AbandonBumpAllocation();
-
-  ASSERT(donor->tasks_ == 0);
-  ASSERT(donor->concurrent_marker_tasks_ == 0);
-  ASSERT(donor->phase_ == kDone);
-  DEBUG_ASSERT(donor->iterating_thread_ == nullptr);
-  ASSERT(donor->marker_ == nullptr);
-
-  for (intptr_t i = 0; i < num_freelists_; ++i) {
-    ASSERT(donor->freelists_[i].top() == 0);
-    ASSERT(donor->freelists_[i].end() == 0);
-    const bool is_protected =
-        FLAG_write_protect_code && i == OldPage::kExecutable;
-    freelists_[i].MergeFrom(&donor->freelists_[i], is_protected);
-    donor->freelists_[i].Reset();
-  }
-
-  // The freelist locks will be taken in MergeOtherFreelist above, and the
-  // locking order is the freelist locks are taken before the page list locks,
-  // so don't take the pages lock until after MergeOtherFreelist.
-  MutexLocker ml(&pages_lock_);
-  MutexLocker ml2(&donor->pages_lock_);
-
-  AppendList(&pages_, &pages_tail_, &donor->pages_, &donor->pages_tail_);
-  AppendList(&exec_pages_, &exec_pages_tail_, &donor->exec_pages_,
-             &donor->exec_pages_tail_);
-  AppendList(&large_pages_, &large_pages_tail_, &donor->large_pages_,
-             &donor->large_pages_tail_);
-  // We intentionall do not merge [image_pages_] beause [this] and [other] have
-  // the same mmap()ed image page areas.
-  EnsureEqualImagePages(image_pages_, donor->image_pages_);
-
-  // We intentionaly do not increase [max_capacity_in_words_] because this can
-  // lead [max_capacity_in_words_] to become larger and larger and eventually
-  // wrap-around and become negative.
-  allocated_black_in_words_ += donor->allocated_black_in_words_;
-  gc_time_micros_ += donor->gc_time_micros_;
-  collections_ += donor->collections_;
-
-  usage_.capacity_in_words += donor->usage_.capacity_in_words;
-  usage_.used_in_words += donor->usage_.used_in_words;
-  usage_.external_in_words += donor->usage_.external_in_words;
-
-  page_space_controller_.MergeFrom(&donor->page_space_controller_);
-
-  ASSERT(FLAG_concurrent_mark || donor->enable_concurrent_mark_ == false);
-}
-
 PageSpaceController::PageSpaceController(Heap* heap,
                                          int heap_growth_ratio,
                                          int heap_growth_max,
@@ -1771,12 +1682,6 @@
   // TODO(rmacnak): Hasten the soft threshold at some discount?
 }
 
-void PageSpaceController::MergeFrom(PageSpaceController* donor) {
-  last_usage_.capacity_in_words += donor->last_usage_.capacity_in_words;
-  last_usage_.used_in_words += donor->last_usage_.used_in_words;
-  last_usage_.external_in_words += donor->last_usage_.external_in_words;
-}
-
 void PageSpaceGarbageCollectionHistory::AddGarbageCollectionTime(int64_t start,
                                                                  int64_t end) {
   Entry entry;
diff --git a/runtime/vm/heap/pages.h b/runtime/vm/heap/pages.h
index a786f78..434ad7f 100644
--- a/runtime/vm/heap/pages.h
+++ b/runtime/vm/heap/pages.h
@@ -240,8 +240,6 @@
   friend class PageSpace;  // For MergeOtherPageSpaceController
 
   void RecordUpdate(SpaceUsage before, SpaceUsage after, const char* reason);
-  void MergeFrom(PageSpaceController* donor);
-
   void RecordUpdate(SpaceUsage before,
                     SpaceUsage after,
                     intptr_t growth_in_pages,
@@ -489,8 +487,6 @@
 
   bool IsObjectFromImagePages(ObjectPtr object);
 
-  void MergeFrom(PageSpace* donor);
-
  private:
   // Ids for time and data records in Heap::GCStats.
   enum {
diff --git a/runtime/vm/heap/scavenger.cc b/runtime/vm/heap/scavenger.cc
index 3f6f09d..f22ab54 100644
--- a/runtime/vm/heap/scavenger.cc
+++ b/runtime/vm/heap/scavenger.cc
@@ -715,19 +715,6 @@
   tail_ = tail;
 }
 
-void SemiSpace::MergeFrom(SemiSpace* donor) {
-  for (NewPage* page = donor->head_; page != nullptr; page = page->next()) {
-    page->Release();
-  }
-
-  AddList(donor->head_, donor->tail_);
-  capacity_in_words_ += donor->capacity_in_words_;
-
-  donor->head_ = nullptr;
-  donor->tail_ = nullptr;
-  donor->capacity_in_words_ = 0;
-}
-
 // The initial estimate of how many words we can scavenge per microsecond (usage
 // before / scavenge time). This is a conservative value observed running
 // Flutter on a Nexus 4. After the first scavenge, we instead use a value based
@@ -1721,13 +1708,4 @@
   ASSERT((UsedInWords() == 0) || failed_to_promote_);
 }
 
-void Scavenger::MergeFrom(Scavenger* donor) {
-  MutexLocker ml(&space_lock_);
-  MutexLocker ml2(&donor->space_lock_);
-  to_->MergeFrom(donor->to_);
-
-  external_size_ += donor->external_size_;
-  donor->external_size_ = 0;
-}
-
 }  // namespace dart
diff --git a/runtime/vm/heap/scavenger.h b/runtime/vm/heap/scavenger.h
index 5e7486b..785825e 100644
--- a/runtime/vm/heap/scavenger.h
+++ b/runtime/vm/heap/scavenger.h
@@ -184,7 +184,6 @@
   NewPage* head() const { return head_; }
 
   void AddList(NewPage* head, NewPage* tail);
-  void MergeFrom(SemiSpace* donor);
 
  private:
   // Size of NewPages in this semi-space.
@@ -281,8 +280,6 @@
   // Promote all live objects.
   void Evacuate();
 
-  void MergeFrom(Scavenger* donor);
-
   int64_t UsedInWords() const {
     MutexLocker ml(&space_lock_);
     return to_->capacity_in_words();
diff --git a/runtime/vm/heap/weak_table.cc b/runtime/vm/heap/weak_table.cc
index fdb0a7d..4070590 100644
--- a/runtime/vm/heap/weak_table.cc
+++ b/runtime/vm/heap/weak_table.cc
@@ -140,12 +140,4 @@
   free(old_data);
 }
 
-void WeakTable::MergeFrom(WeakTable* donor) {
-  for (intptr_t i = 0; i < donor->size(); i++) {
-    if (donor->IsValidEntryAtExclusive(i)) {
-      SetValueExclusive(donor->ObjectAtExclusive(i), ValueIndex(i));
-    }
-  }
-}
-
 }  // namespace dart
diff --git a/runtime/vm/heap/weak_table.h b/runtime/vm/heap/weak_table.h
index c7728b0..c72d773 100644
--- a/runtime/vm/heap/weak_table.h
+++ b/runtime/vm/heap/weak_table.h
@@ -133,8 +133,6 @@
 
   void Reset();
 
-  void MergeFrom(WeakTable* donor);
-
  private:
   enum {
     kObjectOffset = 0,
diff --git a/runtime/vm/isolate.cc b/runtime/vm/isolate.cc
index 4500d86..7f229b7 100644
--- a/runtime/vm/isolate.cc
+++ b/runtime/vm/isolate.cc
@@ -345,11 +345,7 @@
       safepoint_handler_(new SafepointHandler(this)),
       shared_class_table_(new SharedClassTable()),
       object_store_(object_store),
-#if defined(DART_PRECOMPILED_RUNTIME)
       class_table_(new ClassTable(shared_class_table_.get())),
-#else
-      class_table_(nullptr),
-#endif
       store_buffer_(new StoreBuffer()),
       heap_(nullptr),
       saved_unlinked_calls_(Array::null()),
@@ -393,14 +389,7 @@
 
 IsolateGroup::IsolateGroup(std::shared_ptr<IsolateGroupSource> source,
                            void* embedder_data)
-    : IsolateGroup(source,
-                   embedder_data,
-#if !defined(DART_PRECOMPILED_RUNTIME)
-                   // in JIT, with --enable_isolate_groups keep object store
-                   // on isolate, rather than on isolate group
-                   FLAG_enable_isolate_groups ? nullptr :
-#endif
-                                              new ObjectStore()) {
+    : IsolateGroup(source, embedder_data, new ObjectStore()) {
   if (object_store() != nullptr) {
     object_store()->InitStubs();
   }
@@ -908,15 +897,31 @@
   ASSERT(program_lock()->IsCurrentThreadWriter());
 
   ASSERT(field.is_static());
-  initial_field_table()->Register(field);
-  initial_field_table()->SetAt(field.field_id(), initial_value.raw());
+  const bool need_to_grow_backing_store =
+      initial_field_table()->Register(field);
+  const intptr_t field_id = field.field_id();
+  initial_field_table()->SetAt(field_id, initial_value.raw());
 
-  // TODO(dartbug.com/36097): When we start sharing the object stores (and
-  // therefore libraries, classes, fields) we'll have to register the initial
-  // static field value in all isolates.
-  auto current = Isolate::Current();
-  current->field_table()->AllocateIndex(field.field_id());
-  current->field_table()->SetAt(field.field_id(), initial_value.raw());
+  if (need_to_grow_backing_store) {
+    // We have to stop other isolates from accessing their field state, since
+    // we'll have to grow the backing store.
+    SafepointOperationScope ops(Thread::Current());
+    for (auto isolate : isolates_) {
+      auto field_table = isolate->field_table();
+      if (field_table->IsReadyToUse()) {
+        field_table->Register(field, field_id);
+        field_table->SetAt(field_id, initial_value.raw());
+      }
+    }
+  } else {
+    for (auto isolate : isolates_) {
+      auto field_table = isolate->field_table();
+      if (field_table->IsReadyToUse()) {
+        field_table->Register(field, field_id);
+        field_table->SetAt(field_id, initial_value.raw());
+      }
+    }
+  }
 }
 
 void Isolate::RehashConstants() {
@@ -1636,11 +1641,7 @@
       isolate_object_store_(
           new IsolateObjectStore(isolate_group->object_store())),
       object_store_shared_ptr_(isolate_group->object_store_shared_ptr()),
-#if defined(DART_PRECOMPILED_RUNTIME)
       class_table_(isolate_group->class_table_shared_ptr()),
-#else
-      class_table_(new ClassTable(shared_class_table_)),
-#endif
 #if !defined(DART_PRECOMPILED_RUNTIME)
       native_callback_trampolines_(),
 #endif
@@ -1773,12 +1774,7 @@
     // Non-vm isolates need to have isolate object store initialized is that
     // exit_listeners have to be null-initialized as they will be used if
     // we fail to create isolate below, have to do low level shutdown.
-    if (result->object_store() == nullptr) {
-      // in JIT with --enable-isolate-groups each isolate still
-      // has to have its own object store
-      result->set_object_store(new ObjectStore());
-      result->object_store()->InitStubs();
-    }
+    ASSERT(result->object_store() != nullptr);
     result->isolate_object_store()->Init();
   }
 
diff --git a/runtime/vm/isolate.h b/runtime/vm/isolate.h
index e88229a..a3b1b8a 100644
--- a/runtime/vm/isolate.h
+++ b/runtime/vm/isolate.h
@@ -718,8 +718,8 @@
   uint64_t id_ = 0;
 
   std::unique_ptr<SharedClassTable> shared_class_table_;
-  std::shared_ptr<ObjectStore> object_store_;  // nullptr in JIT mode
-  std::shared_ptr<ClassTable> class_table_;    // nullptr in JIT mode
+  std::shared_ptr<ObjectStore> object_store_;
+  std::shared_ptr<ClassTable> class_table_;
   std::unique_ptr<StoreBuffer> store_buffer_;
   std::unique_ptr<Heap> heap_;
   std::unique_ptr<DispatchTable> dispatch_table_;
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index e673c0a..acb3646 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -10731,16 +10731,23 @@
 
 void Field::SetStaticValue(const Instance& value,
                            bool save_initial_value) const {
-  ASSERT(Thread::Current()->IsMutatorThread());
+  auto thread = Thread::Current();
+  ASSERT(thread->IsMutatorThread());
 
   ASSERT(is_static());  // Valid only for static dart fields.
-  Isolate* isolate = Isolate::Current();
   const intptr_t id = field_id();
   ASSERT(id >= 0);
-  isolate->field_table()->SetAt(id, value.raw());
+
+  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
+  thread->isolate()->field_table()->SetAt(id, value.raw());
   if (save_initial_value) {
+    // TODO(https://dartbug.com/36097): We should re-visit call-sites where
+    // `save_initial_value == true` and try to have a different path. This
+    // method should only modify the isolate-local field state and not modify
+    // the initial field table.
 #if !defined(DART_PRECOMPILED_RUNTIME)
-    isolate->group()->initial_field_table()->SetAt(field_id(), value.raw());
+    thread->isolate_group()->initial_field_table()->SetAt(field_id(),
+                                                          value.raw());
 #endif
   }
 }
diff --git a/runtime/vm/object_reload.cc b/runtime/vm/object_reload.cc
index 907dda1..4aab7f8 100644
--- a/runtime/vm/object_reload.cc
+++ b/runtime/vm/object_reload.cc
@@ -219,6 +219,12 @@
           if (update_values && !field.is_const()) {
             // Make new field point to the old field value so that both
             // old and new code see and update same value.
+            //
+            // TODO(https://dartbug.com/36097): Once we look into enabling
+            // hot-reload with --enable-isolate-groups we have to do this
+            // for all isolates.
+            reload_context->isolate()->group()->initial_field_table()->Free(
+                field.field_id());
             reload_context->isolate()->field_table()->Free(field.field_id());
             field.set_field_id(old_field.field_id());
           }
diff --git a/runtime/vm/unit_test.cc b/runtime/vm/unit_test.cc
index 52f46f8..3364072 100644
--- a/runtime/vm/unit_test.cc
+++ b/runtime/vm/unit_test.cc
@@ -164,13 +164,8 @@
                                                 void* group_data,
                                                 void* isolate_data) {
   char* error;
-#if defined(DART_PRECOMPILED_RUNTIME)
-  Isolate* result = CreateWithinExistingIsolateGroupAOT(
-      reinterpret_cast<Isolate*>(parent)->group(), name, &error);
-#else
   Isolate* result = CreateWithinExistingIsolateGroup(
       reinterpret_cast<Isolate*>(parent)->group(), name, &error);
-#endif
   if (error != nullptr) {
     OS::PrintErr("CreateTestIsolateInGroup failed: %s\n", error);
     free(error);
diff --git a/sdk/lib/_internal/js_runtime/lib/js_array.dart b/sdk/lib/_internal/js_runtime/lib/js_array.dart
index 93bd80c..ffefd1f 100644
--- a/sdk/lib/_internal/js_runtime/lib/js_array.dart
+++ b/sdk/lib/_internal/js_runtime/lib/js_array.dart
@@ -282,15 +282,27 @@
   }
 
   void addAll(Iterable<E> collection) {
-    int i = this.length;
     checkGrowable('addAll');
+    if (collection is JSArray) {
+      _addAllFromArray(JS('', '#', collection));
+      return;
+    }
+    int i = this.length;
     for (E e in collection) {
-      assert(
-          i++ == this.length || (throw new ConcurrentModificationError(this)));
+      assert(i++ == this.length || (throw ConcurrentModificationError(this)));
       JS('void', r'#.push(#)', this, e);
     }
   }
 
+  void _addAllFromArray(JSArray array) {
+    int len = array.length;
+    if (len == 0) return;
+    if (identical(this, array)) throw ConcurrentModificationError(this);
+    for (int i = 0; i < len; i++) {
+      JS('', '#.push(#[#])', this, array, i);
+    }
+  }
+
   void clear() {
     length = 0;
   }
diff --git a/sdk/lib/html/dart2js/html_dart2js.dart b/sdk/lib/html/dart2js/html_dart2js.dart
index a79aff6..bc7bdfb 100644
--- a/sdk/lib/html/dart2js/html_dart2js.dart
+++ b/sdk/lib/html/dart2js/html_dart2js.dart
@@ -37285,18 +37285,13 @@
   }
 
   Future cancel() {
-    // Check for strong mode. This function can no longer return null in strong
-    // mode, so only return null in weak mode to preserve synchronous timing.
-    // See issue 41653 for more details.
-    dynamic emptyFuture =
-        typeAcceptsNull<Event>() ? null : Future<void>.value();
-    if (_canceled) return emptyFuture as Future;
+    if (_canceled) return nullFuture;
 
     _unlisten();
     // Clear out the target to indicate this is complete.
     _target = null;
     _onData = null;
-    return emptyFuture as Future;
+    return nullFuture;
   }
 
   bool get _canceled => _target == null;
diff --git a/tools/VERSION b/tools/VERSION
index 84ed07b..e263e32 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 12
 PATCH 0
-PRERELEASE 135
+PRERELEASE 136
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/dom/src/EventStreamProvider.dart b/tools/dom/src/EventStreamProvider.dart
index fe01be9..feadc26 100644
--- a/tools/dom/src/EventStreamProvider.dart
+++ b/tools/dom/src/EventStreamProvider.dart
@@ -248,18 +248,13 @@
   }
 
   Future cancel() {
-    // Check for strong mode. This function can no longer return null in strong
-    // mode, so only return null in weak mode to preserve synchronous timing.
-    // See issue 41653 for more details.
-    dynamic emptyFuture =
-        typeAcceptsNull<Event>() ? null : Future<void>.value();
-    if (_canceled) return emptyFuture as Future;
+    if (_canceled) return nullFuture;
 
     _unlisten();
     // Clear out the target to indicate this is complete.
     _target = null;
     _onData = null;
-    return emptyFuture as Future;
+    return nullFuture;
   }
 
   bool get _canceled => _target == null;