diff --git a/DEPS b/DEPS
index 519ade5d..d45fcd5 100644
--- a/DEPS
+++ b/DEPS
@@ -69,7 +69,7 @@
 
   # Revisions of /third_party/* dependencies.
   "args_tag": "1.6.0",
-  "async_rev": "6d2de25f208b011d79d056115256d3840229723b",
+  "async_rev": "695b3ac280f107c84adf7488743abfdfaaeea68f",
   "bazel_worker_rev": "26680d5e249b249c7216ab2fed0ac8ed4ee285c5",
   "benchmark_harness_rev": "ec6b646f5443faa871e126ac1ba248c94ca06257",
   "boolean_selector_rev": "665e6921ab246569420376f827bff4585dff0b14",
@@ -101,7 +101,7 @@
 "dart_style_tag": "1.3.9",  # Please see the note above before updating.
 
   "chromedriver_tag": "83.0.4103.39",
-  "dartdoc_rev" : "72c69f8659ce8823ce2dde9a4f758b0fa617ab5e",
+  "dartdoc_rev" : "6935dcd8f2d78cf1797e6365b4b71505e6579659",
   "ffi_rev": "a90bd424116fb6f416337db67425171f2dc4c98f",
   "fixnum_rev": "16d3890c6dc82ca629659da1934e412292508bba",
   "glob_rev": "e9f4e6b7ae8abe5071461cf8f47191bb19cf7ef6",
@@ -147,7 +147,7 @@
   "source_maps_rev": "53eb92ccfe6e64924054f83038a534b959b12b3e",
   "source_span_rev": "cc7c4288a83f71ecef3414199947b52a8c112c65",
   "sse_tag": "e5cf68975e8e87171a3dc297577aa073454a91dc",
-  "stack_trace_tag": "45319bfd2a6da228d8c32b06e1da02ad199373c7",
+  "stack_trace_tag": "c9c867fa9d5b9c8a059e33d3efe759698aa49d60",
   "stagehand_tag": "v3.3.9",
   "stream_channel_tag": "d7251e61253ec389ee6e045ee1042311bced8f1d",
   "string_scanner_rev": "1b63e6e5db5933d7be0a45da6e1129fe00262734",
diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index ba3883d..990feb4 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -535,6 +535,7 @@
   HintCode.NULL_AWARE_BEFORE_OPERATOR,
   HintCode.NULL_AWARE_IN_CONDITION,
   HintCode.NULL_AWARE_IN_LOGICAL_OPERATOR,
+  HintCode.NULL_CHECK_ALWAYS_FAILS,
   HintCode.NULLABLE_TYPE_IN_CATCH_CLAUSE,
   HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE,
   HintCode.OVERRIDE_ON_NON_OVERRIDING_FIELD,
diff --git a/pkg/analyzer/lib/src/dart/error/hint_codes.dart b/pkg/analyzer/lib/src/dart/error/hint_codes.dart
index 3688028..a9eae73 100644
--- a/pkg/analyzer/lib/src/dart/error/hint_codes.dart
+++ b/pkg/analyzer/lib/src/dart/error/hint_codes.dart
@@ -1435,6 +1435,15 @@
           "as an operand of a logical operator.");
 
   /**
+   * This hint indicates that a null literal is null-checked with `!`, but null
+   * is never not null.
+   */
+  static const HintCode NULL_CHECK_ALWAYS_FAILS = HintCode(
+      'NULL_CHECK_ALWAYS_FAILS',
+      "This null-check will always throw an exception because the expression "
+          "will always evaluate to 'null'.");
+
+  /**
    * No parameters.
    */
   // #### Description
diff --git a/pkg/analyzer/lib/src/dart/resolver/prefixed_identifier_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/prefixed_identifier_resolver.dart
index 54a67e4..6d65356 100644
--- a/pkg/analyzer/lib/src/dart/resolver/prefixed_identifier_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/prefixed_identifier_resolver.dart
@@ -32,10 +32,60 @@
       hasWrite: false,
     );
 
-    var identifier = node.identifier;
-    identifier.staticElement = result.readElement;
+    var element = result.readElement;
 
-    _resolve2(node);
+    var identifier = node.identifier;
+    identifier.staticElement = element;
+
+    if (element is ExtensionElement) {
+      _setExtensionIdentifierType(node);
+      return;
+    }
+
+    if (identical(node.prefix.staticType, NeverTypeImpl.instance)) {
+      _recordStaticType(identifier, NeverTypeImpl.instance);
+      _recordStaticType(node, NeverTypeImpl.instance);
+      return;
+    }
+
+    DartType type = DynamicTypeImpl.instance;
+    if (element is ClassElement) {
+      if (_isExpressionIdentifier(node)) {
+        var type = _typeProvider.typeType;
+        node.staticType = type;
+        identifier.staticType = type;
+      }
+      return;
+    } else if (element is DynamicElementImpl) {
+      var type = _typeProvider.typeType;
+      node.staticType = type;
+      identifier.staticType = type;
+      return;
+    } else if (element is FunctionTypeAliasElement) {
+      if (node.parent is TypeName) {
+        // no type
+      } else {
+        var type = _typeProvider.typeType;
+        node.staticType = type;
+        identifier.staticType = type;
+      }
+      return;
+    } else if (element is MethodElement) {
+      type = element.type;
+    } else if (element is PropertyAccessorElement) {
+      type = _getTypeOfProperty(element);
+    } else if (element is ExecutableElement) {
+      type = element.type;
+    } else if (element is VariableElement) {
+      type = element.type;
+    } else if (result.functionTypeCallType != null) {
+      type = result.functionTypeCallType;
+    }
+
+    type = _inferenceHelper.inferTearOff(node, identifier, type);
+
+    _recordStaticType(identifier, type);
+    _recordStaticType(node, type);
   }
 
   /// Return the type that should be recorded for a node that resolved to the given accessor.
@@ -103,60 +153,6 @@
     _inferenceHelper.recordStaticType(expression, type);
   }
 
-  void _resolve2(PrefixedIdentifier node) {
-    SimpleIdentifier prefixedIdentifier = node.identifier;
-    Element staticElement = prefixedIdentifier.staticElement;
-
-    if (staticElement is ExtensionElement) {
-      _setExtensionIdentifierType(node);
-      return;
-    }
-
-    if (identical(node.prefix.staticType, NeverTypeImpl.instance)) {
-      _recordStaticType(prefixedIdentifier, NeverTypeImpl.instance);
-      _recordStaticType(node, NeverTypeImpl.instance);
-      return;
-    }
-
-    DartType staticType = DynamicTypeImpl.instance;
-    if (staticElement is ClassElement) {
-      if (_isExpressionIdentifier(node)) {
-        var type = _typeProvider.typeType;
-        node.staticType = type;
-        node.identifier.staticType = type;
-      }
-      return;
-    } else if (staticElement is DynamicElementImpl) {
-      var type = _typeProvider.typeType;
-      node.staticType = type;
-      node.identifier.staticType = type;
-      return;
-    } else if (staticElement is FunctionTypeAliasElement) {
-      if (node.parent is TypeName) {
-        // no type
-      } else {
-        var type = _typeProvider.typeType;
-        node.staticType = type;
-        node.identifier.staticType = type;
-      }
-      return;
-    } else if (staticElement is MethodElement) {
-      staticType = staticElement.type;
-    } else if (staticElement is PropertyAccessorElement) {
-      staticType = _getTypeOfProperty(staticElement);
-    } else if (staticElement is ExecutableElement) {
-      staticType = staticElement.type;
-    } else if (staticElement is VariableElement) {
-      staticType = staticElement.type;
-    }
-
-    staticType =
-        _inferenceHelper.inferTearOff(node, node.identifier, staticType);
-
-    _recordStaticType(prefixedIdentifier, staticType);
-    _recordStaticType(node, staticType);
-  }
-
   /// TODO(scheglov) this is duplicate
   void _setExtensionIdentifierType(Identifier node) {
     if (node is SimpleIdentifier && node.inDeclarationContext()) {
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 23023c0..a271757e 100644
--- a/pkg/analyzer/lib/src/dart/resolver/property_element_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/property_element_resolver.dart
@@ -329,6 +329,12 @@
 
     var targetType = target.staticType;
 
+    if (targetType is FunctionType && propertyName.name == 'call') {
+      return PropertyElementResolverResult(
+        functionTypeCallType: targetType,
+      );
+    }
+
     if (targetType.isVoid) {
       _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.USE_OF_VOID_RESULT,
@@ -693,6 +699,7 @@
   final Element readElementRecovery;
   final Element writeElementRequested;
   final Element writeElementRecovery;
+  final FunctionType functionTypeCallType;
 
   /// If [IndexExpression] is resolved, the context type of the index.
   /// Might be `null` if `[]` or `[]=` are not resolved or invalid.
@@ -704,6 +711,7 @@
     this.writeElementRequested,
     this.writeElementRecovery,
     this.indexContextType,
+    this.functionTypeCallType,
   });
 
   Element get readElement {
diff --git a/pkg/analyzer/lib/src/error/best_practices_verifier.dart b/pkg/analyzer/lib/src/error/best_practices_verifier.dart
index 0093170..392a4b1 100644
--- a/pkg/analyzer/lib/src/error/best_practices_verifier.dart
+++ b/pkg/analyzer/lib/src/error/best_practices_verifier.dart
@@ -613,6 +613,9 @@
   @override
   void visitPostfixExpression(PostfixExpression node) {
     _deprecatedVerifier.postfixExpression(node);
+    if (node.operand.staticType?.isDartCoreNull ?? false) {
+      _errorReporter.reportErrorForNode(HintCode.NULL_CHECK_ALWAYS_FAILS, node);
+    }
     super.visitPostfixExpression(node);
   }
 
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index aa631a8..4cbf579 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -1743,6 +1743,8 @@
       type = element.type;
     } else if (element is PropertyAccessorElement && element.isGetter) {
       type = element.returnType;
+    } else if (result.functionTypeCallType != null) {
+      type = result.functionTypeCallType;
     } else {
       type = DynamicTypeImpl.instance;
     }
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
index e955fb1..3ba26a1 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
@@ -6218,7 +6218,7 @@
 
     SimpleIdentifier methodName = prefixed.identifier;
     expect(methodName.staticElement, isNull);
-    expect(methodName.staticType, typeProvider.dynamicType);
+    assertType(methodName.staticType, 'double Function(int)');
   }
 
   test_prefixedIdentifier_importPrefix_className() async {
diff --git a/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
index add8f6f..400c242 100644
--- a/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
@@ -614,11 +614,13 @@
   }
 
   test_nullCheck_null() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 void f(Null x) {
   x!;
 }
-''');
+''', [
+      error(HintCode.NULL_CHECK_ALWAYS_FAILS, 19, 2),
+    ]);
 
     assertType(findNode.postfix('x!'), 'Never');
   }
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 679ec1a..ff8104f 100644
--- a/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart
@@ -33,6 +33,20 @@
     );
   }
 
+  test_functionType_call_read() async {
+    await assertNoErrorsInCode('''
+void f(int Function(String) a) {
+  a.call;
+}
+''');
+
+    assertPrefixedIdentifier(
+      findNode.prefixed('.call;'),
+      element: null,
+      type: 'int Function(String)',
+    );
+  }
+
   test_implicitCall_tearOff() async {
     newFile('$testPackageLibPath/a.dart', content: r'''
 class A {
diff --git a/pkg/analyzer/test/src/dart/resolution/property_access_test.dart b/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
index 308f02f..313cd97 100644
--- a/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
@@ -124,6 +124,20 @@
     }
   }
 
+  test_functionType_call_read() async {
+    await assertNoErrorsInCode('''
+void f(int Function(String) a) {
+  (a).call;
+}
+''');
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('call;'),
+      element: null,
+      type: 'int Function(String)',
+    );
+  }
+
   test_instanceCreation_read() async {
     await assertNoErrorsInCode('''
 class A {
diff --git a/pkg/analyzer/test/src/diagnostics/null_check_always_fails_test.dart b/pkg/analyzer/test/src/diagnostics/null_check_always_fails_test.dart
new file mode 100644
index 0000000..e21d37c
--- /dev/null
+++ b/pkg/analyzer/test/src/diagnostics/null_check_always_fails_test.dart
@@ -0,0 +1,68 @@
+// 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:analyzer/src/error/codes.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../dart/resolution/context_collection_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(NullNeverNotNullTest);
+  });
+}
+
+@reflectiveTest
+class NullNeverNotNullTest extends PubPackageResolutionTest
+    with WithNullSafetyMixin {
+  test_nullable() async {
+    await assertNoErrorsInCode(r'''
+void f(int? i) {
+  i!;
+}
+''');
+  }
+
+  test_nullLiteral() async {
+    await assertErrorsInCode(r'''
+void f() {
+  null!;
+}
+''', [
+      error(HintCode.NULL_CHECK_ALWAYS_FAILS, 13, 5),
+    ]);
+  }
+
+  test_nullLiteral_parenthesized() async {
+    await assertErrorsInCode(r'''
+void f() {
+  null!;
+}
+''', [
+      error(HintCode.NULL_CHECK_ALWAYS_FAILS, 13, 5),
+    ]);
+  }
+
+  test_nullType() async {
+    await assertErrorsInCode(r'''
+void f() {
+  g()!;
+}
+Null g() => null;
+''', [
+      error(HintCode.NULL_CHECK_ALWAYS_FAILS, 13, 4),
+    ]);
+  }
+
+  test_nullType_awaited() async {
+    await assertErrorsInCode(r'''
+void f() async {
+  (await g())!;
+}
+Future<Null> g() async => null;
+''', [
+      error(HintCode.NULL_CHECK_ALWAYS_FAILS, 19, 12),
+    ]);
+  }
+}
diff --git a/pkg/analyzer/test/src/diagnostics/test_all.dart b/pkg/analyzer/test/src/diagnostics/test_all.dart
index 3c07bbe..2498c30 100644
--- a/pkg/analyzer/test/src/diagnostics/test_all.dart
+++ b/pkg/analyzer/test/src/diagnostics/test_all.dart
@@ -464,6 +464,7 @@
 import 'null_aware_in_condition_test.dart' as null_aware_in_condition;
 import 'null_aware_in_logical_operator_test.dart'
     as null_aware_in_logical_operator;
+import 'null_check_always_fails_test.dart' as null_check_always_fails;
 import 'null_safety_read_write_test.dart' as null_safety_read_write;
 import 'nullable_type_in_catch_clause_test.dart'
     as nullable_type_in_catch_clause;
@@ -963,6 +964,7 @@
     null_aware_before_operator.main();
     null_aware_in_condition.main();
     null_aware_in_logical_operator.main();
+    null_check_always_fails.main();
     null_safety_read_write.main();
     nullable_type_in_catch_clause.main();
     nullable_type_in_extends_clause.main();
diff --git a/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart b/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart
index baf399c..814771c 100644
--- a/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart
@@ -277,7 +277,7 @@
 }
 
 void f(A a) {
-  return a.staticMethod.call;
+  a.staticMethod.call;
 }
 ''');
   }
diff --git a/pkg/dds/CHANGELOG.md b/pkg/dds/CHANGELOG.md
index f959b95..32be6a6 100644
--- a/pkg/dds/CHANGELOG.md
+++ b/pkg/dds/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 1.5.0
+- Added event caching for `Stdout`, `Stderr`, and `Extension` streams. When a
+client subscribes to one of these streams, they will be sent up to 10,000
+historical events from the stream.
+
 # 1.4.1
 - Fixed issue where `evaluate` and `evaluateInFrame` requests were not being
   forwarded to the VM service properly when no external compilation service
diff --git a/pkg/dds/dds_protocol.md b/pkg/dds/dds_protocol.md
index be9da7e..253ef99 100644
--- a/pkg/dds/dds_protocol.md
+++ b/pkg/dds/dds_protocol.md
@@ -47,6 +47,22 @@
 
 See the corresponding section in the VM Service protocol [here][service-protocol-ids-and-names].
 
+## Streams
+
+For a list of core VM service streams, see [streamListen][service-protocol-streams].
+
+DDS will keep a history of events on certain streams and send historical events
+when a client first subscribes to a stream with history. These streams currently
+consist of the following:
+
+- `Logging`
+- `Stdout`
+- `Stderr`
+- `Extension`
+
+In addition, subscribing to the `Service` stream will result in a `ServiceRegistered`
+event being sent to the subscribing client for each existing service extension.
+
 ## Public RPCs
 
 The DDS Protocol supports all [public RPCs defined in the VM Service protocol][service-protocol-public-rpcs].
@@ -187,6 +203,7 @@
 [service-protocol]: https://github.com/dart-lang/sdk/blob/master/runtime/vm/service/service.md
 [service-protocol-rpcs-requests-and-responses]: https://github.com/dart-lang/sdk/blob/master/runtime/vm/service/service.md#rpcs-requests-and-responses
 [service-protocol-events]: https://github.com/dart-lang/sdk/blob/master/runtime/vm/service/service.md#events
+[service-protocol-streams]: https://github.com/dart-lang/sdk/blob/master/runtime/vm/service/service.md#streamlisten
 [service-protocol-binary-events]: https://github.com/dart-lang/sdk/blob/master/runtime/vm/service/service.md#binary-events
 [service-protocol-types]: https://github.com/dart-lang/sdk/blob/master/runtime/vm/service/service.md#types
 [service-protocol-ids-and-names]: https://github.com/dart-lang/sdk/blob/master/runtime/vm/service/service.md#ids-and-names
diff --git a/pkg/dds/lib/src/client.dart b/pkg/dds/lib/src/client.dart
index 79e4233..2c85aae 100644
--- a/pkg/dds/lib/src/client.dart
+++ b/pkg/dds/lib/src/client.dart
@@ -140,7 +140,9 @@
         'getLogHistorySize',
         (parameters) => {
               'type': 'Size',
-              'size': dds.loggingRepository.bufferSize,
+              'size': _StreamManager
+                  .loggingRepositories[_StreamManager.kLoggingStream]
+                  .bufferSize,
             });
 
     _clientPeer.registerMethod('setLogHistorySize', (parameters) {
@@ -150,7 +152,8 @@
           "'size' must be greater or equal to zero",
         );
       }
-      dds.loggingRepository.resize(size);
+      _StreamManager.loggingRepositories[_StreamManager.kLoggingStream]
+          .resize(size);
       return _RPCResponses.success;
     });
 
diff --git a/pkg/dds/lib/src/dds_impl.dart b/pkg/dds/lib/src/dds_impl.dart
index 06327a8..d2a6dcb 100644
--- a/pkg/dds/lib/src/dds_impl.dart
+++ b/pkg/dds/lib/src/dds_impl.dart
@@ -10,7 +10,6 @@
     _clientManager = _ClientManager(this);
     _expressionEvaluator = _ExpressionEvaluator(this);
     _isolateManager = _IsolateManager(this);
-    _loggingRepository = _LoggingRepository();
     _streamManager = _StreamManager(this);
     _authCode = _authCodesEnabled ? _makeAuthToken() : '';
   }
@@ -270,9 +269,6 @@
   _IsolateManager get isolateManager => _isolateManager;
   _IsolateManager _isolateManager;
 
-  _LoggingRepository get loggingRepository => _loggingRepository;
-  _LoggingRepository _loggingRepository;
-
   _StreamManager get streamManager => _streamManager;
   _StreamManager _streamManager;
 
diff --git a/pkg/dds/lib/src/stream_manager.dart b/pkg/dds/lib/src/stream_manager.dart
index abb233c..542fe91 100644
--- a/pkg/dds/lib/src/stream_manager.dart
+++ b/pkg/dds/lib/src/stream_manager.dart
@@ -91,7 +91,14 @@
     // The _IsolateManager requires information from both the Debug and
     // Isolate streams, so they must always be subscribed to by DDS.
     for (final stream in ddsCoreStreams) {
-      await streamListen(null, stream);
+      try {
+        await streamListen(null, stream);
+        if (loggingRepositoryStreams.contains(stream)) {
+          loggingRepositories[stream] = _LoggingRepository();
+        }
+      } on json_rpc.RpcException {
+        // Stdout and Stderr streams may not exist.
+      }
     }
     dds._vmServiceClient.registerMethod(
       'streamNotify',
@@ -101,10 +108,10 @@
         if (isolateManagerStreams.contains(streamId)) {
           dds.isolateManager.handleIsolateEvent(parameters);
         }
-        // Keep a history of log messages to send to clients when they first
-        // subscribe to the Logging stream.
-        if (streamId == kLoggingStream) {
-          dds.loggingRepository.add(parameters.asMap);
+        // Keep a history of messages to send to clients when they first
+        // subscribe to a stream with an event history.
+        if (loggingRepositories.containsKey(streamId)) {
+          loggingRepositories[streamId].add(parameters.asMap);
         }
         streamNotify(streamId, parameters.value);
       },
@@ -137,8 +144,8 @@
     }
     if (client != null) {
       streamListeners[stream].add(client);
-      if (stream == kLoggingStream) {
-        dds.loggingRepository.sendHistoricalLogs(client);
+      if (loggingRepositories.containsKey(stream)) {
+        loggingRepositories[stream].sendHistoricalLogs(client);
       } else if (stream == kServiceStream) {
         // Send all previously registered service extensions when a client
         // subscribes to the Service stream.
@@ -223,8 +230,13 @@
   );
 
   static const kDebugStream = 'Debug';
+  static const kExtensionStream = 'Extension';
   static const kIsolateStream = 'Isolate';
   static const kLoggingStream = 'Logging';
+  static const kStderrStream = 'Stderr';
+  static const kStdoutStream = 'Stdout';
+
+  static Map<String, _LoggingRepository> loggingRepositories = {};
 
   // Never cancel the Debug or Isolate stream as `_IsolateManager` requires
   // them for isolate state notifications.
@@ -233,10 +245,13 @@
     kIsolateStream,
   };
 
-  // Never cancel the Logging stream as `_LoggingRepository` requires it to
-  // keep a log history.
+  // Never cancel the logging and extension event streams as `_LoggingRepository`
+  // requires them keep history.
   static const loggingRepositoryStreams = <String>{
+    kExtensionStream,
     kLoggingStream,
+    kStderrStream,
+    kStdoutStream,
   };
 
   // The set of streams that DDS requires to function.
diff --git a/pkg/dds/pubspec.yaml b/pkg/dds/pubspec.yaml
index a7ae669..d2fdbdb 100644
--- a/pkg/dds/pubspec.yaml
+++ b/pkg/dds/pubspec.yaml
@@ -3,7 +3,7 @@
   A library used to spawn the Dart Developer Service, used to communicate with
   a Dart VM Service instance.
 
-version: 1.4.1
+version: 1.5.0
 
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/dds
 
diff --git a/pkg/front_end/lib/src/api_prototype/file_system.dart b/pkg/front_end/lib/src/api_prototype/file_system.dart
index 1306c0c..82b511a 100644
--- a/pkg/front_end/lib/src/api_prototype/file_system.dart
+++ b/pkg/front_end/lib/src/api_prototype/file_system.dart
@@ -4,8 +4,6 @@
 
 library front_end.file_system;
 
-import 'dart:async';
-
 /// Abstract interface to file system operations.
 ///
 /// All front end interaction with the file system goes through this interface;
diff --git a/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart b/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
index c49c884..e5b1bc2 100644
--- a/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
+++ b/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:_fe_analyzer_shared/src/scanner/string_scanner.dart'
     show StringScanner;
 
diff --git a/pkg/front_end/lib/src/api_prototype/kernel_generator.dart b/pkg/front_end/lib/src/api_prototype/kernel_generator.dart
index 8519ca0..27857a9 100644
--- a/pkg/front_end/lib/src/api_prototype/kernel_generator.dart
+++ b/pkg/front_end/lib/src/api_prototype/kernel_generator.dart
@@ -5,8 +5,6 @@
 /// Defines the front-end API for converting source code to Dart Kernel objects.
 library front_end.kernel_generator;
 
-import 'dart:async' show Future;
-
 import 'package:_fe_analyzer_shared/src/messages/codes.dart'
     show messageMissingMain, noLength;
 
diff --git a/pkg/front_end/lib/src/api_prototype/memory_file_system.dart b/pkg/front_end/lib/src/api_prototype/memory_file_system.dart
index 3618c93..e077d8d 100644
--- a/pkg/front_end/lib/src/api_prototype/memory_file_system.dart
+++ b/pkg/front_end/lib/src/api_prototype/memory_file_system.dart
@@ -4,7 +4,6 @@
 
 library front_end.memory_file_system;
 
-import 'dart:async';
 import 'dart:convert';
 import 'dart:typed_data';
 
diff --git a/pkg/front_end/lib/src/api_prototype/standard_file_system.dart b/pkg/front_end/lib/src/api_prototype/standard_file_system.dart
index bdd78ad..a8bbc0b 100644
--- a/pkg/front_end/lib/src/api_prototype/standard_file_system.dart
+++ b/pkg/front_end/lib/src/api_prototype/standard_file_system.dart
@@ -4,7 +4,6 @@
 
 library front_end.standard_file_system;
 
-import 'dart:async';
 import 'dart:io' as io;
 
 import 'file_system.dart';
diff --git a/pkg/front_end/lib/src/api_prototype/summary_generator.dart b/pkg/front_end/lib/src/api_prototype/summary_generator.dart
index 5385311..d579536 100644
--- a/pkg/front_end/lib/src/api_prototype/summary_generator.dart
+++ b/pkg/front_end/lib/src/api_prototype/summary_generator.dart
@@ -5,7 +5,6 @@
 /// Defines the front-end API for converting source code to summaries.
 library front_end.summary_generator;
 
-import 'dart:async';
 import 'compiler_options.dart';
 
 import '../base/processed_options.dart';
diff --git a/pkg/front_end/lib/src/api_unstable/bazel_worker.dart b/pkg/front_end/lib/src/api_unstable/bazel_worker.dart
index 24c779d..d4445e4 100644
--- a/pkg/front_end/lib/src/api_unstable/bazel_worker.dart
+++ b/pkg/front_end/lib/src/api_unstable/bazel_worker.dart
@@ -5,8 +5,6 @@
 /// API needed by `utils/front_end/summary_worker.dart`, a tool used to compute
 /// summaries in build systems like bazel, pub-build, and package-build.
 
-import 'dart:async' show Future;
-
 import 'package:_fe_analyzer_shared/src/messages/diagnostic_message.dart'
     show DiagnosticMessageHandler;
 
diff --git a/pkg/front_end/lib/src/api_unstable/dart2js.dart b/pkg/front_end/lib/src/api_unstable/dart2js.dart
index 85cb35a..d7fba2e 100644
--- a/pkg/front_end/lib/src/api_unstable/dart2js.dart
+++ b/pkg/front_end/lib/src/api_unstable/dart2js.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:_fe_analyzer_shared/src/messages/codes.dart'
     show messageMissingMain;
 
diff --git a/pkg/front_end/lib/src/api_unstable/ddc.dart b/pkg/front_end/lib/src/api_unstable/ddc.dart
index d9506f7..b28384f 100644
--- a/pkg/front_end/lib/src/api_unstable/ddc.dart
+++ b/pkg/front_end/lib/src/api_unstable/ddc.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:_fe_analyzer_shared/src/messages/diagnostic_message.dart'
     show DiagnosticMessageHandler;
 
diff --git a/pkg/front_end/lib/src/api_unstable/modular_incremental_compilation.dart b/pkg/front_end/lib/src/api_unstable/modular_incremental_compilation.dart
index 0044b4c..691483d 100644
--- a/pkg/front_end/lib/src/api_unstable/modular_incremental_compilation.dart
+++ b/pkg/front_end/lib/src/api_unstable/modular_incremental_compilation.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:kernel/kernel.dart' show Component, CanonicalName, Library;
 
 import 'package:kernel/target/targets.dart' show Target;
diff --git a/pkg/front_end/lib/src/base/processed_options.dart b/pkg/front_end/lib/src/base/processed_options.dart
index e6ee21b..93c5853 100644
--- a/pkg/front_end/lib/src/base/processed_options.dart
+++ b/pkg/front_end/lib/src/base/processed_options.dart
@@ -4,8 +4,6 @@
 
 import 'dart:io' show exitCode;
 
-import 'dart:async' show Future;
-
 import 'dart:typed_data' show Uint8List;
 
 import 'package:_fe_analyzer_shared/src/messages/severity.dart' show Severity;
diff --git a/pkg/front_end/lib/src/fasta/builder/field_builder.dart b/pkg/front_end/lib/src/fasta/builder/field_builder.dart
index 5fb86e7..63f82eb 100644
--- a/pkg/front_end/lib/src/fasta/builder/field_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/field_builder.dart
@@ -577,7 +577,10 @@
 
   RegularFieldEncoding(Uri fileUri, int charOffset, int charEndOffset,
       Field reference, bool isNonNullableByDefault) {
-    _field = new Field(null, fileUri: fileUri, reference: reference?.reference)
+    _field = new Field(null,
+        fileUri: fileUri,
+        getterReference: reference?.getterReference,
+        setterReference: reference?.setterReference)
       ..fileOffset = charOffset
       ..fileEndOffset = charEndOffset
       ..isNonNullableByDefault = isNonNullableByDefault;
@@ -787,12 +790,14 @@
         _isSetStrategy = isSetStrategy,
         _forceIncludeIsSetField =
             isSetStrategy == late_lowering.IsSetStrategy.forceUseIsSetField {
-    _field =
-        new Field(null, fileUri: fileUri, reference: referenceFrom?.reference)
-          ..fileOffset = charOffset
-          ..fileEndOffset = charEndOffset
-          ..isNonNullableByDefault = true
-          ..isInternalImplementation = true;
+    _field = new Field(null,
+        fileUri: fileUri,
+        getterReference: referenceFrom?.getterReference,
+        setterReference: referenceFrom?.setterReference)
+      ..fileOffset = charOffset
+      ..fileEndOffset = charEndOffset
+      ..isNonNullableByDefault = true
+      ..isInternalImplementation = true;
     switch (_isSetStrategy) {
       case late_lowering.IsSetStrategy.useSentinelOrNull:
         // [_lateIsSetField] is never needed.
@@ -800,7 +805,9 @@
       case late_lowering.IsSetStrategy.forceUseIsSetField:
       case late_lowering.IsSetStrategy.useIsSetFieldOrNull:
         _lateIsSetField = new Field(null,
-            fileUri: fileUri, reference: lateIsSetReferenceFrom?.reference)
+            fileUri: fileUri,
+            getterReference: lateIsSetReferenceFrom?.getterReference,
+            setterReference: lateIsSetReferenceFrom?.setterReference)
           ..fileOffset = charOffset
           ..fileEndOffset = charEndOffset
           ..isNonNullableByDefault = true
diff --git a/pkg/front_end/lib/src/fasta/compiler_context.dart b/pkg/front_end/lib/src/fasta/compiler_context.dart
index 38df523..e65531a 100644
--- a/pkg/front_end/lib/src/fasta/compiler_context.dart
+++ b/pkg/front_end/lib/src/fasta/compiler_context.dart
@@ -4,7 +4,7 @@
 
 library fasta.compiler_context;
 
-import 'dart:async' show Future, Zone, runZoned;
+import 'dart:async' show Zone, runZoned;
 
 import 'package:_fe_analyzer_shared/src/messages/severity.dart' show Severity;
 
diff --git a/pkg/front_end/lib/src/fasta/crash.dart b/pkg/front_end/lib/src/fasta/crash.dart
index 8498da9..1ad20fc 100644
--- a/pkg/front_end/lib/src/fasta/crash.dart
+++ b/pkg/front_end/lib/src/fasta/crash.dart
@@ -4,8 +4,6 @@
 
 library fasta.crash;
 
-import 'dart:async' show Future;
-
 import 'dart:convert' show jsonEncode;
 
 import 'dart:io'
diff --git a/pkg/front_end/lib/src/fasta/dill/dill_loader.dart b/pkg/front_end/lib/src/fasta/dill/dill_loader.dart
index cf98a1f..2ce2498 100644
--- a/pkg/front_end/lib/src/fasta/dill/dill_loader.dart
+++ b/pkg/front_end/lib/src/fasta/dill/dill_loader.dart
@@ -4,8 +4,6 @@
 
 library fasta.dill_loader;
 
-import 'dart:async' show Future;
-
 import 'package:kernel/ast.dart' show Class, Component, DartType, Library;
 
 import '../builder/class_builder.dart';
diff --git a/pkg/front_end/lib/src/fasta/dill/dill_target.dart b/pkg/front_end/lib/src/fasta/dill/dill_target.dart
index 717c348..52fa515 100644
--- a/pkg/front_end/lib/src/fasta/dill/dill_target.dart
+++ b/pkg/front_end/lib/src/fasta/dill/dill_target.dart
@@ -4,8 +4,6 @@
 
 library fasta.dill_target;
 
-import 'dart:async' show Future;
-
 import 'package:front_end/src/fasta/builder/library_builder.dart'
     show LibraryBuilder;
 
diff --git a/pkg/front_end/lib/src/fasta/get_dependencies.dart b/pkg/front_end/lib/src/fasta/get_dependencies.dart
index 22b621a..3a23778 100644
--- a/pkg/front_end/lib/src/fasta/get_dependencies.dart
+++ b/pkg/front_end/lib/src/fasta/get_dependencies.dart
@@ -4,8 +4,6 @@
 
 library fasta.get_dependencies;
 
-import 'dart:async' show Future;
-
 import 'package:kernel/kernel.dart' show Component, loadComponentFromBytes;
 
 import 'package:kernel/target/targets.dart' show Target;
diff --git a/pkg/front_end/lib/src/fasta/hybrid_file_system.dart b/pkg/front_end/lib/src/fasta/hybrid_file_system.dart
index 84d1cbd..3a78a1c 100644
--- a/pkg/front_end/lib/src/fasta/hybrid_file_system.dart
+++ b/pkg/front_end/lib/src/fasta/hybrid_file_system.dart
@@ -6,8 +6,6 @@
 /// sdk sources from disk.
 library front_end.src.hybrid_file_system;
 
-import 'dart:async';
-
 import '../api_prototype/file_system.dart';
 import '../api_prototype/memory_file_system.dart';
 import '../api_prototype/standard_file_system.dart';
diff --git a/pkg/front_end/lib/src/fasta/incremental_compiler.dart b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
index 69d3f19..73c5550 100644
--- a/pkg/front_end/lib/src/fasta/incremental_compiler.dart
+++ b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
@@ -4,8 +4,6 @@
 
 library fasta.incremental_compiler;
 
-import 'dart:async' show Future;
-
 import 'package:front_end/src/api_prototype/experimental_flags.dart';
 import 'package:front_end/src/api_prototype/front_end.dart';
 import 'package:front_end/src/base/nnbd_mode.dart';
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart b/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart
index 2db181b..4521aec 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart
@@ -191,7 +191,7 @@
                 evaluator.unmodifiableSetMap.enclosingClass.reference, [
               elementType
             ], <Reference, Constant>{
-              evaluator.unmodifiableSetMap.reference: map
+              evaluator.unmodifiableSetMap.getterReference: map
             }));
       } else {
         return evaluator.lowerSetConstant(result);
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index 3d6f7a5..1d098cd 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -2855,7 +2855,7 @@
     final Map<Reference, Constant> fieldValues = <Reference, Constant>{};
     fields.forEach((Field field, Constant value) {
       assert(value is! UnevaluatedConstant);
-      fieldValues[field.reference] = value;
+      fieldValues[field.getterReference] = value;
     });
     assert(unusedArguments.isEmpty);
     return new InstanceConstant(klass.reference, typeArguments, fieldValues);
@@ -2864,7 +2864,7 @@
   InstanceCreation buildUnevaluatedInstance() {
     final Map<Reference, Expression> fieldValues = <Reference, Expression>{};
     fields.forEach((Field field, Constant value) {
-      fieldValues[field.reference] = evaluator.extract(value);
+      fieldValues[field.getterReference] = evaluator.extract(value);
     });
     return new InstanceCreation(
         klass.reference, typeArguments, fieldValues, asserts, unusedArguments);
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
index ba8a8b3..afa72c8 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -4,8 +4,6 @@
 
 library fasta.kernel_target;
 
-import 'dart:async' show Future;
-
 import 'package:front_end/src/api_prototype/experimental_flags.dart';
 import 'package:front_end/src/fasta/dill/dill_library_builder.dart'
     show DillLibraryBuilder;
diff --git a/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart b/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
index 06556d5..c4a6bc5 100644
--- a/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
@@ -309,7 +309,7 @@
       if (field.isStatic) continue;
       if (!first) result.add(", ");
       result.add("${field.name}: ");
-      node.fieldValues[field.reference].accept(this);
+      node.fieldValues[field.getterReference].accept(this);
       first = false;
     }
     result.add("}");
diff --git a/pkg/front_end/lib/src/fasta/kernel/utils.dart b/pkg/front_end/lib/src/fasta/kernel/utils.dart
index aae5538..1eaf2b3 100644
--- a/pkg/front_end/lib/src/fasta/kernel/utils.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/utils.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:io' show BytesBuilder, File, IOSink;
 
 import 'dart:typed_data' show Uint8List;
diff --git a/pkg/front_end/lib/src/fasta/loader.dart b/pkg/front_end/lib/src/fasta/loader.dart
index 35c5007..cb9e306 100644
--- a/pkg/front_end/lib/src/fasta/loader.dart
+++ b/pkg/front_end/lib/src/fasta/loader.dart
@@ -4,8 +4,6 @@
 
 library fasta.loader;
 
-import 'dart:async' show Future;
-
 import 'dart:collection' show Queue;
 
 import 'package:_fe_analyzer_shared/src/messages/severity.dart' show Severity;
diff --git a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
index 35a1e40..710d78e 100644
--- a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
@@ -860,7 +860,8 @@
           isStatic: true,
           initializer: literal,
           fileUri: cls.fileUri,
-          reference: referenceFrom?.reference)
+          getterReference: referenceFrom?.getterReference,
+          setterReference: referenceFrom?.setterReference)
         ..fileOffset = cls.fileOffset;
       cls.addField(field);
       constructorsField = new DillFieldBuilder(field, this);
diff --git a/pkg/front_end/lib/src/fasta/source/source_extension_builder.dart b/pkg/front_end/lib/src/fasta/source/source_extension_builder.dart
index 0479011..f3c9943 100644
--- a/pkg/front_end/lib/src/fasta/source/source_extension_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_extension_builder.dart
@@ -146,17 +146,20 @@
                   break;
               }
               assert(kind != null);
+              Reference memberReference;
               if (member is Field) {
                 libraryBuilder.library.addField(member);
+                memberReference = member.getterReference;
               } else if (member is Procedure) {
                 libraryBuilder.library.addProcedure(member);
+                memberReference = member.reference;
               } else {
                 unhandled("${member.runtimeType}", "buildBuilders",
                     member.fileOffset, member.fileUri);
               }
               extension.members.add(new ExtensionMemberDescriptor(
                   name: new Name(memberBuilder.name, libraryBuilder.library),
-                  member: member.reference,
+                  member: memberReference,
                   isStatic: declaration.isStatic,
                   kind: kind));
             }
diff --git a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
index b70ba48..f34bede 100644
--- a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
@@ -806,15 +806,18 @@
 
   @override
   Builder addBuilder(String name, Builder declaration, int charOffset,
-      {Reference reference}) {
+      {Reference getterReference, Reference setterReference}) {
     // TODO(ahe): Set the parent correctly here. Could then change the
     // implementation of MemberBuilder.isTopLevel to test explicitly for a
     // LibraryBuilder.
     if (name == null) {
       unhandled("null", "name", charOffset, fileUri);
     }
-    if (reference != null) {
-      loader.buildersCreatedWithReferences[reference] = declaration;
+    if (getterReference != null) {
+      loader.buildersCreatedWithReferences[getterReference] = declaration;
+    }
+    if (setterReference != null) {
+      loader.buildersCreatedWithReferences[setterReference] = declaration;
     }
     if (currentTypeParameterScopeBuilder == libraryDeclaration) {
       if (declaration is MemberBuilder) {
@@ -977,7 +980,8 @@
           initializer: new StringLiteral(jsonEncode(unserializableExports)),
           isStatic: true,
           isConst: true,
-          reference: referenceFrom?.reference));
+          getterReference: referenceFrom?.getterReference,
+          setterReference: referenceFrom?.setterReference));
     }
 
     return library;
@@ -1258,7 +1262,15 @@
                 library.additionalExports.add(memberLast.extension.reference);
               } else if (memberLast is MemberBuilder) {
                 for (Member member in memberLast.exportedMembers) {
-                  library.additionalExports.add(member.reference);
+                  if (member is Field) {
+                    // For fields add both getter and setter references
+                    // so replacing a field with a getter/setter pair still
+                    // exports correctly.
+                    library.additionalExports.add(member.getterReference);
+                    library.additionalExports.add(member.setterReference);
+                  } else {
+                    library.additionalExports.add(member.reference);
+                  }
                 }
               } else {
                 unhandled('member', 'exportScope', memberLast.charOffset,
@@ -1594,7 +1606,7 @@
     constructors.forEach(setParentAndCheckConflicts);
     setters.forEach(setParentAndCheckConflicts);
     addBuilder(className, classBuilder, nameOffset,
-        reference: referencesFromClass?.reference);
+        getterReference: referencesFromClass?.reference);
   }
 
   Map<String, TypeVariableBuilder> checkTypeVariables(
@@ -1804,7 +1816,7 @@
     constructors.forEach(setParentAndCheckConflicts);
     setters.forEach(setParentAndCheckConflicts);
     addBuilder(extensionName, extensionBuilder, nameOffset,
-        reference: referenceFrom?.reference);
+        getterReference: referenceFrom?.reference);
   }
 
   TypeBuilder applyMixins(TypeBuilder type, int startCharOffset, int charOffset,
@@ -2045,7 +2057,7 @@
         // handle that :(
         application.cls.isAnonymousMixin = !isNamedMixinApplication;
         addBuilder(fullname, application, charOffset,
-            reference: referencesFromClass?.reference);
+            getterReference: referencesFromClass?.reference);
         supertype = addNamedType(fullname, const NullabilityBuilder.omitted(),
             applicationTypeArguments, charOffset);
       }
@@ -2194,7 +2206,8 @@
         setterReferenceFrom);
     fieldBuilder.constInitializerToken = constInitializerToken;
     addBuilder(name, fieldBuilder, charOffset,
-        reference: referenceFrom?.reference);
+        getterReference: referenceFrom?.getterReference,
+        setterReference: referenceFrom?.setterReference);
     if (type == null && fieldBuilder.next == null) {
       // Only the first one (the last one in the linked list of next pointers)
       // are added to the tree, had parent pointers and can infer correctly.
@@ -2255,7 +2268,7 @@
         constructorBuilder.constructor, name);
     checkTypeVariables(typeVariables, constructorBuilder);
     addBuilder(constructorName, constructorBuilder, charOffset,
-        reference: referenceFrom?.reference);
+        getterReference: referenceFrom?.reference);
     if (nativeMethodName != null) {
       addNativeMethod(constructorBuilder);
     }
@@ -2368,7 +2381,7 @@
         procedureBuilder.procedure, documentationComment);
     checkTypeVariables(typeVariables, procedureBuilder);
     addBuilder(name, procedureBuilder, charOffset,
-        reference: referenceFrom?.reference);
+        getterReference: referenceFrom?.reference);
     if (nativeMethodName != null) {
       addNativeMethod(procedureBuilder);
     }
@@ -2471,7 +2484,7 @@
 
     factoryDeclaration.resolveTypes(procedureBuilder.typeVariables, this);
     addBuilder(procedureName, procedureBuilder, charOffset,
-        reference: referenceFrom?.reference);
+        getterReference: referenceFrom?.reference);
     if (nativeMethodName != null) {
       addNativeMethod(procedureBuilder);
     }
@@ -2505,7 +2518,7 @@
         referencesFromClass,
         referencesFromIndexedClass);
     addBuilder(name, builder, charOffset,
-        reference: referencesFromClass?.reference);
+        getterReference: referencesFromClass?.reference);
     metadataCollector?.setDocumentationComment(
         builder.cls, documentationComment);
   }
@@ -2533,7 +2546,7 @@
     endNestedDeclaration(TypeParameterScopeKind.typedef, "#typedef")
         .resolveTypes(typeVariables, this);
     addBuilder(name, typedefBuilder, charOffset,
-        reference: referenceFrom?.reference);
+        getterReference: referenceFrom?.reference);
   }
 
   FunctionTypeBuilder addFunctionType(
diff --git a/pkg/front_end/lib/src/fasta/source/source_loader.dart b/pkg/front_end/lib/src/fasta/source/source_loader.dart
index 215bba5..c9a3615 100644
--- a/pkg/front_end/lib/src/fasta/source/source_loader.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_loader.dart
@@ -4,8 +4,6 @@
 
 library fasta.source_loader;
 
-import 'dart:async' show Future;
-
 import 'dart:convert' show utf8;
 
 import 'dart:typed_data' show Uint8List;
diff --git a/pkg/front_end/lib/src/fasta/target.dart b/pkg/front_end/lib/src/fasta/target.dart
index 641d55a..8d2efd9 100644
--- a/pkg/front_end/lib/src/fasta/target.dart
+++ b/pkg/front_end/lib/src/fasta/target.dart
@@ -4,8 +4,6 @@
 
 library fasta.target;
 
-import 'dart:async' show Future;
-
 import 'package:kernel/ast.dart' show Component;
 
 import 'ticker.dart' show Ticker;
diff --git a/pkg/front_end/lib/src/kernel_generator_impl.dart b/pkg/front_end/lib/src/kernel_generator_impl.dart
index 78a0c68..24b5b55 100644
--- a/pkg/front_end/lib/src/kernel_generator_impl.dart
+++ b/pkg/front_end/lib/src/kernel_generator_impl.dart
@@ -5,8 +5,6 @@
 /// Defines the front-end API for converting source code to Dart Kernel objects.
 library front_end.kernel_generator_impl;
 
-import 'dart:async' show Future;
-
 import 'package:_fe_analyzer_shared/src/messages/severity.dart' show Severity;
 
 import 'package:kernel/kernel.dart'
diff --git a/pkg/front_end/lib/src/testing/compiler_common.dart b/pkg/front_end/lib/src/testing/compiler_common.dart
index 0f698a84..3164c83 100644
--- a/pkg/front_end/lib/src/testing/compiler_common.dart
+++ b/pkg/front_end/lib/src/testing/compiler_common.dart
@@ -5,8 +5,6 @@
 /// Common compiler options and helper functions used for testing.
 library front_end.testing.compiler_options_common;
 
-import 'dart:async' show Future;
-
 import 'package:kernel/ast.dart' show Library, Component;
 
 import '../api_prototype/front_end.dart'
diff --git a/pkg/front_end/test/fasta/bootstrap_test.dart b/pkg/front_end/test/fasta/bootstrap_test.dart
index 37dff17..f7ea1bd 100644
--- a/pkg/front_end/test/fasta/bootstrap_test.dart
+++ b/pkg/front_end/test/fasta/bootstrap_test.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:io' show Directory, File, Platform;
 
 import 'package:async_helper/async_helper.dart' show asyncEnd, asyncStart;
diff --git a/pkg/front_end/test/fasta/expression_suite.dart b/pkg/front_end/test/fasta/expression_suite.dart
index 46811fb..2b29aa0 100644
--- a/pkg/front_end/test/fasta/expression_suite.dart
+++ b/pkg/front_end/test/fasta/expression_suite.dart
@@ -4,8 +4,6 @@
 
 library fasta.test.expression_test;
 
-import "dart:async" show Future;
-
 import "dart:convert" show JsonEncoder;
 
 import "dart:io" show File, IOSink;
diff --git a/pkg/front_end/test/fasta/fast_strong_suite.dart b/pkg/front_end/test/fasta/fast_strong_suite.dart
index 8269eb9..8a0d844 100644
--- a/pkg/front_end/test/fasta/fast_strong_suite.dart
+++ b/pkg/front_end/test/fasta/fast_strong_suite.dart
@@ -4,8 +4,6 @@
 
 library fasta.test.fast_strong_test;
 
-import 'dart:async' show Future;
-
 import 'dart:io' show Platform;
 
 import 'testing/suite.dart';
diff --git a/pkg/front_end/test/fasta/incremental_suite.dart b/pkg/front_end/test/fasta/incremental_suite.dart
index 656da97..46c13e9 100644
--- a/pkg/front_end/test/fasta/incremental_suite.dart
+++ b/pkg/front_end/test/fasta/incremental_suite.dart
@@ -4,8 +4,6 @@
 
 library fasta.test.incremental_test;
 
-import "dart:async" show Future;
-
 import "dart:convert" show JsonEncoder;
 
 import "dart:io" show File;
diff --git a/pkg/front_end/test/fasta/messages_suite.dart b/pkg/front_end/test/fasta/messages_suite.dart
index 2992f1e..aa7aa4870 100644
--- a/pkg/front_end/test/fasta/messages_suite.dart
+++ b/pkg/front_end/test/fasta/messages_suite.dart
@@ -2,8 +2,6 @@
 // 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" show Future, Stream;
-
 import "dart:convert" show utf8;
 
 import 'dart:io' show File, Platform;
diff --git a/pkg/front_end/test/fasta/outline_suite.dart b/pkg/front_end/test/fasta/outline_suite.dart
index cc5ec1d..4bb4b58 100644
--- a/pkg/front_end/test/fasta/outline_suite.dart
+++ b/pkg/front_end/test/fasta/outline_suite.dart
@@ -4,8 +4,6 @@
 
 library fasta.test.outline_test;
 
-import 'dart:async' show Future;
-
 import 'testing/suite.dart';
 
 Future<FastaContext> createContext(
diff --git a/pkg/front_end/test/fasta/parser/parser_suite.dart b/pkg/front_end/test/fasta/parser/parser_suite.dart
index 1bcb148..8ea1ada 100644
--- a/pkg/front_end/test/fasta/parser/parser_suite.dart
+++ b/pkg/front_end/test/fasta/parser/parser_suite.dart
@@ -6,7 +6,7 @@
     show ParserError, parse;
 
 import 'package:testing/testing.dart'
-    show Chain, ChainContext, Future, Result, Step, runMe;
+    show Chain, ChainContext, Result, Step, runMe;
 
 import '../../utils/scanner_chain.dart' show Read, Scan, ScannedFile;
 
diff --git a/pkg/front_end/test/fasta/scanner/scanner_suite.dart b/pkg/front_end/test/fasta/scanner/scanner_suite.dart
index 1fb6f442..e71149e 100644
--- a/pkg/front_end/test/fasta/scanner/scanner_suite.dart
+++ b/pkg/front_end/test/fasta/scanner/scanner_suite.dart
@@ -2,8 +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.md file.
 
-import 'package:testing/testing.dart'
-    show Chain, ChainContext, Future, Step, runMe;
+import 'package:testing/testing.dart' show Chain, ChainContext, Step, runMe;
 
 import '../../utils/scanner_chain.dart' show Read, Scan;
 
diff --git a/pkg/front_end/test/fasta/sdk_test.dart b/pkg/front_end/test/fasta/sdk_test.dart
index 6341091..27073c4 100644
--- a/pkg/front_end/test/fasta/sdk_test.dart
+++ b/pkg/front_end/test/fasta/sdk_test.dart
@@ -4,8 +4,6 @@
 
 library fasta.test.sdk_test;
 
-import 'dart:async' show Future;
-
 import 'testing/suite.dart';
 
 Future<FastaContext> createContext(
diff --git a/pkg/front_end/test/fasta/strong_tester.dart b/pkg/front_end/test/fasta/strong_tester.dart
index 402ff57..83d9ab3 100644
--- a/pkg/front_end/test/fasta/strong_tester.dart
+++ b/pkg/front_end/test/fasta/strong_tester.dart
@@ -4,7 +4,6 @@
 
 library fasta.test.strong_test;
 
-import 'dart:async' show Future;
 import 'dart:io' show Platform;
 
 import 'testing/suite.dart';
diff --git a/pkg/front_end/test/fasta/testing/suite.dart b/pkg/front_end/test/fasta/testing/suite.dart
index 4ccb3b1..c9d68e8 100644
--- a/pkg/front_end/test/fasta/testing/suite.dart
+++ b/pkg/front_end/test/fasta/testing/suite.dart
@@ -4,8 +4,6 @@
 
 library fasta.testing.suite;
 
-import 'dart:async' show Future;
-
 import 'dart:convert' show jsonDecode;
 
 import 'dart:io' show Directory, File, Platform;
diff --git a/pkg/front_end/test/fasta/text_serialization_tester.dart b/pkg/front_end/test/fasta/text_serialization_tester.dart
index 3a0deda..13ee181 100644
--- a/pkg/front_end/test/fasta/text_serialization_tester.dart
+++ b/pkg/front_end/test/fasta/text_serialization_tester.dart
@@ -4,7 +4,6 @@
 
 library fasta.test.text_serialization_test;
 
-import 'dart:async' show Future;
 import 'dart:io' show Platform;
 
 import 'testing/suite.dart';
diff --git a/pkg/front_end/test/fasta/textual_outline_suite.dart b/pkg/front_end/test/fasta/textual_outline_suite.dart
index 6127a28..702b2fc 100644
--- a/pkg/front_end/test/fasta/textual_outline_suite.dart
+++ b/pkg/front_end/test/fasta/textual_outline_suite.dart
@@ -4,7 +4,6 @@
 
 library fasta.test.textual_outline_test;
 
-import 'dart:async' show Future;
 import 'dart:io';
 
 import 'package:dart_style/dart_style.dart' show DartFormatter;
diff --git a/pkg/front_end/test/fasta/weak_suite.dart b/pkg/front_end/test/fasta/weak_suite.dart
index 6316e60..604a480 100644
--- a/pkg/front_end/test/fasta/weak_suite.dart
+++ b/pkg/front_end/test/fasta/weak_suite.dart
@@ -4,8 +4,6 @@
 
 library fasta.test.weak_test;
 
-import 'dart:async' show Future;
-
 import 'testing/suite.dart';
 
 Future<FastaContext> createContext(
diff --git a/pkg/front_end/test/hot_reload_e2e_test.dart b/pkg/front_end/test/hot_reload_e2e_test.dart
index 939d3a0..d64dcd3 100644
--- a/pkg/front_end/test/hot_reload_e2e_test.dart
+++ b/pkg/front_end/test/hot_reload_e2e_test.dart
@@ -7,7 +7,7 @@
 /// reload on the running program.
 library front_end.incremental.hot_reload_e2e_test;
 
-import 'dart:async' show Completer, Future;
+import 'dart:async' show Completer;
 
 import 'dart:convert' show LineSplitter, utf8;
 
diff --git a/pkg/front_end/test/incremental_bulk_compiler_full.dart b/pkg/front_end/test/incremental_bulk_compiler_full.dart
index ad1a7f3..03ac980 100644
--- a/pkg/front_end/test/incremental_bulk_compiler_full.dart
+++ b/pkg/front_end/test/incremental_bulk_compiler_full.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:expect/expect.dart' show Expect;
 
 import 'package:front_end/src/api_prototype/compiler_options.dart'
diff --git a/pkg/front_end/test/incremental_bulk_compiler_smoke_suite.dart b/pkg/front_end/test/incremental_bulk_compiler_smoke_suite.dart
index 866104c..28f3352 100644
--- a/pkg/front_end/test/incremental_bulk_compiler_smoke_suite.dart
+++ b/pkg/front_end/test/incremental_bulk_compiler_smoke_suite.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:testing/testing.dart' show Chain, runMe;
 
 import 'incremental_bulk_compiler_full.dart' show Context;
diff --git a/pkg/front_end/test/incremental_dart2js_load_from_dill_test.dart b/pkg/front_end/test/incremental_dart2js_load_from_dill_test.dart
index 2d7e57c..844ecd5 100644
--- a/pkg/front_end/test/incremental_dart2js_load_from_dill_test.dart
+++ b/pkg/front_end/test/incremental_dart2js_load_from_dill_test.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:io' show Directory, File;
 
 import 'package:expect/expect.dart' show Expect;
diff --git a/pkg/front_end/test/incremental_load_from_dill_suite.dart b/pkg/front_end/test/incremental_load_from_dill_suite.dart
index 69abdd8..31ffc06 100644
--- a/pkg/front_end/test/incremental_load_from_dill_suite.dart
+++ b/pkg/front_end/test/incremental_load_from_dill_suite.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:developer' show debugger;
 
 import 'dart:io' show Directory, File;
@@ -1908,8 +1906,11 @@
     Name fieldName = new Name("unique_SimulateTransformer");
     Field field = new Field(fieldName,
         isFinal: true,
-        reference: lib.reference.canonicalName
+        getterReference: lib.reference.canonicalName
             ?.getChildFromFieldWithName(fieldName)
+            ?.reference,
+        setterReference: lib.reference.canonicalName
+            ?.getChildFromFieldSetterWithName(fieldName)
             ?.reference);
     lib.addField(field);
     for (Class c in lib.classes) {
@@ -1920,8 +1921,11 @@
       fieldName = new Name("unique_SimulateTransformer");
       field = new Field(fieldName,
           isFinal: true,
-          reference: c.reference.canonicalName
+          getterReference: c.reference.canonicalName
               ?.getChildFromFieldWithName(fieldName)
+              ?.reference,
+          setterReference: c.reference.canonicalName
+              ?.getChildFromFieldSetterWithName(fieldName)
               ?.reference);
       c.addField(field);
     }
diff --git a/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart b/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
index 7f9e8d2..1f8b19a 100644
--- a/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
+++ b/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:io' show File;
 
 import 'package:_fe_analyzer_shared/src/messages/diagnostic_message.dart'
diff --git a/pkg/front_end/test/lint_suite.dart b/pkg/front_end/test/lint_suite.dart
index 2831434..938c1bf 100644
--- a/pkg/front_end/test/lint_suite.dart
+++ b/pkg/front_end/test/lint_suite.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:io' show Directory, File, FileSystemEntity;
 
 import 'dart:typed_data' show Uint8List;
diff --git a/pkg/front_end/test/parser_all_suite.dart b/pkg/front_end/test/parser_all_suite.dart
index 543dbf9..9b60aae 100644
--- a/pkg/front_end/test/parser_all_suite.dart
+++ b/pkg/front_end/test/parser_all_suite.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:testing/testing.dart' show Chain, ChainContext, runMe;
 
 import 'parser_suite.dart';
diff --git a/pkg/front_end/test/parser_suite.dart b/pkg/front_end/test/parser_suite.dart
index 9e03711..da464ac 100644
--- a/pkg/front_end/test/parser_suite.dart
+++ b/pkg/front_end/test/parser_suite.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:convert' show jsonDecode;
 
 import 'dart:io' show File;
diff --git a/pkg/front_end/test/read_dill_from_binary_md_test.dart b/pkg/front_end/test/read_dill_from_binary_md_test.dart
index 4907f4e..2331db5 100644
--- a/pkg/front_end/test/read_dill_from_binary_md_test.dart
+++ b/pkg/front_end/test/read_dill_from_binary_md_test.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:io' show File, Platform;
 
 import 'package:kernel/target/targets.dart' show NoneTarget, TargetFlags;
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index a339577..fcf1279 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -1108,6 +1108,7 @@
 tags
 tailor
 taking
+talk
 talks
 tb
 team
diff --git a/pkg/front_end/test/spelling_test_base.dart b/pkg/front_end/test/spelling_test_base.dart
index 9bafa38..23d64a5 100644
--- a/pkg/front_end/test/spelling_test_base.dart
+++ b/pkg/front_end/test/spelling_test_base.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:io' show File, Platform;
 
 import 'dart:typed_data' show Uint8List;
diff --git a/pkg/front_end/test/spelling_test_external_targets.dart b/pkg/front_end/test/spelling_test_external_targets.dart
index 0330b22..79ff96c 100644
--- a/pkg/front_end/test/spelling_test_external_targets.dart
+++ b/pkg/front_end/test/spelling_test_external_targets.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'dart:io' show Directory, File, FileSystemEntity;
 
 import 'package:testing/testing.dart'
diff --git a/pkg/front_end/test/spelling_test_not_src_suite.dart b/pkg/front_end/test/spelling_test_not_src_suite.dart
index 3259c88..a6205de 100644
--- a/pkg/front_end/test/spelling_test_not_src_suite.dart
+++ b/pkg/front_end/test/spelling_test_not_src_suite.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:testing/testing.dart' show Chain, runMe;
 
 import 'spelling_test_base.dart';
diff --git a/pkg/front_end/test/spelling_test_src_suite.dart b/pkg/front_end/test/spelling_test_src_suite.dart
index afea1e0..dfd1117 100644
--- a/pkg/front_end/test/spelling_test_src_suite.dart
+++ b/pkg/front_end/test/spelling_test_src_suite.dart
@@ -2,8 +2,6 @@
 // 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' show Future;
-
 import 'package:testing/testing.dart' show Chain, runMe;
 
 import 'spelling_test_base.dart';
diff --git a/pkg/front_end/test/src/base/processed_options_test.dart b/pkg/front_end/test/src/base/processed_options_test.dart
index 50a7939..b004fb1 100644
--- a/pkg/front_end/test/src/base/processed_options_test.dart
+++ b/pkg/front_end/test/src/base/processed_options_test.dart
@@ -2,8 +2,6 @@
 // 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:front_end/src/api_prototype/compiler_options.dart';
 import 'package:front_end/src/api_prototype/memory_file_system.dart';
 import 'package:front_end/src/base/processed_options.dart';
diff --git a/pkg/front_end/test/standard_file_system_test.dart b/pkg/front_end/test/standard_file_system_test.dart
index 5644c98..5f5fd02 100644
--- a/pkg/front_end/test/standard_file_system_test.dart
+++ b/pkg/front_end/test/standard_file_system_test.dart
@@ -5,7 +5,6 @@
 
 library front_end.test.standard_file_system_test;
 
-import 'dart:async';
 import 'dart:convert';
 import 'dart:io' as io;
 import 'dart:math' show Random;
diff --git a/pkg/front_end/test/type_labeler_test.dart b/pkg/front_end/test/type_labeler_test.dart
index bab4138..40e862f 100644
--- a/pkg/front_end/test/type_labeler_test.dart
+++ b/pkg/front_end/test/type_labeler_test.dart
@@ -223,22 +223,28 @@
   check({symConst: "#foo", symLibConst: "#dart:core::bar"}, 0);
 
   Constant fooConst = new InstanceConstant(
-      fooClass.reference, [], {booField.reference: trueConst});
+      fooClass.reference, [], {booField.getterReference: trueConst});
   check({fooConst: "Foo {boo: true}"}, 1);
 
-  Constant foo2Const = new InstanceConstant(foo2Class.reference, [],
-      {nextField.reference: nullConst, valueField.reference: intConst});
+  Constant foo2Const = new InstanceConstant(foo2Class.reference, [], {
+    nextField.getterReference: nullConst,
+    valueField.getterReference: intConst
+  });
   check({foo2Const: "Foo {value: 2, next: null}"}, 1);
 
   Constant foo2nConst = new InstanceConstant(foo2Class.reference, [], {
-    valueField.reference: intConst,
-    nextField.reference: new InstanceConstant(foo2Class.reference, [],
-        {valueField.reference: intConst, nextField.reference: nullConst}),
+    valueField.getterReference: intConst,
+    nextField.getterReference: new InstanceConstant(foo2Class.reference, [], {
+      valueField.getterReference: intConst,
+      nextField.getterReference: nullConst
+    }),
   });
   check({foo2nConst: "Foo {value: 2, next: Foo {value: 2, next: null}}"}, 1);
 
-  Constant bazFooFoo2Const = new InstanceConstant(bazClass.reference,
-      [foo, foo2], {xField.reference: fooConst, yField.reference: foo2Const});
+  Constant bazFooFoo2Const = new InstanceConstant(
+      bazClass.reference,
+      [foo, foo2],
+      {xField.getterReference: fooConst, yField.getterReference: foo2Const});
   check({
     bazFooFoo2Const: "Baz<Foo/*1*/, Foo/*2*/> "
         "{x: Foo/*1*/ {boo: true}, y: Foo/*2*/ {value: 2, next: null}}"
diff --git a/pkg/front_end/test/utils/kernel_chain.dart b/pkg/front_end/test/utils/kernel_chain.dart
index abdc1d4..81b5e42 100644
--- a/pkg/front_end/test/utils/kernel_chain.dart
+++ b/pkg/front_end/test/utils/kernel_chain.dart
@@ -4,8 +4,6 @@
 
 library fasta.testing.kernel_chain;
 
-import 'dart:async' show Future;
-
 import 'dart:io' show Directory, File, IOSink, Platform;
 
 import 'dart:typed_data' show Uint8List;
diff --git a/pkg/front_end/test/utils/scanner_chain.dart b/pkg/front_end/test/utils/scanner_chain.dart
index 7f014e4..1bf5b45 100644
--- a/pkg/front_end/test/utils/scanner_chain.dart
+++ b/pkg/front_end/test/utils/scanner_chain.dart
@@ -10,7 +10,7 @@
 import 'package:_fe_analyzer_shared/src/scanner/io.dart' show readBytesFromFile;
 
 import 'package:testing/testing.dart'
-    show ChainContext, Future, Result, Step, TestDescription;
+    show ChainContext, Result, Step, TestDescription;
 
 class ReadFile {
   final Uri uri;
diff --git a/pkg/front_end/test/utils/validating_instrumentation.dart b/pkg/front_end/test/utils/validating_instrumentation.dart
index 8214637..9680b32 100644
--- a/pkg/front_end/test/utils/validating_instrumentation.dart
+++ b/pkg/front_end/test/utils/validating_instrumentation.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
-import 'dart:async' show Future;
-
 import 'dart:convert' show utf8;
 
 import 'dart:io' show File;
diff --git a/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_2.yaml.world.1.expect b/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_2.yaml.world.1.expect
index df74ba9c..74024f4 100644
--- a/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_2.yaml.world.1.expect
+++ b/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_2.yaml.world.1.expect
@@ -6,6 +6,7 @@
 }
 library from "package:foo/foo.dart" as foo {
 additionalExports = (a::example,
+  a::example,
   a::a)
 
   export "package:example/a.dart";
diff --git a/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_2.yaml.world.2.expect b/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_2.yaml.world.2.expect
index df74ba9c..74024f4 100644
--- a/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_2.yaml.world.2.expect
+++ b/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_2.yaml.world.2.expect
@@ -6,6 +6,7 @@
 }
 library from "package:foo/foo.dart" as foo {
 additionalExports = (a::example,
+  a::example,
   a::a)
 
   export "package:example/a.dart";
diff --git a/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_4.yaml.world.1.expect b/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_4.yaml.world.1.expect
index b716fc7..4f177a0 100644
--- a/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_4.yaml.world.1.expect
+++ b/pkg/front_end/testcases/incremental_initialize_from_dill/changing_modules_4.yaml.world.1.expect
@@ -7,7 +7,8 @@
   static field dart.core::int* x = b::mya2.{b::A2::bar};
 }
 library from "package:moduleB/b.dart" as b {
-additionalExports = (c::baz)
+additionalExports = (c::baz,
+  c::baz)
 
   import "package:moduleC/c.dart";
   export "package:moduleC/c.dart" show baz;
diff --git a/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml
new file mode 100644
index 0000000..8fb3d4f
--- /dev/null
+++ b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml
@@ -0,0 +1,58 @@
+# 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.md file.
+
+# A field has 2 references. Both should be passed when creating a new field
+# for references to both set and get to work. And both should be put in the
+# `buildersCreatedWithReferences` map so - when lazy-loading a dill library
+# with additional exports to a library that we're currently recompiling
+# those will get setup correctly too.
+
+type: newworld
+worlds:
+  - entry: main.dart
+    experiments: alternative-invalidation-strategy
+    sources:
+      main.dart: |
+        import 'libExporter.dart';
+        void foo() {
+          int value = libField;
+          libField = value+1;
+        }
+      libExporter.dart: |
+        export "lib.dart";
+        String fromLibExporter = "hello";
+      lib.dart: |
+        import "libExporter.dart";
+        int libField = 42;
+        void requireStuffFromLibExporter() {
+          print(fromLibExporter);
+        }
+    expectedLibraryCount: 3
+
+  - entry: main.dart
+    experiments: alternative-invalidation-strategy
+    worldType: updated
+    expectInitializeFromDill: false
+    invalidate:
+      - lib.dart
+    expectedLibraryCount: 3
+    expectsRebuildBodiesOnly: true
+
+  - entry: main.dart
+    experiments: alternative-invalidation-strategy
+    worldType: updated
+    expectInitializeFromDill: false
+    invalidate:
+      - libExporter.dart
+    expectedLibraryCount: 3
+    expectsRebuildBodiesOnly: true
+
+  - entry: main.dart
+    experiments: alternative-invalidation-strategy
+    worldType: updated
+    expectInitializeFromDill: false
+    invalidate:
+      - main.dart
+    expectedLibraryCount: 3
+    expectsRebuildBodiesOnly: true
\ No newline at end of file
diff --git a/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.1.expect b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.1.expect
new file mode 100644
index 0000000..cc2970c
--- /dev/null
+++ b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.1.expect
@@ -0,0 +1,28 @@
+main = <No Member>;
+library from "org-dartlang-test:///lib.dart" as lib {
+
+  import "org-dartlang-test:///libExporter.dart";
+
+  static field dart.core::int* libField = 42;
+  static method requireStuffFromLibExporter() → void {
+    dart.core::print(lib2::fromLibExporter);
+  }
+}
+library from "org-dartlang-test:///libExporter.dart" as lib2 {
+additionalExports = (lib::libField,
+  lib::libField,
+  lib::requireStuffFromLibExporter)
+
+  export "org-dartlang-test:///lib.dart";
+
+  static field dart.core::String* fromLibExporter = "hello";
+}
+library from "org-dartlang-test:///main.dart" as main {
+
+  import "org-dartlang-test:///libExporter.dart";
+
+  static method foo() → void {
+    dart.core::int* value = lib::libField;
+    lib::libField = value.{dart.core::num::+}(1);
+  }
+}
diff --git a/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.2.expect b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.2.expect
new file mode 100644
index 0000000..cc2970c
--- /dev/null
+++ b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.2.expect
@@ -0,0 +1,28 @@
+main = <No Member>;
+library from "org-dartlang-test:///lib.dart" as lib {
+
+  import "org-dartlang-test:///libExporter.dart";
+
+  static field dart.core::int* libField = 42;
+  static method requireStuffFromLibExporter() → void {
+    dart.core::print(lib2::fromLibExporter);
+  }
+}
+library from "org-dartlang-test:///libExporter.dart" as lib2 {
+additionalExports = (lib::libField,
+  lib::libField,
+  lib::requireStuffFromLibExporter)
+
+  export "org-dartlang-test:///lib.dart";
+
+  static field dart.core::String* fromLibExporter = "hello";
+}
+library from "org-dartlang-test:///main.dart" as main {
+
+  import "org-dartlang-test:///libExporter.dart";
+
+  static method foo() → void {
+    dart.core::int* value = lib::libField;
+    lib::libField = value.{dart.core::num::+}(1);
+  }
+}
diff --git a/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.3.expect b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.3.expect
new file mode 100644
index 0000000..cc2970c
--- /dev/null
+++ b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.3.expect
@@ -0,0 +1,28 @@
+main = <No Member>;
+library from "org-dartlang-test:///lib.dart" as lib {
+
+  import "org-dartlang-test:///libExporter.dart";
+
+  static field dart.core::int* libField = 42;
+  static method requireStuffFromLibExporter() → void {
+    dart.core::print(lib2::fromLibExporter);
+  }
+}
+library from "org-dartlang-test:///libExporter.dart" as lib2 {
+additionalExports = (lib::libField,
+  lib::libField,
+  lib::requireStuffFromLibExporter)
+
+  export "org-dartlang-test:///lib.dart";
+
+  static field dart.core::String* fromLibExporter = "hello";
+}
+library from "org-dartlang-test:///main.dart" as main {
+
+  import "org-dartlang-test:///libExporter.dart";
+
+  static method foo() → void {
+    dart.core::int* value = lib::libField;
+    lib::libField = value.{dart.core::num::+}(1);
+  }
+}
diff --git a/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.4.expect b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.4.expect
new file mode 100644
index 0000000..cc2970c
--- /dev/null
+++ b/pkg/front_end/testcases/incremental_initialize_from_dill/no_outline_change_43.yaml.world.4.expect
@@ -0,0 +1,28 @@
+main = <No Member>;
+library from "org-dartlang-test:///lib.dart" as lib {
+
+  import "org-dartlang-test:///libExporter.dart";
+
+  static field dart.core::int* libField = 42;
+  static method requireStuffFromLibExporter() → void {
+    dart.core::print(lib2::fromLibExporter);
+  }
+}
+library from "org-dartlang-test:///libExporter.dart" as lib2 {
+additionalExports = (lib::libField,
+  lib::libField,
+  lib::requireStuffFromLibExporter)
+
+  export "org-dartlang-test:///lib.dart";
+
+  static field dart.core::String* fromLibExporter = "hello";
+}
+library from "org-dartlang-test:///main.dart" as main {
+
+  import "org-dartlang-test:///libExporter.dart";
+
+  static method foo() → void {
+    dart.core::int* value = lib::libField;
+    lib::libField = value.{dart.core::num::+}(1);
+  }
+}
diff --git a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.outline.expect b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.outline.expect
index 4212a8e..0f3daec 100644
--- a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.outline.expect
+++ b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.outline.expect
@@ -65,7 +65,8 @@
 //
 import self as self4;
 import "main_declaration_field_lib.dart" as mai4;
-additionalExports = (mai4::main)
+additionalExports = (mai4::main,
+  mai4::main)
 
 export "org-dartlang-testcase:///main_declaration_field_lib.dart";
 
diff --git a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.strong.expect b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.strong.expect
index eb68861..92cd79e 100644
--- a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.strong.expect
@@ -65,7 +65,8 @@
 //
 import self as self4;
 import "main_declaration_field_lib.dart" as mai4;
-additionalExports = (mai4::main)
+additionalExports = (mai4::main,
+  mai4::main)
 
 export "org-dartlang-testcase:///main_declaration_field_lib.dart";
 
diff --git a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.strong.transformed.expect
index eb68861..92cd79e 100644
--- a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.strong.transformed.expect
@@ -65,7 +65,8 @@
 //
 import self as self4;
 import "main_declaration_field_lib.dart" as mai4;
-additionalExports = (mai4::main)
+additionalExports = (mai4::main,
+  mai4::main)
 
 export "org-dartlang-testcase:///main_declaration_field_lib.dart";
 
diff --git a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.weak.expect b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.weak.expect
index c3fa573..c4ad76f 100644
--- a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.weak.expect
@@ -65,7 +65,8 @@
 //
 import self as self4;
 import "main_declaration_field_lib.dart" as mai4;
-additionalExports = (mai4::main)
+additionalExports = (mai4::main,
+  mai4::main)
 
 export "org-dartlang-testcase:///main_declaration_field_lib.dart";
 
diff --git a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.weak.transformed.expect
index c3fa573..c4ad76f 100644
--- a/pkg/front_end/testcases/nnbd/export_main_declaration.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/export_main_declaration.dart.weak.transformed.expect
@@ -65,7 +65,8 @@
 //
 import self as self4;
 import "main_declaration_field_lib.dart" as mai4;
-additionalExports = (mai4::main)
+additionalExports = (mai4::main,
+  mai4::main)
 
 export "org-dartlang-testcase:///main_declaration_field_lib.dart";
 
diff --git a/pkg/front_end/testcases/regress/issue_36647.dart.outline.expect b/pkg/front_end/testcases/regress/issue_36647.dart.outline.expect
index 67b102e..9ece05e 100644
--- a/pkg/front_end/testcases/regress/issue_36647.dart.outline.expect
+++ b/pkg/front_end/testcases/regress/issue_36647.dart.outline.expect
@@ -9,6 +9,8 @@
 import "issue_36647_lib2.dart" as iss;
 additionalExports = (iss::xxx,
   iss::XXX,
+  iss::XXX,
+  iss::extends,
   iss::extends)
 
 export "org-dartlang-testcase:///issue_36647_lib2.dart";
diff --git a/pkg/front_end/testcases/regress/issue_36647.dart.strong.expect b/pkg/front_end/testcases/regress/issue_36647.dart.strong.expect
index 3ad0fc9..85c932b 100644
--- a/pkg/front_end/testcases/regress/issue_36647.dart.strong.expect
+++ b/pkg/front_end/testcases/regress/issue_36647.dart.strong.expect
@@ -9,6 +9,8 @@
 import "issue_36647_lib2.dart" as iss;
 additionalExports = (iss::xxx,
   iss::XXX,
+  iss::XXX,
+  iss::extends,
   iss::extends)
 
 export "org-dartlang-testcase:///issue_36647_lib2.dart";
diff --git a/pkg/front_end/testcases/regress/issue_36647.dart.strong.transformed.expect b/pkg/front_end/testcases/regress/issue_36647.dart.strong.transformed.expect
index 3ad0fc9..85c932b 100644
--- a/pkg/front_end/testcases/regress/issue_36647.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_36647.dart.strong.transformed.expect
@@ -9,6 +9,8 @@
 import "issue_36647_lib2.dart" as iss;
 additionalExports = (iss::xxx,
   iss::XXX,
+  iss::XXX,
+  iss::extends,
   iss::extends)
 
 export "org-dartlang-testcase:///issue_36647_lib2.dart";
diff --git a/pkg/front_end/testcases/regress/issue_36647_2.dart.outline.expect b/pkg/front_end/testcases/regress/issue_36647_2.dart.outline.expect
index eddabae..e7ebe11 100644
--- a/pkg/front_end/testcases/regress/issue_36647_2.dart.outline.expect
+++ b/pkg/front_end/testcases/regress/issue_36647_2.dart.outline.expect
@@ -2,6 +2,7 @@
 import self as self;
 import "issue_36647_2_lib1.dart" as iss;
 additionalExports = (iss::foo,
+  iss::foo,
   iss::bar,
   iss::baz)
 
diff --git a/pkg/front_end/testcases/regress/issue_36647_2.dart.strong.expect b/pkg/front_end/testcases/regress/issue_36647_2.dart.strong.expect
index 5180e18..79c30c6 100644
--- a/pkg/front_end/testcases/regress/issue_36647_2.dart.strong.expect
+++ b/pkg/front_end/testcases/regress/issue_36647_2.dart.strong.expect
@@ -2,6 +2,7 @@
 import self as self;
 import "issue_36647_2_lib1.dart" as iss;
 additionalExports = (iss::foo,
+  iss::foo,
   iss::bar,
   iss::baz)
 
diff --git a/pkg/front_end/testcases/regress/issue_36647_2.dart.strong.transformed.expect b/pkg/front_end/testcases/regress/issue_36647_2.dart.strong.transformed.expect
index 5180e18..79c30c6 100644
--- a/pkg/front_end/testcases/regress/issue_36647_2.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/regress/issue_36647_2.dart.strong.transformed.expect
@@ -2,6 +2,7 @@
 import self as self;
 import "issue_36647_2_lib1.dart" as iss;
 additionalExports = (iss::foo,
+  iss::foo,
   iss::bar,
   iss::baz)
 
diff --git a/pkg/front_end/tool/_fasta/command_line.dart b/pkg/front_end/tool/_fasta/command_line.dart
index 12a1073..0404554 100644
--- a/pkg/front_end/tool/_fasta/command_line.dart
+++ b/pkg/front_end/tool/_fasta/command_line.dart
@@ -4,8 +4,6 @@
 
 library fasta.tool.command_line;
 
-import 'dart:async' show Future;
-
 import 'dart:io' show exit;
 
 import 'package:_fe_analyzer_shared/src/messages/severity.dart' show Severity;
diff --git a/pkg/front_end/tool/_fasta/compile_platform_legacy_test.dart b/pkg/front_end/tool/_fasta/compile_platform_legacy_test.dart
index 90a9f5f..985026c 100644
--- a/pkg/front_end/tool/_fasta/compile_platform_legacy_test.dart
+++ b/pkg/front_end/tool/_fasta/compile_platform_legacy_test.dart
@@ -4,8 +4,6 @@
 
 library fasta.test.compile_platform_test;
 
-import 'dart:async';
-
 import 'dart:io';
 
 import 'package:async_helper/async_helper.dart';
diff --git a/pkg/front_end/tool/_fasta/compile_platform_test.dart b/pkg/front_end/tool/_fasta/compile_platform_test.dart
index 90a9f5f..985026c 100644
--- a/pkg/front_end/tool/_fasta/compile_platform_test.dart
+++ b/pkg/front_end/tool/_fasta/compile_platform_test.dart
@@ -4,8 +4,6 @@
 
 library fasta.test.compile_platform_test;
 
-import 'dart:async';
-
 import 'dart:io';
 
 import 'package:async_helper/async_helper.dart';
diff --git a/pkg/front_end/tool/_fasta/entry_points.dart b/pkg/front_end/tool/_fasta/entry_points.dart
index f6f412b..03a5e96 100644
--- a/pkg/front_end/tool/_fasta/entry_points.dart
+++ b/pkg/front_end/tool/_fasta/entry_points.dart
@@ -4,8 +4,6 @@
 
 library fasta.tool.entry_points;
 
-import 'dart:async' show Stream;
-
 import 'dart:convert' show LineSplitter, jsonDecode, jsonEncode, utf8;
 
 import 'dart:io' show File, Platform, exitCode, stderr, stdin, stdout;
diff --git a/pkg/front_end/tool/_fasta/generate_messages.dart b/pkg/front_end/tool/_fasta/generate_messages.dart
index b50bee9..cd6b870 100644
--- a/pkg/front_end/tool/_fasta/generate_messages.dart
+++ b/pkg/front_end/tool/_fasta/generate_messages.dart
@@ -2,8 +2,6 @@
 // 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:io';
 
 import 'dart:isolate';
diff --git a/pkg/front_end/tool/fasta_perf.dart b/pkg/front_end/tool/fasta_perf.dart
index 8bffb28..385ec39 100644
--- a/pkg/front_end/tool/fasta_perf.dart
+++ b/pkg/front_end/tool/fasta_perf.dart
@@ -5,7 +5,6 @@
 /// An entrypoint used to run portions of fasta and measure its performance.
 library front_end.tool.fasta_perf;
 
-import 'dart:async';
 import 'dart:io';
 
 import 'package:_fe_analyzer_shared/src/parser/parser.dart';
diff --git a/pkg/front_end/tool/incremental_perf.dart b/pkg/front_end/tool/incremental_perf.dart
index 7d87595..617e448 100644
--- a/pkg/front_end/tool/incremental_perf.dart
+++ b/pkg/front_end/tool/incremental_perf.dart
@@ -42,7 +42,6 @@
 ///  updates input1.dart a second time.
 library front_end.tool.incremental_perf;
 
-import 'dart:async';
 import 'dart:convert';
 import 'dart:io' hide FileSystemEntity;
 
diff --git a/pkg/front_end/tool/perf.dart b/pkg/front_end/tool/perf.dart
index 4f10f61..95b3ba5 100644
--- a/pkg/front_end/tool/perf.dart
+++ b/pkg/front_end/tool/perf.dart
@@ -15,7 +15,6 @@
 /// outlines).
 library front_end.tool.perf;
 
-import 'dart:async';
 import 'dart:io' show Directory, File, Platform, exit;
 
 import 'package:_fe_analyzer_shared/src/scanner/scanner.dart';
diff --git a/pkg/js/CHANGELOG.md b/pkg/js/CHANGELOG.md
index 3b4897d..17e9aa3 100644
--- a/pkg/js/CHANGELOG.md
+++ b/pkg/js/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 0.6.3-nullsafety.3
+
+* Update SDK constraints to `>=2.12.0-0 <3.0.0` based on beta release
+  guidelines.
+
 ## 0.6.3-nullsafety.2
 
 * Allow prerelease versions of the `2.12` sdk.
diff --git a/pkg/js/pubspec.yaml b/pkg/js/pubspec.yaml
index 6ae05bb..90d0352 100644
--- a/pkg/js/pubspec.yaml
+++ b/pkg/js/pubspec.yaml
@@ -1,10 +1,10 @@
 name: js
-version: 0.6.3-nullsafety.2
+version: 0.6.3-nullsafety.3
 description: Annotations to create static Dart interfaces for JavaScript APIs.
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/js
 
 environment:
-  sdk: '>=2.10.0-0 <2.12.0'
+  sdk: ">=2.12.0-0 <3.0.0"
 
 dev_dependencies:
   pedantic: ^1.9.0
diff --git a/pkg/kernel/binary.md b/pkg/kernel/binary.md
index 6470e3a..6a26a6d 100644
--- a/pkg/kernel/binary.md
+++ b/pkg/kernel/binary.md
@@ -143,7 +143,7 @@
 
 type ComponentFile {
   UInt32 magic = 0x90ABCDEF;
-  UInt32 formatVersion = 49;
+  UInt32 formatVersion = 50;
   Byte[10] shortSdkHash;
   List<String> problemsAsJson; // Described in problems.md.
   Library[] libraries;
@@ -353,7 +353,8 @@
 
 type Field extends Member {
   Byte tag = 4;
-  CanonicalNameReference canonicalName;
+  CanonicalNameReference canonicalNameGetter;
+  CanonicalNameReference canonicalNameSetter;
   // An absolute path URI to the .dart file from which the field was created.
   UriReference fileUri;
   FileOffset fileOffset;
diff --git a/pkg/kernel/lib/ast.dart b/pkg/kernel/lib/ast.dart
index 9928ad2..7ce8cba 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -210,7 +210,12 @@
 
   NamedNode(Reference reference)
       : this.reference = reference ?? new Reference() {
-    this.reference.node = this;
+    if (this is Field) {
+      Field me = this;
+      me.getterReference.node = this;
+    } else {
+      this.reference.node = this;
+    }
   }
 
   CanonicalName get canonicalName => reference?.canonicalName;
@@ -537,7 +542,10 @@
     }
     for (int i = 0; i < fields.length; ++i) {
       Field field = fields[i];
-      canonicalName.getChildFromField(field).bindTo(field.reference);
+      canonicalName.getChildFromField(field).bindTo(field.getterReference);
+      canonicalName
+          .getChildFromFieldSetter(field)
+          .bindTo(field.setterReference);
     }
     for (int i = 0; i < procedures.length; ++i) {
       Procedure member = procedures[i];
@@ -1181,7 +1189,10 @@
     if (!dirty) return;
     for (int i = 0; i < fields.length; ++i) {
       Field member = fields[i];
-      canonicalName.getChildFromField(member).bindTo(member.reference);
+      canonicalName.getChildFromField(member).bindTo(member.getterReference);
+      canonicalName
+          .getChildFromFieldSetter(member)
+          .bindTo(member.setterReference);
     }
     for (int i = 0; i < procedures.length; ++i) {
       Procedure member = procedures[i];
@@ -1659,6 +1670,16 @@
   DartType type; // Not null. Defaults to DynamicType.
   int flags = 0;
   Expression initializer; // May be null.
+  final Reference setterReference;
+  @Deprecated("Use the specific getterReference/setterReference instead")
+  Reference get reference => super.reference;
+
+  Reference get getterReference => super.reference;
+  @Deprecated(
+      "Use the specific getterCanonicalName/setterCanonicalName instead")
+  CanonicalName get canonicalName => reference?.canonicalName;
+  CanonicalName get getterCanonicalName => getterReference?.canonicalName;
+  CanonicalName get setterCanonicalName => setterReference?.canonicalName;
 
   Field(Name name,
       {this.type: const DynamicType(),
@@ -1672,8 +1693,14 @@
       bool isLate: false,
       int transformerFlags: 0,
       Uri fileUri,
-      Reference reference})
-      : super(name, fileUri, reference) {
+      Reference getterReference,
+      Reference setterReference})
+      :
+        // TODO(jensj): Maybe don't create one for final fields?
+        // ('final' is a mutable setting though).
+        this.setterReference = setterReference ?? new Reference(),
+        super(name, fileUri, getterReference) {
+    this.setterReference.node = this;
     assert(type != null);
     initializer?.parent = this;
     this.isCovariant = isCovariant;
@@ -1689,6 +1716,12 @@
     this.transformerFlags = transformerFlags;
   }
 
+  @override
+  void _relinkNode() {
+    super._relinkNode();
+    this.setterReference.node = this;
+  }
+
   static const int FlagFinal = 1 << 0; // Must match serialized bit positions.
   static const int FlagConst = 1 << 1;
   static const int FlagStatic = 1 << 2;
@@ -1844,6 +1877,11 @@
   Location _getLocationInEnclosingFile(int offset) {
     return _getLocationInComponent(enclosingComponent, fileUri, offset);
   }
+
+  @override
+  void toTextInternal(AstPrinter printer) {
+    printer.writeMemberName(getterReference);
+  }
 }
 
 /// A generative constructor, possibly redirecting.
@@ -2073,7 +2111,7 @@
   void set target(Member member) {
     assert(member is Constructor ||
         (member is Procedure && member.kind == ProcedureKind.Factory));
-    targetReference = getMemberReference(member);
+    targetReference = getMemberReferenceGetter(member);
   }
 
   R accept<R>(MemberVisitor<R> v) => v.visitRedirectingFactoryConstructor(this);
@@ -2173,24 +2211,31 @@
       Member forwardingStubSuperTarget,
       Member forwardingStubInterfaceTarget,
       Member memberSignatureOrigin})
-      : this._byReferenceRenamed(name, kind, function,
-            isAbstract: isAbstract,
-            isStatic: isStatic,
-            isExternal: isExternal,
-            isConst: isConst,
-            isForwardingStub: isForwardingStub,
-            isMemberSignature: isMemberSignature,
-            isForwardingSemiStub: isForwardingSemiStub,
-            isExtensionMember: isExtensionMember,
-            transformerFlags: transformerFlags,
-            fileUri: fileUri,
-            reference: reference,
-            forwardingStubSuperTargetReference:
-                getMemberReference(forwardingStubSuperTarget),
-            forwardingStubInterfaceTargetReference:
-                getMemberReference(forwardingStubInterfaceTarget),
-            memberSignatureOriginReference:
-                getMemberReference(memberSignatureOrigin));
+      : this._byReferenceRenamed(
+          name,
+          kind,
+          function,
+          isAbstract: isAbstract,
+          isStatic: isStatic,
+          isExternal: isExternal,
+          isConst: isConst,
+          isForwardingStub: isForwardingStub,
+          isMemberSignature: isMemberSignature,
+          isForwardingSemiStub: isForwardingSemiStub,
+          isExtensionMember: isExtensionMember,
+          transformerFlags: transformerFlags,
+          fileUri: fileUri,
+          reference: reference,
+          forwardingStubSuperTargetReference:
+              getMemberReferenceBasedOnProcedureKind(
+                  forwardingStubSuperTarget, kind),
+          forwardingStubInterfaceTargetReference:
+              getMemberReferenceBasedOnProcedureKind(
+                  forwardingStubInterfaceTarget, kind),
+          memberSignatureOriginReference:
+              getMemberReferenceBasedOnProcedureKind(
+                  memberSignatureOrigin, kind),
+        );
 
   Procedure._byReferenceRenamed(Name name, this.kind, this.function,
       {bool isAbstract: false,
@@ -2359,21 +2404,24 @@
       forwardingStubSuperTargetReference?.asMember;
 
   void set forwardingStubSuperTarget(Member target) {
-    forwardingStubSuperTargetReference = getMemberReference(target);
+    forwardingStubSuperTargetReference =
+        getMemberReferenceBasedOnProcedureKind(target, kind);
   }
 
   Member get forwardingStubInterfaceTarget =>
       forwardingStubInterfaceTargetReference?.asMember;
 
   void set forwardingStubInterfaceTarget(Member target) {
-    forwardingStubInterfaceTargetReference = getMemberReference(target);
+    forwardingStubInterfaceTargetReference =
+        getMemberReferenceBasedOnProcedureKind(target, kind);
   }
 
   @override
   Member get memberSignatureOrigin => memberSignatureOriginReference?.asMember;
 
   void set memberSignatureOrigin(Member target) {
-    memberSignatureOriginReference = getMemberReference(target);
+    memberSignatureOriginReference =
+        getMemberReferenceBasedOnProcedureKind(target, kind);
   }
 
   R accept<R>(MemberVisitor<R> v) => v.visitProcedure(this);
@@ -2469,7 +2517,10 @@
   Expression value;
 
   FieldInitializer(Field field, Expression value)
-      : this.byReference(field?.reference, value);
+      : this.byReference(
+            // getterReference is used since this refers to the field itself
+            field?.getterReference,
+            value);
 
   FieldInitializer.byReference(this.fieldReference, this.value) {
     value?.parent = this;
@@ -2478,7 +2529,7 @@
   Field get field => fieldReference?.node;
 
   void set field(Field field) {
-    fieldReference = field?.reference;
+    fieldReference = field?.getterReference;
   }
 
   R accept<R>(InitializerVisitor<R> v) => v.visitFieldInitializer(this);
@@ -2521,7 +2572,10 @@
   Arguments arguments;
 
   SuperInitializer(Constructor target, Arguments arguments)
-      : this.byReference(getMemberReference(target), arguments);
+      : this.byReference(
+            // Getter vs setter doesn't matter for constructors.
+            getMemberReferenceGetter(target),
+            arguments);
 
   SuperInitializer.byReference(this.targetReference, this.arguments) {
     arguments?.parent = this;
@@ -2530,7 +2584,8 @@
   Constructor get target => targetReference?.asConstructor;
 
   void set target(Constructor target) {
-    targetReference = getMemberReference(target);
+    // Getter vs setter doesn't matter for constructors.
+    targetReference = getMemberReferenceGetter(target);
   }
 
   R accept<R>(InitializerVisitor<R> v) => v.visitSuperInitializer(this);
@@ -2569,7 +2624,10 @@
   Arguments arguments;
 
   RedirectingInitializer(Constructor target, Arguments arguments)
-      : this.byReference(getMemberReference(target), arguments);
+      : this.byReference(
+            // Getter vs setter doesn't matter for constructors.
+            getMemberReferenceGetter(target),
+            arguments);
 
   RedirectingInitializer.byReference(this.targetReference, this.arguments) {
     arguments?.parent = this;
@@ -2578,7 +2636,8 @@
   Constructor get target => targetReference?.asConstructor;
 
   void set target(Constructor target) {
-    targetReference = getMemberReference(target);
+    // Getter vs setter doesn't matter for constructors.
+    targetReference = getMemberReferenceGetter(target);
   }
 
   R accept<R>(InitializerVisitor<R> v) => v.visitRedirectingInitializer(this);
@@ -3217,7 +3276,8 @@
   Reference interfaceTargetReference;
 
   PropertyGet(Expression receiver, Name name, [Member interfaceTarget])
-      : this.byReference(receiver, name, getMemberReference(interfaceTarget));
+      : this.byReference(
+            receiver, name, getMemberReferenceGetter(interfaceTarget));
 
   PropertyGet.byReference(
       this.receiver, this.name, this.interfaceTargetReference) {
@@ -3227,7 +3287,7 @@
   Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member member) {
-    interfaceTargetReference = getMemberReference(member);
+    interfaceTargetReference = getMemberReferenceGetter(member);
   }
 
   @override
@@ -3296,7 +3356,7 @@
   PropertySet(Expression receiver, Name name, Expression value,
       [Member interfaceTarget])
       : this.byReference(
-            receiver, name, value, getMemberReference(interfaceTarget));
+            receiver, name, value, getMemberReferenceSetter(interfaceTarget));
 
   PropertySet.byReference(
       this.receiver, this.name, this.value, this.interfaceTargetReference) {
@@ -3307,7 +3367,7 @@
   Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member member) {
-    interfaceTargetReference = getMemberReference(member);
+    interfaceTargetReference = getMemberReferenceSetter(member);
   }
 
   DartType getStaticType(StaticTypeContext context) =>
@@ -3364,14 +3424,14 @@
   Reference interfaceTargetReference;
 
   SuperPropertyGet(Name name, [Member interfaceTarget])
-      : this.byReference(name, getMemberReference(interfaceTarget));
+      : this.byReference(name, getMemberReferenceGetter(interfaceTarget));
 
   SuperPropertyGet.byReference(this.name, this.interfaceTargetReference);
 
   Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member member) {
-    interfaceTargetReference = getMemberReference(member);
+    interfaceTargetReference = getMemberReferenceGetter(member);
   }
 
   DartType getStaticTypeInternal(StaticTypeContext context) {
@@ -3426,7 +3486,8 @@
   Reference interfaceTargetReference;
 
   SuperPropertySet(Name name, Expression value, Member interfaceTarget)
-      : this.byReference(name, value, getMemberReference(interfaceTarget));
+      : this.byReference(
+            name, value, getMemberReferenceSetter(interfaceTarget));
 
   SuperPropertySet.byReference(
       this.name, this.value, this.interfaceTargetReference) {
@@ -3436,7 +3497,7 @@
   Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member member) {
-    interfaceTargetReference = getMemberReference(member);
+    interfaceTargetReference = getMemberReferenceSetter(member);
   }
 
   DartType getStaticType(StaticTypeContext context) =>
@@ -3482,14 +3543,14 @@
   /// A static field, getter, or method (for tear-off).
   Reference targetReference;
 
-  StaticGet(Member target) : this.byReference(getMemberReference(target));
+  StaticGet(Member target) : this.byReference(getMemberReferenceGetter(target));
 
   StaticGet.byReference(this.targetReference);
 
   Member get target => targetReference?.asMember;
 
   void set target(Member target) {
-    targetReference = getMemberReference(target);
+    targetReference = getMemberReferenceGetter(target);
   }
 
   DartType getStaticType(StaticTypeContext context) =>
@@ -3529,7 +3590,7 @@
   Expression value;
 
   StaticSet(Member target, Expression value)
-      : this.byReference(getMemberReference(target), value);
+      : this.byReference(getMemberReferenceSetter(target), value);
 
   StaticSet.byReference(this.targetReference, this.value) {
     value?.parent = this;
@@ -3538,7 +3599,7 @@
   Member get target => targetReference?.asMember;
 
   void set target(Member target) {
-    targetReference = getMemberReference(target);
+    targetReference = getMemberReferenceSetter(target);
   }
 
   DartType getStaticType(StaticTypeContext context) =>
@@ -3726,7 +3787,11 @@
   MethodInvocation(Expression receiver, Name name, Arguments arguments,
       [Member interfaceTarget])
       : this.byReference(
-            receiver, name, arguments, getMemberReference(interfaceTarget));
+            receiver,
+            name,
+            arguments,
+            // An invocation doesn't refer to the setter.
+            getMemberReferenceGetter(interfaceTarget));
 
   MethodInvocation.byReference(
       this.receiver, this.name, this.arguments, this.interfaceTargetReference) {
@@ -3737,7 +3802,8 @@
   Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member target) {
-    interfaceTargetReference = getMemberReference(target);
+    // An invocation doesn't refer to the setter.
+    interfaceTargetReference = getMemberReferenceGetter(target);
   }
 
   DartType getStaticTypeInternal(StaticTypeContext context) {
@@ -3857,7 +3923,11 @@
 
   SuperMethodInvocation(Name name, Arguments arguments,
       [Procedure interfaceTarget])
-      : this.byReference(name, arguments, getMemberReference(interfaceTarget));
+      : this.byReference(
+            name,
+            arguments,
+            // An invocation doesn't refer to the setter.
+            getMemberReferenceGetter(interfaceTarget));
 
   SuperMethodInvocation.byReference(
       this.name, this.arguments, this.interfaceTargetReference) {
@@ -3867,7 +3937,8 @@
   Procedure get interfaceTarget => interfaceTargetReference?.asProcedure;
 
   void set interfaceTarget(Procedure target) {
-    interfaceTargetReference = getMemberReference(target);
+    // An invocation doesn't refer to the setter.
+    interfaceTargetReference = getMemberReferenceGetter(target);
   }
 
   DartType getStaticTypeInternal(StaticTypeContext context) {
@@ -3927,7 +3998,10 @@
   Name get name => target?.name;
 
   StaticInvocation(Procedure target, Arguments arguments, {bool isConst: false})
-      : this.byReference(getMemberReference(target), arguments,
+      : this.byReference(
+            // An invocation doesn't refer to the setter.
+            getMemberReferenceGetter(target),
+            arguments,
             isConst: isConst);
 
   StaticInvocation.byReference(this.targetReference, this.arguments,
@@ -3938,7 +4012,8 @@
   Procedure get target => targetReference?.asProcedure;
 
   void set target(Procedure target) {
-    targetReference = getMemberReference(target);
+    // An invocation doesn't refer to the setter.
+    targetReference = getMemberReferenceGetter(target);
   }
 
   DartType getStaticTypeInternal(StaticTypeContext context) {
@@ -3991,7 +4066,10 @@
 
   ConstructorInvocation(Constructor target, Arguments arguments,
       {bool isConst: false})
-      : this.byReference(getMemberReference(target), arguments,
+      : this.byReference(
+            // A constructor doesn't refer to the setter.
+            getMemberReferenceGetter(target),
+            arguments,
             isConst: isConst);
 
   ConstructorInvocation.byReference(this.targetReference, this.arguments,
@@ -4002,7 +4080,8 @@
   Constructor get target => targetReference?.asConstructor;
 
   void set target(Constructor target) {
-    targetReference = getMemberReference(target);
+    // A constructor doesn't refer to the setter.
+    targetReference = getMemberReferenceGetter(target);
   }
 
   DartType getStaticTypeInternal(StaticTypeContext context) {
@@ -9567,6 +9646,8 @@
   void toTextInternal(AstPrinter printer) {
     // TODO(johnniwinther): Implement this.
   }
+
+  String leakingDebugToString() => astToText.debugComponentToString(this);
 }
 
 /// A tuple with file, line, and column number, for displaying human-readable
@@ -9838,11 +9919,37 @@
   }
 }
 
-/// Returns the [Reference] object for the given member.
+/// Returns the [Reference] object for the given member based on the
+/// ProcedureKind.
 ///
 /// Returns `null` if the member is `null`.
-Reference getMemberReference(Member member) {
-  return member?.reference;
+Reference getMemberReferenceBasedOnProcedureKind(
+    Member member, ProcedureKind kind) {
+  if (member == null) return null;
+  if (member is Field) {
+    if (kind == ProcedureKind.Setter) return member.setterReference;
+    return member.getterReference;
+  }
+  return member.reference;
+}
+
+/// Returns the (getter) [Reference] object for the given member.
+///
+/// Returns `null` if the member is `null`.
+/// TODO(jensj): Should it be called NotSetter instead of Getter?
+Reference getMemberReferenceGetter(Member member) {
+  if (member == null) return null;
+  if (member is Field) return member.getterReference;
+  return member.reference;
+}
+
+/// Returns the setter [Reference] object for the given member.
+///
+/// Returns `null` if the member is `null`.
+Reference getMemberReferenceSetter(Member member) {
+  if (member == null) return null;
+  if (member is Field) return member.setterReference;
+  return member.reference;
 }
 
 /// Returns the [Reference] object for the given class.
@@ -9856,12 +9963,36 @@
 /// member has not been assigned a canonical name yet.
 ///
 /// Returns `null` if the member is `null`.
-CanonicalName getCanonicalNameOfMember(Member member) {
+CanonicalName getCanonicalNameOfMemberGetter(Member member) {
   if (member == null) return null;
-  if (member.canonicalName == null) {
+  CanonicalName canonicalName;
+  if (member is Field) {
+    canonicalName = member.getterCanonicalName;
+  } else {
+    canonicalName = member.canonicalName;
+  }
+  if (canonicalName == null) {
     throw '$member has no canonical name';
   }
-  return member.canonicalName;
+  return canonicalName;
+}
+
+/// Returns the canonical name of [member], or throws an exception if the
+/// member has not been assigned a canonical name yet.
+///
+/// Returns `null` if the member is `null`.
+CanonicalName getCanonicalNameOfMemberSetter(Member member) {
+  if (member == null) return null;
+  CanonicalName canonicalName;
+  if (member is Field) {
+    canonicalName = member.setterCanonicalName;
+  } else {
+    canonicalName = member.canonicalName;
+  }
+  if (canonicalName == null) {
+    throw '$member has no canonical name';
+  }
+  return canonicalName;
 }
 
 /// Returns the canonical name of [class_], or throws an exception if the
diff --git a/pkg/kernel/lib/binary/ast_from_binary.dart b/pkg/kernel/lib/binary/ast_from_binary.dart
index 6f73e68..2c79146 100644
--- a/pkg/kernel/lib/binary/ast_from_binary.dart
+++ b/pkg/kernel/lib/binary/ast_from_binary.dart
@@ -614,6 +614,7 @@
         if (child.name != '@methods' &&
             child.name != '@typedefs' &&
             child.name != '@fields' &&
+            child.name != '@=fields' &&
             child.name != '@getters' &&
             child.name != '@setters' &&
             child.name != '@factories' &&
@@ -1284,14 +1285,17 @@
   Field readField() {
     int tag = readByte();
     assert(tag == Tag.Field);
-    var canonicalName = readCanonicalNameReference();
-    var reference = canonicalName.getReference();
-    Field node = reference.node;
+    CanonicalName getterCanonicalName = readCanonicalNameReference();
+    Reference getterReference = getterCanonicalName.getReference();
+    CanonicalName setterCanonicalName = readCanonicalNameReference();
+    Reference setterReference = setterCanonicalName.getReference();
+    Field node = getterReference.node;
     if (alwaysCreateNewNamedNodes) {
       node = null;
     }
     if (node == null) {
-      node = new Field(null, reference: reference);
+      node = new Field(null,
+          getterReference: getterReference, setterReference: setterReference);
     }
     var fileUri = readUriReference();
     int fileOffset = readOffset();
diff --git a/pkg/kernel/lib/binary/ast_to_binary.dart b/pkg/kernel/lib/binary/ast_to_binary.dart
index a5a426f..3ac762a 100644
--- a/pkg/kernel/lib/binary/ast_to_binary.dart
+++ b/pkg/kernel/lib/binary/ast_to_binary.dart
@@ -549,7 +549,7 @@
         _writeNodeMetadataImpl(component, componentOffset);
       }
       libraryOffsets = <int>[];
-      CanonicalName main = getCanonicalNameOfMember(component.mainMethod);
+      CanonicalName main = getCanonicalNameOfMemberGetter(component.mainMethod);
       if (main != null) {
         checkCanonicalName(main);
       }
@@ -749,7 +749,7 @@
     assert(_binaryOffsetForConstantTable >= 0);
     writeUInt32(_binaryOffsetForConstantTable);
 
-    CanonicalName main = getCanonicalNameOfMember(component.mainMethod);
+    CanonicalName main = getCanonicalNameOfMemberGetter(component.mainMethod);
     if (main == null) {
       writeUInt32(0);
     } else {
@@ -840,8 +840,8 @@
 
   void writeNullAllowedInstanceMemberReference(Reference reference) {
     writeNullAllowedReference(reference);
-    Member member = reference?.asMember;
-    writeNullAllowedReference(member?.memberSignatureOrigin?.reference);
+    writeNullAllowedReference(
+        getMemberReferenceGetter(reference?.asMember?.memberSignatureOrigin));
   }
 
   void writeNullAllowedReference(Reference reference) {
@@ -859,8 +859,8 @@
 
   void writeNonNullInstanceMemberReference(Reference reference) {
     writeNonNullReference(reference);
-    Member member = reference.asMember;
-    writeNullAllowedReference(member?.memberSignatureOrigin?.reference);
+    writeNullAllowedReference(
+        getMemberReferenceGetter(reference.asMember?.memberSignatureOrigin));
   }
 
   void writeNonNullReference(Reference reference) {
@@ -1167,7 +1167,7 @@
     }
     enterScope(memberScope: true);
     writeByte(Tag.Constructor);
-    writeNonNullCanonicalNameReference(getCanonicalNameOfMember(node));
+    writeNonNullCanonicalNameReference(getCanonicalNameOfMemberGetter(node));
     writeUriReference(node.fileUri);
     writeOffset(node.startFileOffset);
     writeOffset(node.fileOffset);
@@ -1222,7 +1222,7 @@
 
     enterScope(memberScope: true);
     writeByte(Tag.Procedure);
-    writeNonNullCanonicalNameReference(getCanonicalNameOfMember(node));
+    writeNonNullCanonicalNameReference(getCanonicalNameOfMemberGetter(node));
     writeUriReference(node.fileUri);
     writeOffset(node.startFileOffset);
     writeOffset(node.fileOffset);
@@ -1246,12 +1246,13 @@
 
   @override
   void visitField(Field node) {
-    if (node.canonicalName == null) {
+    if (node.getterCanonicalName == null || node.setterCanonicalName == null) {
       throw new ArgumentError('Missing canonical name for $node');
     }
     enterScope(memberScope: true);
     writeByte(Tag.Field);
-    writeNonNullCanonicalNameReference(getCanonicalNameOfMember(node));
+    writeNonNullCanonicalNameReference(getCanonicalNameOfMemberGetter(node));
+    writeNonNullCanonicalNameReference(getCanonicalNameOfMemberSetter(node));
     writeUriReference(node.fileUri);
     writeOffset(node.fileOffset);
     writeOffset(node.fileEndOffset);
@@ -1273,7 +1274,7 @@
         typeParameters: node.typeParameters,
         memberScope: true,
         variableScope: true);
-    writeNonNullCanonicalNameReference(getCanonicalNameOfMember(node));
+    writeNonNullCanonicalNameReference(getCanonicalNameOfMemberGetter(node));
     writeUriReference(node.fileUri);
     writeOffset(node.fileOffset);
     writeOffset(node.fileEndOffset);
diff --git a/pkg/kernel/lib/binary/tag.dart b/pkg/kernel/lib/binary/tag.dart
index ebdf993..5b46f8e 100644
--- a/pkg/kernel/lib/binary/tag.dart
+++ b/pkg/kernel/lib/binary/tag.dart
@@ -146,7 +146,7 @@
   /// Internal version of kernel binary format.
   /// Bump it when making incompatible changes in kernel binaries.
   /// Keep in sync with runtime/vm/kernel_binary.h, pkg/kernel/binary.md.
-  static const int BinaryFormatVersion = 49;
+  static const int BinaryFormatVersion = 50;
 }
 
 abstract class ConstantTag {
diff --git a/pkg/kernel/lib/canonical_name.dart b/pkg/kernel/lib/canonical_name.dart
index 27e66ef..526c32e 100644
--- a/pkg/kernel/lib/canonical_name.dart
+++ b/pkg/kernel/lib/canonical_name.dart
@@ -131,6 +131,10 @@
     return getChild('@fields').getChildFromQualifiedName(field.name);
   }
 
+  CanonicalName getChildFromFieldSetter(Field field) {
+    return getChild('@=fields').getChildFromQualifiedName(field.name);
+  }
+
   CanonicalName getChildFromConstructor(Constructor constructor) {
     return getChild('@constructors')
         .getChildFromQualifiedName(constructor.name);
@@ -146,6 +150,10 @@
     return getChild('@fields').getChildFromQualifiedName(name);
   }
 
+  CanonicalName getChildFromFieldSetterWithName(Name name) {
+    return getChild('@=fields').getChildFromQualifiedName(name);
+  }
+
   CanonicalName getChildFromTypedef(Typedef typedef_) {
     return getChild('@typedefs').getChild(typedef_.name);
   }
diff --git a/pkg/kernel/lib/clone.dart b/pkg/kernel/lib/clone.dart
index f83e594..d70b550 100644
--- a/pkg/kernel/lib/clone.dart
+++ b/pkg/kernel/lib/clone.dart
@@ -680,7 +680,8 @@
         hasImplicitSetter: node.hasImplicitSetter,
         transformerFlags: node.transformerFlags,
         fileUri: _activeFileUri,
-        reference: referenceFrom?.reference)
+        getterReference: referenceFrom?.getterReference,
+        setterReference: referenceFrom?.setterReference)
       ..annotations = cloneAnnotations && !node.annotations.isEmpty
           ? node.annotations.map(super.clone).toList()
           : const <Expression>[]
diff --git a/pkg/kernel/lib/text/ast_to_text.dart b/pkg/kernel/lib/text/ast_to_text.dart
index 3e253af..d13d0c9 100644
--- a/pkg/kernel/lib/text/ast_to_text.dart
+++ b/pkg/kernel/lib/text/ast_to_text.dart
@@ -169,6 +169,13 @@
   return '$buffer';
 }
 
+String debugComponentToString(Component component) {
+  StringBuffer buffer = new StringBuffer();
+  new Printer(buffer, syntheticNames: new NameSystem())
+      .writeComponentFile(component);
+  return '$buffer';
+}
+
 String componentToString(Component node) {
   StringBuffer buffer = new StringBuffer();
   new Printer(buffer, syntheticNames: new NameSystem())
diff --git a/pkg/kernel/lib/transformations/track_widget_constructor_locations.dart b/pkg/kernel/lib/transformations/track_widget_constructor_locations.dart
index 3713e32..7585b5c 100644
--- a/pkg/kernel/lib/transformations/track_widget_constructor_locations.dart
+++ b/pkg/kernel/lib/transformations/track_widget_constructor_locations.dart
@@ -379,7 +379,7 @@
         type:
             new InterfaceType(_locationClass, clazz.enclosingLibrary.nullable),
         isFinal: true,
-        reference: clazz.reference.canonicalName
+        getterReference: clazz.reference.canonicalName
             ?.getChildFromFieldWithName(fieldName)
             ?.reference);
     clazz.addField(locationField);
diff --git a/pkg/kernel/lib/vm/constants_native_effects.dart b/pkg/kernel/lib/vm/constants_native_effects.dart
index 2dc607d..fb52988 100644
--- a/pkg/kernel/lib/vm/constants_native_effects.dart
+++ b/pkg/kernel/lib/vm/constants_native_effects.dart
@@ -45,7 +45,8 @@
       constant.keyType,
       constant.valueType,
     ], <Reference, Constant>{
-      kvPairListField.reference: kvListConstant,
+      // We use getterReference as we refer to the field itself.
+      kvPairListField.getterReference: kvListConstant,
     });
   }
 }
diff --git a/pkg/kernel/test/convert_field_to_setter_getter.dart b/pkg/kernel/test/convert_field_to_setter_getter.dart
new file mode 100644
index 0000000..fc45c7b
--- /dev/null
+++ b/pkg/kernel/test/convert_field_to_setter_getter.dart
@@ -0,0 +1,193 @@
+// 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:io';
+
+import 'package:kernel/ast.dart';
+import 'package:kernel/binary/ast_from_binary.dart';
+import 'package:kernel/binary/ast_to_binary.dart';
+
+main() {
+  final Library lib1 = new Library(Uri.parse('org-dartlang:///lib.dart'));
+  final Field field = new Field(new Name("f"));
+  lib1.addField(field);
+  final Block libProcedureBody = new Block([
+    new ExpressionStatement(new StaticSet(field, new IntLiteral(42))),
+    new ReturnStatement(new StaticGet(field)),
+  ]);
+  final Procedure libProcedure = new Procedure(
+      new Name("method"),
+      ProcedureKind.Method,
+      new FunctionNode(libProcedureBody, returnType: new DynamicType()));
+  lib1.addProcedure(libProcedure);
+
+  final Library lib2 = new Library(Uri.parse('org-dartlang:///lib2.dart'));
+  final Block lib2ProcedureBody = new Block([
+    new ExpressionStatement(new StaticSet(field, new IntLiteral(43))),
+    new ReturnStatement(new StaticGet(field)),
+  ]);
+  final Procedure lib2Procedure = new Procedure(
+      new Name("method"),
+      ProcedureKind.Method,
+      new FunctionNode(lib2ProcedureBody, returnType: new DynamicType()));
+  lib2.addProcedure(lib2Procedure);
+
+  verifyTargets(libProcedure, lib2Procedure, field, field);
+  List<int> writtenBytesFieldOriginal = serialize(lib1, lib2);
+  // Canonical names are now set: Verify that the field is marked as such,
+  // canonical-name-wise.
+  if (field.getterCanonicalName.parent.name != "@fields") {
+    throw "Expected @fields parent, but had "
+        "${field.getterCanonicalName.parent.name}";
+  }
+  if (field.setterCanonicalName.parent.name != "@=fields") {
+    throw "Expected @=fields parent, but had "
+        "${field.setterCanonicalName.parent.name}";
+  }
+
+  // Replace the field with a setter/getter pair.
+  lib1.fields.remove(field);
+  FunctionNode getterFunction = new FunctionNode(new Block([]));
+  Procedure getter = new Procedure(
+      new Name("f"), ProcedureKind.Getter, getterFunction,
+      reference: field.getterReference);
+  // Important: Unbind any old canonical name
+  // (nulling out the canonical name is not enough because it leaves the old
+  // canonical name (which always stays alive) with a pointer to the reference,
+  // meaning that if one tried to rebind it (e.g. if going back to a field from
+  // a setter/getter), the reference wouldn't (because of the way `bindTo` is
+  // implemented) actually have it's canonical name set, and serialization
+  // wouldn't work.)
+  field.getterReference?.canonicalName?.unbind();
+  lib1.addProcedure(getter);
+
+  FunctionNode setterFunction = new FunctionNode(new Block([]),
+      positionalParameters: [new VariableDeclaration("foo")]);
+  Procedure setter = new Procedure(
+      new Name("f"), ProcedureKind.Setter, setterFunction,
+      reference: field.setterReference);
+  // Important: Unbind any old canonical name
+  // (nulling out the canonical name is not enough, see above).
+  field.setterReference?.canonicalName?.unbind();
+  lib1.addProcedure(setter);
+
+  verifyTargets(libProcedure, lib2Procedure, getter, setter);
+  List<int> writtenBytesGetterSetter = serialize(lib1, lib2);
+  // Canonical names are now set: Verify that the getter/setter is marked as
+  // such, canonical-name-wise.
+  if (getter.canonicalName.parent.name != "@getters") {
+    throw "Expected @getters parent, but had "
+        "${getter.canonicalName.parent.name}";
+  }
+  if (setter.canonicalName.parent.name != "@setters") {
+    throw "Expected @setters parent, but had "
+        "${setter.canonicalName.parent.name}";
+  }
+
+  // Replace getter/setter with field.
+  lib1.procedures.remove(getter);
+  lib1.procedures.remove(setter);
+  final Field fieldReplacement = new Field(new Name("f"),
+      getterReference: getter.reference, setterReference: setter.reference);
+  // Important: Unbind any old canonical name
+  // (nulling out the canonical name is not enough, see above).
+  fieldReplacement.getterReference?.canonicalName?.unbind();
+  fieldReplacement.setterReference?.canonicalName?.unbind();
+  lib1.addField(fieldReplacement);
+
+  verifyTargets(
+      libProcedure, lib2Procedure, fieldReplacement, fieldReplacement);
+  List<int> writtenBytesFieldNew = serialize(lib1, lib2);
+  // Canonical names are now set: Verify that the field is marked as such,
+  // canonical-name-wise.
+  if (fieldReplacement.getterCanonicalName.parent.name != "@fields") {
+    throw "Expected @fields parent, but had "
+        "${fieldReplacement.getterCanonicalName.parent.name}";
+  }
+  if (fieldReplacement.setterCanonicalName.parent.name != "@=fields") {
+    throw "Expected @=fields parent, but had "
+        "${fieldReplacement.setterCanonicalName.parent.name}";
+  }
+
+  // Load the written stuff and ensure it is as expected.
+  // First one has a field.
+  Component componentLoaded = new Component();
+  new BinaryBuilder(writtenBytesFieldOriginal)
+      .readSingleFileComponent(componentLoaded);
+  verifyTargets(
+      componentLoaded.libraries[0].procedures.single,
+      componentLoaded.libraries[1].procedures.single,
+      componentLoaded.libraries[0].fields.single,
+      componentLoaded.libraries[0].fields.single);
+
+  // Second one has a getter/setter pair.
+  componentLoaded = new Component();
+  new BinaryBuilder(writtenBytesGetterSetter)
+      .readSingleFileComponent(componentLoaded);
+  assert(componentLoaded.libraries[0].procedures[2].isSetter);
+  verifyTargets(
+      componentLoaded.libraries[0].procedures[0],
+      componentLoaded.libraries[1].procedures[0],
+      componentLoaded.libraries[0].procedures[1],
+      componentLoaded.libraries[0].procedures[2]);
+
+  // Third one has a field again.
+  componentLoaded = new Component();
+  new BinaryBuilder(writtenBytesFieldNew)
+      .readSingleFileComponent(componentLoaded);
+  verifyTargets(
+      componentLoaded.libraries[0].procedures.single,
+      componentLoaded.libraries[1].procedures.single,
+      componentLoaded.libraries[0].fields.single,
+      componentLoaded.libraries[0].fields.single);
+}
+
+void verifyTargets(Procedure libProcedure, Procedure lib2Procedure,
+    Member getterTarget, Member setterTarget) {
+  if (getGetTarget(libProcedure) != getterTarget) {
+    throw "Unexpected get target for lib #1";
+  }
+  if (getSetTarget(libProcedure) != setterTarget) {
+    throw "Unexpected set target for lib #1";
+  }
+  if (getGetTarget(lib2Procedure) != getterTarget) {
+    throw "Unexpected get target for lib #2";
+  }
+  if (getSetTarget(lib2Procedure) != setterTarget) {
+    throw "Unexpected set target for lib #2";
+  }
+}
+
+List<int> serialize(Library lib1, Library lib2) {
+  Component component = new Component(libraries: [lib1, lib2])
+    ..setMainMethodAndMode(null, false, NonNullableByDefaultCompiledMode.Weak);
+  ByteSink sink = new ByteSink();
+  new BinaryPrinter(sink).writeComponentFile(component);
+  return sink.builder.takeBytes();
+}
+
+Member getSetTarget(Procedure p) {
+  Block block = p.function.body;
+  ExpressionStatement getterStatement = block.statements[0];
+  StaticSet staticSet = getterStatement.expression;
+  return staticSet.target;
+}
+
+Member getGetTarget(Procedure p) {
+  Block block = p.function.body;
+  ReturnStatement setterStatement = block.statements[1];
+  StaticGet staticGet = setterStatement.expression;
+  return staticGet.target;
+}
+
+/// A [Sink] that directly writes data into a byte builder.
+class ByteSink implements Sink<List<int>> {
+  final BytesBuilder builder = new BytesBuilder();
+
+  void add(List<int> data) {
+    builder.add(data);
+  }
+
+  void close() {}
+}
diff --git a/pkg/kernel/test/metadata_test.dart b/pkg/kernel/test/metadata_test.dart
index dd557fb..5b362f1 100644
--- a/pkg/kernel/test/metadata_test.dart
+++ b/pkg/kernel/test/metadata_test.dart
@@ -25,8 +25,11 @@
   Member get member => _memberRef?.asMember;
 
   Metadata.forNode(TreeNode n)
-      : this(n.leakingDebugToString(),
-            getMemberReference(getMemberForMetadata(n)), getTypeForMetadata(n));
+      : this(
+            n.leakingDebugToString(),
+            // Refers to the member, not about the function => use getter.
+            getMemberReferenceGetter(getMemberForMetadata(n)),
+            getTypeForMetadata(n));
 
   Metadata(this.string, this._memberRef, this.type);
 }
diff --git a/pkg/kernel/test/text_serializer_from_kernel_nodes_test.dart b/pkg/kernel/test/text_serializer_from_kernel_nodes_test.dart
index 7a55d99..cd4ae4a 100644
--- a/pkg/kernel/test/text_serializer_from_kernel_nodes_test.dart
+++ b/pkg/kernel/test/text_serializer_from_kernel_nodes_test.dart
@@ -148,7 +148,7 @@
               new ExpressionStatement(new StaticSet(field, new IntLiteral(1))),
           expectation: ''
               '(expr'
-              ' (set-static "package:foo/bar.dart::@fields::field" (int 1)))',
+              ' (set-static "package:foo/bar.dart::@=fields::field" (int 1)))',
           makeSerializationState: () => new SerializationState(null),
           makeDeserializationState: () =>
               new DeserializationState(null, component.root),
@@ -221,7 +221,7 @@
       return new TestCase<Statement>(
           name: '/* suppose A {dynamic field;} A x; */ x.{A::field};',
           node: new ExpressionStatement(new PropertyGet.byReference(
-              new VariableGet(x), field.name, field.reference)),
+              new VariableGet(x), field.name, field.getterReference)),
           expectation: ''
               '(expr (get-prop (get-var "x^0" _) (public "field")))',
           makeSerializationState: () =>
@@ -252,7 +252,7 @@
               new VariableGet(x),
               field.name,
               new IntLiteral(42),
-              field.reference)),
+              field.setterReference)),
           expectation: ''
               '(expr (set-prop (get-var "x^0" _) (public "field") (int 42)))',
           makeSerializationState: () =>
diff --git a/pkg/meta/CHANGELOG.md b/pkg/meta/CHANGELOG.md
index 743ed08..e56752f 100644
--- a/pkg/meta/CHANGELOG.md
+++ b/pkg/meta/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 1.3.0-nullsafety.6
+
+* Update SDK constraints to `>=2.12.0-0 <3.0.0` based on beta release
+    guidelines.
+
 ## 1.3.0-nullsafety.5
 
 * Allow prerelease versions of the `2.12` sdk.
diff --git a/pkg/meta/pubspec.yaml b/pkg/meta/pubspec.yaml
index a68bacd..835f447 100644
--- a/pkg/meta/pubspec.yaml
+++ b/pkg/meta/pubspec.yaml
@@ -1,5 +1,5 @@
 name: meta
-version: 1.3.0-nullsafety.5
+version: 1.3.0-nullsafety.6
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/meta
 description: >
  This library contains the declarations of annotations that developers can use
@@ -7,5 +7,4 @@
  analyzing the source code. These annotations are intended to be used by tools
  to provide a better user experience.
 environment:
-  # This must remain a tight constraint until nnbd is stable
-  sdk: '>=2.10.0-0 <2.12.0'
+  sdk: ">=2.12.0-0 <3.0.0"
diff --git a/pkg/nnbd_migration/lib/src/front_end/non_nullable_fix.dart b/pkg/nnbd_migration/lib/src/front_end/non_nullable_fix.dart
index 3c09f9b..792eeba 100644
--- a/pkg/nnbd_migration/lib/src/front_end/non_nullable_fix.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/non_nullable_fix.dart
@@ -36,7 +36,7 @@
       '${_intendedMinimumSdkVersion.major}.${_intendedMinimumSdkVersion.minor}';
 
   static final String _intendedSdkVersionConstraint =
-      '>=$_intendedMinimumSdkVersion <2.12.0';
+      '>=$_intendedMinimumSdkVersion <3.0.0';
 
   static final List<HttpPreviewServer> _allServers = [];
 
diff --git a/pkg/nnbd_migration/test/migration_cli_test.dart b/pkg/nnbd_migration/test/migration_cli_test.dart
index c62fc75..31d3cec 100644
--- a/pkg/nnbd_migration/test/migration_cli_test.dart
+++ b/pkg/nnbd_migration/test/migration_cli_test.dart
@@ -432,7 +432,7 @@
           '''
 name: test
 environment:
-  sdk: '${migrated ? '>=2.12.0-0 <2.12.0' : '>=2.6.0 <3.0.0'}'
+  sdk: '${migrated ? '>=2.12.0-0 <3.0.0' : '>=2.6.0 <3.0.0'}'
 ''',
       '.dart_tool/package_config.json':
           packageConfigText ?? _getPackageConfigText(migrated: migrated),
@@ -1794,7 +1794,7 @@
 name: test
 environment:
   foo: 1
-  sdk: '>=2.12.0-0 <2.12.0'
+  sdk: '>=2.12.0-0 <3.0.0'
 '''));
   }
 
@@ -1834,6 +1834,27 @@
             packageConfigText: _getPackageConfigText(migrated: false)));
   }
 
+  test_pubspec_has_unusual_max_sdk_constraint() async {
+    // No one should be using a weird max SDK constraint like this.  If they are
+    // doing so, we'll fix it to 3.0.0.
+    var projectContents = simpleProject(pubspecText: '''
+name: test
+environment:
+  sdk: '>=2.6.0 <2.17.4'
+''');
+    var projectDir = createProjectDir(projectContents);
+    var cliRunner = _createCli()
+        .decodeCommandLineArgs(_parseArgs(['--apply-changes', projectDir]));
+    await cliRunner.run();
+    // The Dart source code should still be migrated.
+    assertProjectContents(
+        projectDir, simpleProject(migrated: true, pubspecText: '''
+name: test
+environment:
+  sdk: '>=2.12.0-0 <3.0.0'
+'''));
+  }
+
   test_pubspec_is_missing_environment() async {
     var projectContents = simpleProject(pubspecText: '''
 name: test
@@ -1847,7 +1868,7 @@
         // This is strange-looking, but valid.
         '''
 environment:
-  sdk: '>=2.12.0-0 <2.12.0'
+  sdk: '>=2.12.0-0 <3.0.0'
 
 name: test
 '''));
diff --git a/pkg/vm/lib/metadata/direct_call.dart b/pkg/vm/lib/metadata/direct_call.dart
index 17eb4e8..b7e8277 100644
--- a/pkg/vm/lib/metadata/direct_call.dart
+++ b/pkg/vm/lib/metadata/direct_call.dart
@@ -13,7 +13,8 @@
   final bool checkReceiverForNull;
 
   DirectCallMetadata(Member target, bool checkReceiverForNull)
-      : this.byReference(getMemberReference(target), checkReceiverForNull);
+      : this.byReference(
+            getMemberReferenceGetter(target), checkReceiverForNull);
 
   DirectCallMetadata.byReference(
       this._targetReference, this.checkReceiverForNull);
@@ -40,7 +41,7 @@
   @override
   void writeToBinary(DirectCallMetadata metadata, Node node, BinarySink sink) {
     sink.writeNullAllowedCanonicalNameReference(
-        getCanonicalNameOfMember(metadata.target));
+        getCanonicalNameOfMemberGetter(metadata.target));
     sink.writeByte(metadata.checkReceiverForNull ? 1 : 0);
   }
 
diff --git a/pkg/vm/lib/transformations/ffi_definitions.dart b/pkg/vm/lib/transformations/ffi_definitions.dart
index 8986ebe..4f96426 100644
--- a/pkg/vm/lib/transformations/ffi_definitions.dart
+++ b/pkg/vm/lib/transformations/ffi_definitions.dart
@@ -398,10 +398,10 @@
 
     node.addAnnotation(ConstantExpression(
         InstanceConstant(pragmaClass.reference, [], {
-          pragmaName.reference: StringConstant("vm:ffi:struct-fields"),
+          pragmaName.getterReference: StringConstant("vm:ffi:struct-fields"),
           // TODO(dartbug.com/38158): Wrap list in class to be able to encode
           // more information when needed.
-          pragmaOptions.reference: ListConstant(
+          pragmaOptions.getterReference: ListConstant(
               InterfaceType(typeClass, Nullability.nonNullable), types)
         }),
         InterfaceType(pragmaClass, Nullability.nonNullable, [])));
@@ -528,13 +528,15 @@
   void _replaceSizeOfMethod(
       Class struct, Map<Abi, int> sizes, IndexedClass indexedClass) {
     var name = Name("#sizeOf");
+    var lookupField = indexedClass?.lookupField(name.text);
     final Field sizeOf = Field(name,
         isStatic: true,
         isFinal: true,
         initializer: _runtimeBranchOnLayout(sizes),
         type: InterfaceType(intClass, Nullability.legacy),
         fileUri: struct.fileUri,
-        reference: indexedClass?.lookupField(name.text)?.reference)
+        getterReference: lookupField?.getterReference,
+        setterReference: lookupField?.setterReference)
       ..fileOffset = struct.fileOffset;
     _makeEntryPoint(sizeOf);
     struct.addField(sizeOf);
@@ -585,8 +587,8 @@
   void _makeEntryPoint(Annotatable node) {
     node.addAnnotation(ConstantExpression(
         InstanceConstant(pragmaClass.reference, [], {
-          pragmaName.reference: StringConstant("vm:entry-point"),
-          pragmaOptions.reference: NullConstant()
+          pragmaName.getterReference: StringConstant("vm:entry-point"),
+          pragmaOptions.getterReference: NullConstant()
         }),
         InterfaceType(pragmaClass, Nullability.legacy, [])));
   }
diff --git a/pkg/vm/lib/transformations/ffi_use_sites.dart b/pkg/vm/lib/transformations/ffi_use_sites.dart
index fb6635c..16e31c7 100644
--- a/pkg/vm/lib/transformations/ffi_use_sites.dart
+++ b/pkg/vm/lib/transformations/ffi_use_sites.dart
@@ -332,6 +332,7 @@
     final nativeFunctionType = InterfaceType(
         nativeFunctionClass, Nullability.legacy, node.arguments.types);
     var name = Name("_#ffiCallback${callbackCount++}", currentLibrary);
+    var lookupField = currentLibraryIndex?.lookupField(name.text);
     final Field field = Field(name,
         type: InterfaceType(
             pointerClass, Nullability.legacy, [nativeFunctionType]),
@@ -345,7 +346,8 @@
         isStatic: true,
         isFinal: true,
         fileUri: currentLibrary.fileUri,
-        reference: currentLibraryIndex?.lookupField(name.text)?.reference)
+        getterReference: lookupField?.getterReference,
+        setterReference: lookupField?.setterReference)
       ..fileOffset = node.fileOffset;
     currentLibrary.addField(field);
     return StaticGet(field);
diff --git a/pkg/vm/lib/transformations/pragma.dart b/pkg/vm/lib/transformations/pragma.dart
index b12e44e..ce3055b 100644
--- a/pkg/vm/lib/transformations/pragma.dart
+++ b/pkg/vm/lib/transformations/pragma.dart
@@ -66,7 +66,8 @@
     if (pragmaConstant == null) return null;
 
     String pragmaName;
-    Constant name = pragmaConstant.fieldValues[coreTypes.pragmaName.reference];
+    Constant name =
+        pragmaConstant.fieldValues[coreTypes.pragmaName.getterReference];
     if (name is StringConstant) {
       pragmaName = name.value;
     } else {
@@ -74,7 +75,7 @@
     }
 
     Constant options =
-        pragmaConstant.fieldValues[coreTypes.pragmaOptions.reference];
+        pragmaConstant.fieldValues[coreTypes.pragmaOptions.getterReference];
     assert(options != null);
 
     switch (pragmaName) {
diff --git a/pkg/vm/lib/transformations/protobuf_aware_treeshaker/transformer.dart b/pkg/vm/lib/transformations/protobuf_aware_treeshaker/transformer.dart
index 7aad1d8..904f915 100644
--- a/pkg/vm/lib/transformations/protobuf_aware_treeshaker/transformer.dart
+++ b/pkg/vm/lib/transformations/protobuf_aware_treeshaker/transformer.dart
@@ -126,7 +126,7 @@
       this.addMethod, Set<Selector> dynamicSelectors, this.coreTypes, this.info)
       : tagNumberField = tagNumberClass.fields
             .firstWhere((f) => f.name.text == 'tagNumber')
-            .reference {
+            .getterReference {
     dynamicNames.addAll(dynamicSelectors.map((sel) => sel.target.text));
   }
 
diff --git a/pkg/vm/lib/transformations/type_flow/protobuf_handler.dart b/pkg/vm/lib/transformations/type_flow/protobuf_handler.dart
index 003bb2f..334eb84 100644
--- a/pkg/vm/lib/transformations/type_flow/protobuf_handler.dart
+++ b/pkg/vm/lib/transformations/type_flow/protobuf_handler.dart
@@ -103,9 +103,9 @@
         final constant = (annotation as ConstantExpression).constant;
         if (constant is InstanceConstant &&
             constant.classReference == _tagNumberClass.reference) {
-          if (messageClass._usedTags.add(
-              (constant.fieldValues[_tagNumberField.reference] as IntConstant)
-                  .value)) {
+          if (messageClass._usedTags.add((constant
+                  .fieldValues[_tagNumberField.getterReference] as IntConstant)
+              .value)) {
             _invalidatedClasses.add(messageClass);
           }
         }
diff --git a/pkg/vm_service/CHANGELOG.md b/pkg/vm_service/CHANGELOG.md
index bbb753e..4b6ac4a 100644
--- a/pkg/vm_service/CHANGELOG.md
+++ b/pkg/vm_service/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## 5.5.0
+- Update to version `3.42.0` of the spec.
+- Added optional `limit` parameter to `getStack` RPC.
+
 ## 5.4.0
 - Update to version `3.41.0` of the spec.
 - Added `PortList` class.
diff --git a/pkg/vm_service/example/vm_service_assert.dart b/pkg/vm_service/example/vm_service_assert.dart
index 617bd7c..0243d12 100644
--- a/pkg/vm_service/example/vm_service_assert.dart
+++ b/pkg/vm_service/example/vm_service_assert.dart
@@ -1105,6 +1105,7 @@
   assertString(obj.type);
   assertListOfFrame(obj.frames);
   assertListOfMessage(obj.messages);
+  assertBool(obj.truncated);
   return obj;
 }
 
diff --git a/pkg/vm_service/java/version.properties b/pkg/vm_service/java/version.properties
index ae41aeb..742d603 100644
--- a/pkg/vm_service/java/version.properties
+++ b/pkg/vm_service/java/version.properties
@@ -1 +1 @@
-version=3.41
+version=3.42
diff --git a/pkg/vm_service/lib/src/vm_service.dart b/pkg/vm_service/lib/src/vm_service.dart
index e7ed3a4..6bb049a 100644
--- a/pkg/vm_service/lib/src/vm_service.dart
+++ b/pkg/vm_service/lib/src/vm_service.dart
@@ -28,7 +28,7 @@
         HeapSnapshotObjectNoData,
         HeapSnapshotObjectNullData;
 
-const String vmServiceVersion = '3.41.0';
+const String vmServiceVersion = '3.42.0';
 
 /// @optional
 const String optional = 'optional';
@@ -733,6 +733,12 @@
   /// The `getStack` RPC is used to retrieve the current execution stack and
   /// message queue for an isolate. The isolate does not need to be paused.
   ///
+  /// If `limit` is provided, up to `limit` frames from the top of the stack
+  /// will be returned. If the stack depth is smaller than `limit` the entire
+  /// stack is returned. Note: this limit also applies to the
+  /// `asyncCausalFrames` and `awaiterFrames` stack representations in the
+  /// `Stack` response.
+  ///
   /// If `isolateId` refers to an isolate which has exited, then the `Collected`
   /// [Sentinel] is returned.
   ///
@@ -740,7 +746,7 @@
   ///
   /// This method will throw a [SentinelException] in the case a [Sentinel] is
   /// returned.
-  Future<Stack> getStack(String isolateId);
+  Future<Stack> getStack(String isolateId, {int limit});
 
   /// The `getSupportedProtocols` RPC is used to determine which protocols are
   /// supported by the current server.
@@ -1344,6 +1350,7 @@
         case 'getStack':
           response = await _serviceImplementation.getStack(
             params['isolateId'],
+            limit: params['limit'],
           );
           break;
         case 'getSupportedProtocols':
@@ -1798,8 +1805,10 @@
       _call('getProcessMemoryUsage');
 
   @override
-  Future<Stack> getStack(String isolateId) =>
-      _call('getStack', {'isolateId': isolateId});
+  Future<Stack> getStack(String isolateId, {int limit}) => _call('getStack', {
+        'isolateId': isolateId,
+        if (limit != null) 'limit': limit,
+      });
 
   @override
   Future<ProtocolList> getSupportedProtocols() =>
@@ -6664,23 +6673,40 @@
       'compiled: ${compiled}]';
 }
 
+/// The `Stack` class represents the various components of a Dart stack trace
+/// for a given isolate.
+///
+/// See [getStack].
 class Stack extends Response {
   static Stack parse(Map<String, dynamic> json) =>
       json == null ? null : Stack._fromJson(json);
 
+  /// A list of frames that make up the synchronous stack, rooted at the message
+  /// loop (i.e., the frames since the last asynchronous gap or the isolate's
+  /// entrypoint).
   List<Frame> frames;
 
+  /// A list of frames representing the asynchronous path. Comparable to
+  /// `awaiterFrames`, if provided, although some frames may be different.
   @optional
   List<Frame> asyncCausalFrames;
 
+  /// A list of frames representing the asynchronous path. Comparable to
+  /// `asyncCausalFrames`, if provided, although some frames may be different.
   @optional
   List<Frame> awaiterFrames;
 
+  /// A list of messages in the isolate's message queue.
   List<Message> messages;
 
+  /// Specifies whether or not this stack is complete or has been artificially
+  /// truncated.
+  bool truncated;
+
   Stack({
     @required this.frames,
     @required this.messages,
+    @required this.truncated,
     this.asyncCausalFrames,
     this.awaiterFrames,
   });
@@ -6698,6 +6724,7 @@
             createServiceObject(json['awaiterFrames'], const ['Frame']));
     messages = List<Message>.from(
         createServiceObject(json['messages'], const ['Message']) ?? []);
+    truncated = json['truncated'];
   }
 
   @override
@@ -6707,6 +6734,7 @@
     json.addAll({
       'frames': frames.map((f) => f.toJson()).toList(),
       'messages': messages.map((f) => f.toJson()).toList(),
+      'truncated': truncated,
     });
     _setIfNotNull(json, 'asyncCausalFrames',
         asyncCausalFrames?.map((f) => f?.toJson())?.toList());
@@ -6715,8 +6743,9 @@
     return json;
   }
 
-  String toString() =>
-      '[Stack type: ${type}, frames: ${frames}, messages: ${messages}]';
+  String toString() => '[Stack ' //
+      'type: ${type}, frames: ${frames}, messages: ${messages}, ' //
+      'truncated: ${truncated}]';
 }
 
 /// The `Success` type is used to indicate that an operation completed
diff --git a/pkg/vm_service/pubspec.yaml b/pkg/vm_service/pubspec.yaml
index 0c77a68..3b14073 100644
--- a/pkg/vm_service/pubspec.yaml
+++ b/pkg/vm_service/pubspec.yaml
@@ -2,7 +2,7 @@
 description: >-
   A library to communicate with a service implementing the Dart VM
   service protocol.
-version: 5.4.0
+version: 5.5.0
 
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/vm_service
 
diff --git a/runtime/observatory/lib/src/service/object.dart b/runtime/observatory/lib/src/service/object.dart
index 55c9d13..2d9a331 100644
--- a/runtime/observatory/lib/src/service/object.dart
+++ b/runtime/observatory/lib/src/service/object.dart
@@ -1917,8 +1917,10 @@
     return invokeRpc('setExceptionPauseMode', {'mode': mode});
   }
 
-  Future<ServiceMap> getStack() {
-    return invokeRpc('getStack', {}).then((response) => response as ServiceMap);
+  Future<ServiceMap> getStack({int? limit}) {
+    return invokeRpc('getStack', {
+      if (limit != null) 'limit': limit,
+    }).then((response) => response as ServiceMap);
   }
 
   Future<ObjectStore> getObjectStore() {
diff --git a/runtime/observatory/tests/service/dds_extension_event_history_test.dart b/runtime/observatory/tests/service/dds_extension_event_history_test.dart
new file mode 100644
index 0000000..0c3d165
--- /dev/null
+++ b/runtime/observatory/tests/service/dds_extension_event_history_test.dart
@@ -0,0 +1,52 @@
+// 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 'dart:developer';
+
+import 'package:observatory/service_io.dart';
+import 'package:test/test.dart';
+import 'client_resume_approvals_common.dart';
+import 'service_test_common.dart';
+import 'test_helper.dart';
+
+Future testMain() async {
+  // Post a total of 9 events
+  for (int i = 1; i <= 9; ++i) {
+    postEvent('Test', {
+      'id': i,
+    });
+  }
+}
+
+var tests = <IsolateTest>[
+  isPausedAtStart,
+  resumeIsolate,
+  (Isolate isolate) async {
+    final completer = Completer<void>();
+    int i = 1;
+    await subscribeToStream(isolate.vm, 'Extension', (event) async {
+      expect(event.extensionKind, 'Test');
+      expect(event.extensionData!['id'], i);
+      i++;
+
+      if (i == 10) {
+        await cancelStreamSubscription('Extension');
+        completer.complete();
+      } else if (i > 10) {
+        fail('Too many log messages');
+      }
+    });
+    await completer.future;
+  },
+];
+
+main(args) => runIsolateTests(
+      args,
+      tests,
+      enableService: false, // DDS specific feature
+      testeeConcurrent: testMain,
+      pause_on_start: true,
+      pause_on_exit: true,
+    );
diff --git a/runtime/observatory/tests/service/dds_stdout_stderr_history_test.dart b/runtime/observatory/tests/service/dds_stdout_stderr_history_test.dart
new file mode 100644
index 0000000..c0d6ba5
--- /dev/null
+++ b/runtime/observatory/tests/service/dds_stdout_stderr_history_test.dart
@@ -0,0 +1,61 @@
+// 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 'dart:io';
+
+import 'package:observatory/service_io.dart';
+import 'package:test/test.dart';
+import 'client_resume_approvals_common.dart';
+import 'service_test_common.dart';
+import 'test_helper.dart';
+
+Future testMain() async {
+  // Log a total of 9 messages
+  for (int i = 1; i <= 9; ++i) {
+    print('Stdout log$i');
+    stderr.writeln('Stderr log$i');
+  }
+}
+
+Future streamHistoryTest(Isolate isolate, String stream) async {
+  final completer = Completer<void>();
+  int i = 1;
+  await subscribeToStream(isolate.vm, stream, (event) async {
+    // Newlines are sent as separate events for some reason. Ignore them.
+    if (!event.bytesAsString!.startsWith(stream)) {
+      return;
+    }
+    expect(event.bytesAsString, '$stream log$i');
+    i++;
+
+    if (i == 10) {
+      await cancelStreamSubscription(stream);
+      completer.complete();
+    } else if (i > 10) {
+      fail('Too many log messages');
+    }
+  });
+  await completer.future;
+}
+
+var tests = <IsolateTest>[
+  isPausedAtStart,
+  resumeIsolate,
+  (Isolate isolate) async {
+    await streamHistoryTest(isolate, 'Stdout');
+  },
+  (Isolate isolate) async {
+    await streamHistoryTest(isolate, 'Stderr');
+  },
+];
+
+main(args) => runIsolateTests(
+      args,
+      tests,
+      enableService: false, // DDS specific feature
+      testeeConcurrent: testMain,
+      pause_on_start: true,
+      pause_on_exit: true,
+    );
diff --git a/runtime/observatory/tests/service/get_stack_limit_rpc_test.dart b/runtime/observatory/tests/service/get_stack_limit_rpc_test.dart
new file mode 100644
index 0000000..d80e4e1
--- /dev/null
+++ b/runtime/observatory/tests/service/get_stack_limit_rpc_test.dart
@@ -0,0 +1,102 @@
+// 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 'dart:developer';
+
+import 'package:observatory/models.dart' as M;
+import 'package:observatory/service_io.dart';
+import 'package:test/test.dart';
+import 'service_test_common.dart';
+import 'test_helper.dart';
+
+bar(int depth) {
+  if (depth == 21) {
+    debugger();
+    return;
+  }
+  foo(depth + 1);
+}
+
+foo(int depth) {
+  bar(depth + 1);
+}
+
+testMain() {
+  foo(0);
+}
+
+verifyStack(List frames, int numFrames) {
+  for (int i = 0; i < frames.length && i < numFrames; ++i) {
+    final frame = frames[i];
+    if (i < 22) {
+      expect(frame.function!.qualifiedName, (i % 2) == 0 ? 'bar' : 'foo');
+    } else if (i == 22) {
+      expect(frame.function!.qualifiedName, 'testMain');
+      break;
+    }
+  }
+}
+
+var tests = <IsolateTest>[
+  (Isolate isolate) async {
+    await hasStoppedAtBreakpoint(isolate);
+    // Sanity check.
+    expect(isolate.pauseEvent is M.PauseBreakpointEvent, isTrue);
+  },
+
+// Get stack
+  (Isolate isolate) async {
+    var stack = await isolate.getStack();
+    // Sanity check.
+    var frames = stack['frames'];
+    var asyncFrames = stack['asyncCausalFrames'];
+    var awaiterFrames = stack['awaiterFrames'];
+    expect(frames.length, greaterThanOrEqualTo(20));
+    expect(asyncFrames.length, greaterThan(frames.length));
+    expect(awaiterFrames.length, greaterThan(frames.length));
+    expect(stack['truncated'], false);
+
+    verifyStack(frames, frames.length);
+
+    final fullStackLength = frames.length;
+
+    // Try a limit > actual stack depth and expect to get the full stack with
+    // truncated async stacks.
+    stack = await isolate.getStack(limit: fullStackLength + 1);
+    frames = stack['frames'];
+    asyncFrames = stack['asyncCausalFrames'];
+    awaiterFrames = stack['awaiterFrames'];
+
+    expect(frames.length, fullStackLength);
+    expect(asyncFrames.length, fullStackLength + 1);
+    expect(asyncFrames.length, fullStackLength + 1);
+    expect(stack['truncated'], true);
+    verifyStack(frames, fullStackLength);
+
+    // Try a limit < actual stack depth and expect to get a stack of depth
+    // 'limit'.
+    stack = await isolate.getStack(limit: 10);
+    frames = stack['frames'];
+    asyncFrames = stack['asyncCausalFrames'];
+    awaiterFrames = stack['awaiterFrames'];
+
+    expect(frames.length, 10);
+    expect(asyncFrames.length, 10);
+    expect(awaiterFrames.length, 10);
+    expect(stack['truncated'], true);
+    verifyStack(frames, 10);
+  },
+// Invalid limit
+  (Isolate isolate) async {
+    try {
+      await isolate.getStack(limit: -1);
+      fail('Invalid parameter of -1 successful');
+    } on ServerRpcException {
+      // Expected.
+    }
+  }
+];
+
+main(args) => runIsolateTests(args, tests, testeeConcurrent: testMain);
diff --git a/runtime/observatory/tests/service/get_version_rpc_test.dart b/runtime/observatory/tests/service/get_version_rpc_test.dart
index c8b0244..5e1a8c9 100644
--- a/runtime/observatory/tests/service/get_version_rpc_test.dart
+++ b/runtime/observatory/tests/service/get_version_rpc_test.dart
@@ -12,7 +12,7 @@
     final result = await vm.invokeRpcNoUpgrade('getVersion', {});
     expect(result['type'], 'Version');
     expect(result['major'], 3);
-    expect(result['minor'], 41);
+    expect(result['minor'], 42);
     expect(result['_privateMajor'], 0);
     expect(result['_privateMinor'], 0);
   },
diff --git a/runtime/observatory/tests/service/network_profiling_test.dart b/runtime/observatory/tests/service/network_profiling_test.dart
index d68fbeb..3a318ca 100644
--- a/runtime/observatory/tests/service/network_profiling_test.dart
+++ b/runtime/observatory/tests/service/network_profiling_test.dart
@@ -56,11 +56,14 @@
   postEvent('socketTest', {'socket': 'test'});
 }
 
-void checkFinishEvent(ServiceEvent event) {
+bool checkFinishEvent(ServiceEvent event) {
   expect(event.kind, equals(ServiceEvent.kExtension));
-  expect(event.extensionKind, equals('socketTest'));
+  if (event.extensionKind != 'socketTest') {
+    return false;
+  }
   expect(event.extensionData, isA<Map>());
   expect(event.extensionData!['socket'], equals('test'));
+  return true;
 }
 
 var tests = <IsolateTest>[
@@ -102,9 +105,10 @@
     var sub;
     sub = await isolate.vm.listenEventStream(Isolate.kExtensionStream,
         (ServiceEvent event) {
-      checkFinishEvent(event);
-      sub.cancel();
-      completer.complete();
+      if (checkFinishEvent(event)) {
+        sub.cancel();
+        completer.complete();
+      }
     });
 
     dynamic result = await isolate.invokeRpc("invoke",
@@ -150,9 +154,10 @@
       completer = Completer();
       sub = await isolate.vm.listenEventStream(Isolate.kExtensionStream,
           (ServiceEvent event) {
-        checkFinishEvent(event);
-        sub.cancel();
-        completer.complete();
+        if (checkFinishEvent(event)) {
+          sub.cancel();
+          completer.complete();
+        }
       });
       dynamic result = await isolate.invokeRpc("invoke",
           {"targetId": lib.id, "selector": "socketTest", "argumentIds": []});
@@ -197,9 +202,10 @@
     var sub;
     sub = await isolate.vm.listenEventStream(Isolate.kExtensionStream,
         (ServiceEvent event) {
-      checkFinishEvent(event);
-      sub.cancel();
-      completer.complete();
+      if (checkFinishEvent(event)) {
+        sub.cancel();
+        completer.complete();
+      }
     });
 
     dynamic result = await isolate.invokeRpc("invoke",
diff --git a/runtime/observatory_2/lib/src/service/object.dart b/runtime/observatory_2/lib/src/service/object.dart
index fe4027b..3f61be6 100644
--- a/runtime/observatory_2/lib/src/service/object.dart
+++ b/runtime/observatory_2/lib/src/service/object.dart
@@ -1927,8 +1927,10 @@
     return invokeRpc('setExceptionPauseMode', {'mode': mode});
   }
 
-  Future<ServiceMap> getStack() {
-    return invokeRpc('getStack', {}).then((response) => response as ServiceMap);
+  Future<ServiceMap> getStack({int limit}) {
+    return invokeRpc('getStack', {
+      if (limit != null) 'limit': limit,
+    }).then((response) => response as ServiceMap);
   }
 
   Future<ObjectStore> getObjectStore() {
diff --git a/runtime/observatory_2/tests/service_2/dds_extension_event_history_test.dart b/runtime/observatory_2/tests/service_2/dds_extension_event_history_test.dart
new file mode 100644
index 0000000..ea8ab07
--- /dev/null
+++ b/runtime/observatory_2/tests/service_2/dds_extension_event_history_test.dart
@@ -0,0 +1,52 @@
+// 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 'dart:developer';
+
+import 'package:observatory_2/service_io.dart';
+import 'package:test/test.dart';
+import 'client_resume_approvals_common.dart';
+import 'service_test_common.dart';
+import 'test_helper.dart';
+
+Future testMain() async {
+  // Post a total of 9 events
+  for (int i = 1; i <= 9; ++i) {
+    postEvent('Test', {
+      'id': i,
+    });
+  }
+}
+
+var tests = <IsolateTest>[
+  isPausedAtStart,
+  resumeIsolate,
+  (Isolate isolate) async {
+    final completer = Completer<void>();
+    int i = 1;
+    await subscribeToStream(isolate.vm, 'Extension', (event) async {
+      expect(event.extensionKind, 'Test');
+      expect(event.extensionData['id'], i);
+      i++;
+
+      if (i == 10) {
+        await cancelStreamSubscription('Extension');
+        completer.complete();
+      } else if (i > 10) {
+        fail('Too many log messages');
+      }
+    });
+    await completer.future;
+  },
+];
+
+main(args) => runIsolateTests(
+      args,
+      tests,
+      enableService: false, // DDS specific feature
+      testeeConcurrent: testMain,
+      pause_on_start: true,
+      pause_on_exit: true,
+    );
diff --git a/runtime/observatory_2/tests/service_2/dds_stdout_stderr_history_test.dart b/runtime/observatory_2/tests/service_2/dds_stdout_stderr_history_test.dart
new file mode 100644
index 0000000..9fc0b7a
--- /dev/null
+++ b/runtime/observatory_2/tests/service_2/dds_stdout_stderr_history_test.dart
@@ -0,0 +1,61 @@
+// 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 'dart:io';
+
+import 'package:observatory_2/service_io.dart';
+import 'package:test/test.dart';
+import 'client_resume_approvals_common.dart';
+import 'service_test_common.dart';
+import 'test_helper.dart';
+
+Future testMain() async {
+  // Log a total of 9 messages
+  for (int i = 1; i <= 9; ++i) {
+    print('Stdout log$i');
+    stderr.writeln('Stderr log$i');
+  }
+}
+
+Future streamHistoryTest(Isolate isolate, String stream) async {
+  final completer = Completer<void>();
+  int i = 1;
+  await subscribeToStream(isolate.vm, stream, (event) async {
+    // Newlines are sent as separate events for some reason. Ignore them.
+    if (!event.bytesAsString.startsWith(stream)) {
+      return;
+    }
+    expect(event.bytesAsString, '$stream log$i');
+    i++;
+
+    if (i == 10) {
+      await cancelStreamSubscription(stream);
+      completer.complete();
+    } else if (i > 10) {
+      fail('Too many log messages');
+    }
+  });
+  await completer.future;
+}
+
+var tests = <IsolateTest>[
+  isPausedAtStart,
+  resumeIsolate,
+  (Isolate isolate) async {
+    await streamHistoryTest(isolate, 'Stdout');
+  },
+  (Isolate isolate) async {
+    await streamHistoryTest(isolate, 'Stderr');
+  },
+];
+
+main(args) => runIsolateTests(
+      args,
+      tests,
+      enableService: false, // DDS specific feature
+      testeeConcurrent: testMain,
+      pause_on_start: true,
+      pause_on_exit: true,
+    );
diff --git a/runtime/observatory_2/tests/service_2/get_stack_limit_rpc_test.dart b/runtime/observatory_2/tests/service_2/get_stack_limit_rpc_test.dart
new file mode 100644
index 0000000..4c2f286
--- /dev/null
+++ b/runtime/observatory_2/tests/service_2/get_stack_limit_rpc_test.dart
@@ -0,0 +1,102 @@
+// 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 'dart:developer';
+
+import 'package:observatory_2/models.dart' as M;
+import 'package:observatory_2/service_io.dart';
+import 'package:test/test.dart';
+import 'service_test_common.dart';
+import 'test_helper.dart';
+
+bar(int depth) {
+  if (depth == 21) {
+    debugger();
+    return;
+  }
+  foo(depth + 1);
+}
+
+foo(int depth) {
+  bar(depth + 1);
+}
+
+testMain() {
+  foo(0);
+}
+
+verifyStack(List frames, int numFrames) {
+  for (int i = 0; i < frames.length && i < numFrames; ++i) {
+    final frame = frames[i];
+    if (i < 22) {
+      expect(frame.function.qualifiedName, (i % 2) == 0 ? 'bar' : 'foo');
+    } else if (i == 22) {
+      expect(frame.function.qualifiedName, 'testMain');
+      break;
+    }
+  }
+}
+
+var tests = <IsolateTest>[
+  (Isolate isolate) async {
+    await hasStoppedAtBreakpoint(isolate);
+    // Sanity check.
+    expect(isolate.pauseEvent is M.PauseBreakpointEvent, isTrue);
+  },
+
+// Get stack
+  (Isolate isolate) async {
+    var stack = await isolate.getStack();
+    // Sanity check.
+    var frames = stack['frames'];
+    var asyncFrames = stack['asyncCausalFrames'];
+    var awaiterFrames = stack['awaiterFrames'];
+    expect(frames.length, greaterThanOrEqualTo(20));
+    expect(asyncFrames.length, greaterThan(frames.length));
+    expect(awaiterFrames.length, greaterThan(frames.length));
+    expect(stack['truncated'], false);
+
+    verifyStack(frames, frames.length);
+
+    final fullStackLength = frames.length;
+
+    // Try a limit > actual stack depth and expect to get the full stack with
+    // truncated async stacks.
+    stack = await isolate.getStack(limit: fullStackLength + 1);
+    frames = stack['frames'];
+    asyncFrames = stack['asyncCausalFrames'];
+    awaiterFrames = stack['awaiterFrames'];
+
+    expect(frames.length, fullStackLength);
+    expect(asyncFrames.length, fullStackLength + 1);
+    expect(asyncFrames.length, fullStackLength + 1);
+    expect(stack['truncated'], true);
+    verifyStack(frames, fullStackLength);
+
+    // Try a limit < actual stack depth and expect to get a stack of depth
+    // 'limit'.
+    stack = await isolate.getStack(limit: 10);
+    frames = stack['frames'];
+    asyncFrames = stack['asyncCausalFrames'];
+    awaiterFrames = stack['awaiterFrames'];
+
+    expect(frames.length, 10);
+    expect(asyncFrames.length, 10);
+    expect(awaiterFrames.length, 10);
+    expect(stack['truncated'], true);
+    verifyStack(frames, 10);
+  },
+// Invalid limit
+  (Isolate isolate) async {
+    try {
+      await isolate.getStack(limit: -1);
+      fail('Invalid parameter of -1 successful');
+    } on ServerRpcException {
+      // Expected.
+    }
+  }
+];
+
+main(args) => runIsolateTests(args, tests, testeeConcurrent: testMain);
diff --git a/runtime/observatory_2/tests/service_2/get_version_rpc_test.dart b/runtime/observatory_2/tests/service_2/get_version_rpc_test.dart
index df37cb9..5160f96 100644
--- a/runtime/observatory_2/tests/service_2/get_version_rpc_test.dart
+++ b/runtime/observatory_2/tests/service_2/get_version_rpc_test.dart
@@ -12,7 +12,7 @@
     var result = await vm.invokeRpcNoUpgrade('getVersion', {});
     expect(result['type'], equals('Version'));
     expect(result['major'], equals(3));
-    expect(result['minor'], equals(41));
+    expect(result['minor'], equals(42));
     expect(result['_privateMajor'], equals(0));
     expect(result['_privateMinor'], equals(0));
   },
diff --git a/runtime/observatory_2/tests/service_2/network_profiling_test.dart b/runtime/observatory_2/tests/service_2/network_profiling_test.dart
index 5c27795..8ba995f 100644
--- a/runtime/observatory_2/tests/service_2/network_profiling_test.dart
+++ b/runtime/observatory_2/tests/service_2/network_profiling_test.dart
@@ -56,11 +56,14 @@
   postEvent('socketTest', {'socket': 'test'});
 }
 
-Future<void> checkFinishEvent(ServiceEvent event) {
+bool checkFinishEvent(ServiceEvent event) {
   expect(event.kind, equals(ServiceEvent.kExtension));
-  expect(event.extensionKind, equals('socketTest'));
+  if (event.extensionKind != 'socketTest') {
+    return false;
+  }
   expect(event.extensionData, isA<Map>());
   expect(event.extensionData['socket'], equals('test'));
+  return true;
 }
 
 var tests = <IsolateTest>[
@@ -102,9 +105,10 @@
     var sub;
     sub = await isolate.vm.listenEventStream(Isolate.kExtensionStream,
         (ServiceEvent event) {
-      checkFinishEvent(event);
-      sub.cancel();
-      completer.complete();
+      if (checkFinishEvent(event)) {
+        sub.cancel();
+        completer.complete();
+      }
     });
 
     dynamic result = await isolate.invokeRpc("invoke",
@@ -150,9 +154,10 @@
       completer = Completer();
       sub = await isolate.vm.listenEventStream(Isolate.kExtensionStream,
           (ServiceEvent event) {
-        checkFinishEvent(event);
-        sub.cancel();
-        completer.complete();
+        if (checkFinishEvent(event)) {
+          sub.cancel();
+          completer.complete();
+        }
       });
       dynamic result = await isolate.invokeRpc("invoke",
           {"targetId": lib.id, "selector": "socketTest", "argumentIds": []});
@@ -197,9 +202,10 @@
     var sub;
     sub = await isolate.vm.listenEventStream(Isolate.kExtensionStream,
         (ServiceEvent event) {
-      checkFinishEvent(event);
-      sub.cancel();
-      completer.complete();
+      if (checkFinishEvent(event)) {
+        sub.cancel();
+        completer.complete();
+      }
     });
 
     dynamic result = await isolate.invokeRpc("invoke",
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.cc b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
index 05e62eb..3a626ba 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.cc
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
@@ -248,7 +248,8 @@
   if (IsPrivate(name)) {
     kind = CanonicalNameParent(kind);
   }
-  return StringEquals(CanonicalNameString(kind), "@fields");
+  return StringEquals(CanonicalNameString(kind), "@fields") ||
+         StringEquals(CanonicalNameString(kind), "@=fields");
 }
 
 bool TranslationHelper::IsConstructor(NameIndex name) {
@@ -992,9 +993,14 @@
       if (++next_read_ == field) return;
     }
       FALL_THROUGH;
-    case kCanonicalName:
-      canonical_name_ =
-          helper_->ReadCanonicalNameReference();  // read canonical_name.
+    case kCanonicalNameGetter:
+      canonical_name_getter_ =
+          helper_->ReadCanonicalNameReference();  // read canonical_name_getter.
+      if (++next_read_ == field) return;
+      FALL_THROUGH;
+    case kCanonicalNameSetter:
+      canonical_name_setter_ =
+          helper_->ReadCanonicalNameReference();  // read canonical_name_setter.
       if (++next_read_ == field) return;
       FALL_THROUGH;
     case kSourceUriIndex:
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.h b/runtime/vm/compiler/frontend/kernel_translation_helper.h
index ed347e5..d725cf7 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.h
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.h
@@ -438,7 +438,8 @@
  public:
   enum Field {
     kStart,  // tag.
-    kCanonicalName,
+    kCanonicalNameGetter,
+    kCanonicalNameSetter,
     kSourceUriIndex,
     kPosition,
     kEndPosition,
@@ -484,7 +485,8 @@
   bool IsLate() const { return (flags_ & kIsLate) != 0; }
   bool IsExtensionMember() const { return (flags_ & kExtensionMember) != 0; }
 
-  NameIndex canonical_name_;
+  NameIndex canonical_name_getter_;
+  NameIndex canonical_name_setter_;
   TokenPosition position_;
   TokenPosition end_position_;
   uint32_t flags_ = 0;
diff --git a/runtime/vm/kernel_binary.h b/runtime/vm/kernel_binary.h
index 1625ce1..7d5e9c5 100644
--- a/runtime/vm/kernel_binary.h
+++ b/runtime/vm/kernel_binary.h
@@ -20,8 +20,8 @@
 static const uint32_t kMagicProgramFile = 0x90ABCDEFu;
 
 // Both version numbers are inclusive.
-static const uint32_t kMinSupportedKernelFormatVersion = 49;
-static const uint32_t kMaxSupportedKernelFormatVersion = 49;
+static const uint32_t kMinSupportedKernelFormatVersion = 50;
+static const uint32_t kMaxSupportedKernelFormatVersion = 50;
 
 // Keep in sync with package:kernel/lib/binary/tag.dart
 #define KERNEL_TAG_LIST(V)                                                     \
diff --git a/runtime/vm/kernel_loader.cc b/runtime/vm/kernel_loader.cc
index 4f977cc..bd42689 100644
--- a/runtime/vm/kernel_loader.cc
+++ b/runtime/vm/kernel_loader.cc
@@ -2196,7 +2196,8 @@
   }
   ASSERT(field.NeedsGetter());
 
-  const String& getter_name = H.DartGetterName(field_helper->canonical_name_);
+  const String& getter_name =
+      H.DartGetterName(field_helper->canonical_name_getter_);
   const Object& script_class =
       ClassForScriptAt(klass, field_helper->source_uri_index_);
   Function& getter = Function::ZoneHandle(
@@ -2229,7 +2230,8 @@
   if (field.NeedsSetter()) {
     // Only static fields can be const.
     ASSERT(!field_helper->IsConst());
-    const String& setter_name = H.DartSetterName(field_helper->canonical_name_);
+    const String& setter_name =
+        H.DartSetterName(field_helper->canonical_name_setter_);
     Function& setter = Function::ZoneHandle(
         Z, Function::New(setter_name, FunctionLayout::kImplicitSetter,
                          field_helper->IsStatic(),
diff --git a/runtime/vm/service.cc b/runtime/vm/service.cc
index ab78015..b207114 100644
--- a/runtime/vm/service.cc
+++ b/runtime/vm/service.cc
@@ -12,6 +12,7 @@
 #include "platform/globals.h"
 
 #include "platform/unicode.h"
+#include "platform/utils.h"
 #include "vm/base64.h"
 #include "vm/canonical_tables.h"
 #include "vm/compiler/jit/compiler.h"
@@ -1526,6 +1527,7 @@
 
 static const MethodParameter* get_stack_params[] = {
     RUNNABLE_ISOLATE_PARAMETER,
+    new UIntParameter("limit", false),
     NULL,
 };
 
@@ -1533,7 +1535,15 @@
   if (CheckDebuggerDisabled(thread, js)) {
     return true;
   }
-
+  intptr_t limit = 0;
+  bool has_limit = js->HasParam("limit");
+  if (has_limit) {
+    limit = UIntParameter::Parse(js->LookupParam("limit"));
+    if (limit < 0) {
+      PrintInvalidParamError(js, "limit");
+      return true;
+    }
+  }
   Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
   DebuggerStackTrace* async_causal_stack =
@@ -1546,7 +1556,9 @@
   {
     JSONArray jsarr(&jsobj, "frames");
 
-    intptr_t num_frames = stack->Length();
+    intptr_t num_frames =
+        has_limit ? Utils::Minimum(stack->Length(), limit) : stack->Length();
+
     for (intptr_t i = 0; i < num_frames; i++) {
       ActivationFrame* frame = stack->FrameAt(i);
       JSONObject jsobj(&jsarr);
@@ -1557,7 +1569,9 @@
 
   if (async_causal_stack != NULL) {
     JSONArray jsarr(&jsobj, "asyncCausalFrames");
-    intptr_t num_frames = async_causal_stack->Length();
+    intptr_t num_frames =
+        has_limit ? Utils::Minimum(async_causal_stack->Length(), limit)
+                  : async_causal_stack->Length();
     for (intptr_t i = 0; i < num_frames; i++) {
       ActivationFrame* frame = async_causal_stack->FrameAt(i);
       JSONObject jsobj(&jsarr);
@@ -1568,7 +1582,9 @@
 
   if (awaiter_stack != NULL) {
     JSONArray jsarr(&jsobj, "awaiterFrames");
-    intptr_t num_frames = awaiter_stack->Length();
+    intptr_t num_frames = has_limit
+                              ? Utils::Minimum(awaiter_stack->Length(), limit)
+                              : awaiter_stack->Length();
     for (intptr_t i = 0; i < num_frames; i++) {
       ActivationFrame* frame = awaiter_stack->FrameAt(i);
       JSONObject jsobj(&jsarr);
@@ -1577,6 +1593,14 @@
     }
   }
 
+  const bool truncated =
+      (has_limit &&
+       (limit < stack->Length() ||
+        (async_causal_stack != nullptr &&
+         limit < async_causal_stack->Length()) ||
+        (awaiter_stack != nullptr && limit < awaiter_stack->Length())));
+  jsobj.AddProperty("truncated", truncated);
+
   {
     MessageHandler::AcquiredQueues aq(isolate->message_handler());
     jsobj.AddProperty("messages", aq.queue());
diff --git a/runtime/vm/service.h b/runtime/vm/service.h
index 9d09af1..f66a951 100644
--- a/runtime/vm/service.h
+++ b/runtime/vm/service.h
@@ -15,7 +15,7 @@
 namespace dart {
 
 #define SERVICE_PROTOCOL_MAJOR_VERSION 3
-#define SERVICE_PROTOCOL_MINOR_VERSION 41
+#define SERVICE_PROTOCOL_MINOR_VERSION 42
 
 class Array;
 class EmbedderServiceHandler;
diff --git a/runtime/vm/service/service.md b/runtime/vm/service/service.md
index 6fe2fb8..281b4ba4 100644
--- a/runtime/vm/service/service.md
+++ b/runtime/vm/service/service.md
@@ -1,8 +1,8 @@
-# Dart VM Service Protocol 3.41
+# Dart VM Service Protocol 3.42
 
 > Please post feedback to the [observatory-discuss group][discuss-list]
 
-This document describes of _version 3.41_ of the Dart VM Service Protocol. This
+This document describes of _version 3.42_ of the Dart VM Service Protocol. This
 protocol is used to communicate with a running Dart Virtual Machine.
 
 To use the Service Protocol, start the VM with the *--observe* flag.
@@ -995,12 +995,17 @@
 ### getStack
 
 ```
-Stack|Sentinel getStack(string isolateId)
+Stack|Sentinel getStack(string isolateId, int limit [optional])
 ```
 
 The _getStack_ RPC is used to retrieve the current execution stack and
 message queue for an isolate. The isolate does not need to be paused.
 
+If _limit_ is provided, up to _limit_ frames from the top of the stack will be
+returned. If the stack depth is smaller than _limit_ the entire stack is
+returned. Note: this limit also applies to the `asyncCausalFrames` and
+`awaiterFrames` stack representations in the _Stack_ response.
+
 If _isolateId_ refers to an isolate which has exited, then the
 _Collected_ [Sentinel](#sentinel) is returned.
 
@@ -3646,13 +3651,33 @@
 
 ```
 class Stack extends Response {
+  // A list of frames that make up the synchronous stack, rooted at the message
+  // loop (i.e., the frames since the last asynchronous gap or the isolate's
+  // entrypoint).
   Frame[] frames;
+
+  // A list of frames representing the asynchronous path. Comparable to
+  // `awaiterFrames`, if provided, although some frames may be different.
   Frame[] asyncCausalFrames [optional];
+
+  // A list of frames representing the asynchronous path. Comparable to
+  // `asyncCausalFrames`, if provided, although some frames may be different.
   Frame[] awaiterFrames [optional];
+
+  // A list of messages in the isolate's message queue.
   Message[] messages;
+
+  // Specifies whether or not this stack is complete or has been artificially
+  // truncated.
+  bool truncated;
 }
 ```
 
+The _Stack_ class represents the various components of a Dart stack trace for a
+given isolate.
+
+See [getStack](#getStack).
+
 ### ExceptionPauseMode
 
 ```
@@ -3921,5 +3946,6 @@
 3.39 | Removed the following deprecated RPCs and objects: `getClientName`, `getWebSocketTarget`, `setClientName`, `requireResumeApproval`, `ClientName`, and `WebSocketTarget`.
 3.40 | Added `IsolateFlag` object and `isolateFlags` property to `Isolate`.
 3.41 | Added `PortList` object, `ReceivePort` `InstanceKind`, and `getPorts` RPC.
+3.42 | Added `limit` optional parameter to `getStack` RPC.
 
 [discuss-list]: https://groups.google.com/a/dartlang.org/forum/#!forum/observatory-discuss
diff --git a/tools/VERSION b/tools/VERSION
index 86ee304..ead15d6 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 12
 PATCH 0
-PRERELEASE 16
+PRERELEASE 17
 PRERELEASE_PATCH 0
\ No newline at end of file
