diff --git a/pkg/analysis_server/test/test_all.dart b/pkg/analysis_server/test/test_all.dart
index 4c5a33f..3e5769cc 100644
--- a/pkg/analysis_server/test/test_all.dart
+++ b/pkg/analysis_server/test/test_all.dart
@@ -26,6 +26,7 @@
 import 'socket_server_test.dart' as socket_server;
 import 'src/test_all.dart' as src;
 import 'tool/test_all.dart' as tool;
+import 'verify_no_solo_test.dart' as verify_no_solo;
 import 'verify_sorted_test.dart' as verify_sorted;
 import 'verify_tests_test.dart' as verify_tests;
 
@@ -52,6 +53,7 @@
     socket_server.main();
     src.main();
     tool.main();
+    verify_no_solo.main();
     verify_sorted.main();
     verify_tests.main();
     defineReflectiveSuite(() {
diff --git a/pkg/analysis_server/test/verify_no_solo_test.dart b/pkg/analysis_server/test/verify_no_solo_test.dart
new file mode 100644
index 0000000..150c731
--- /dev/null
+++ b/pkg/analysis_server/test/verify_no_solo_test.dart
@@ -0,0 +1,109 @@
+// Copyright (c) 2021, 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/dart/analysis/analysis_context_collection.dart';
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer/dart/analysis/session.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:analyzer_utilities/package_root.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('analysis_server', () {
+    buildTests(packagePath: 'analysis_server');
+  });
+
+  group('analyzer', () {
+    buildTests(packagePath: 'analyzer');
+  });
+
+  group('analyzer_cli', () {
+    buildTests(packagePath: 'analyzer_cli');
+  });
+
+  group('analyzer_plugin', () {
+    buildTests(packagePath: 'analyzer_plugin');
+  });
+}
+
+void buildTests({required String packagePath}) {
+  var provider = PhysicalResourceProvider.INSTANCE;
+  var pkgRootPath = provider.pathContext.normalize(packageRoot);
+
+  var testsPath = _toPlatformPath(pkgRootPath, '$packagePath/test');
+
+  var collection = AnalysisContextCollection(
+    includedPaths: <String>[testsPath],
+    resourceProvider: provider,
+  );
+  var contexts = collection.contexts;
+  if (contexts.length != 1) {
+    fail('The directory $testsPath contains multiple analysis contexts.');
+  }
+
+  test('no @soloTest', () {
+    var failures = <String>[];
+    buildTestsIn(contexts[0].currentSession, testsPath,
+        provider.getFolder(testsPath), failures);
+
+    if (failures.isNotEmpty) {
+      fail('@soloTest annotation found in:\n${failures.join('\n')}');
+    }
+  });
+}
+
+void buildTestsIn(AnalysisSession session, String testDirPath, Folder directory,
+    List<String> failures) {
+  var pathContext = session.resourceProvider.pathContext;
+  var children = directory.getChildren();
+  children.sort((first, second) => first.shortName.compareTo(second.shortName));
+  for (var child in children) {
+    if (child is Folder) {
+      buildTestsIn(session, testDirPath, child, failures);
+    } else if (child is File && child.shortName.endsWith('_test.dart')) {
+      var path = child.path;
+      var relativePath = pathContext.relative(path, from: testDirPath);
+
+      var result = session.getParsedUnit(path);
+      if (result is! ParsedUnitResult) {
+        fail('Could not parse $path');
+      }
+      var unit = result.unit;
+      var errors = result.errors;
+      if (errors.isNotEmpty) {
+        fail('Errors found when parsing $path');
+      }
+      var tracker = SoloTestTracker();
+      unit.accept(tracker);
+      if (tracker.found) {
+        failures.add(relativePath);
+      }
+    }
+  }
+}
+
+String _toPlatformPath(String pathPath, String relativePosixPath) {
+  var pathContext = PhysicalResourceProvider.INSTANCE.pathContext;
+  return pathContext.joinAll([
+    pathPath,
+    ...relativePosixPath.split('/'),
+  ]);
+}
+
+/// A [RecursiveAstVisitor] that tracks whether any node is annotated with
+/// an annotation named 'soloTest'.
+class SoloTestTracker extends RecursiveAstVisitor<void> {
+  bool found = false;
+
+  @override
+  void visitAnnotation(Annotation node) {
+    if (node.name.name == 'soloTest') {
+      found = true;
+    }
+    super.visitAnnotation(node);
+  }
+}
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index 42249d9..f7d46a6 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -192,7 +192,7 @@
   ///
   /// Note that this is not guaranteed to be complete. It is used to make hard
   /// edges on a best-effort basis.
-  var _postDominatedLocals = _ScopedLocalSet();
+  var _postDominatedLocals = ScopedSet<Element>();
 
   /// Map whose keys are expressions of the form `a?.b` on the LHS of
   /// assignments, and whose values are the nullability nodes corresponding to
@@ -242,6 +242,10 @@
         _whereOrNullTransformer =
             WhereOrNullTransformer(typeProvider, _typeSystem);
 
+  /// The synthetic element we use as a stand-in for `this` when analyzing
+  /// extension methods.
+  Element get _extensionThis => DynamicElementImpl.instance;
+
   /// Gets the decorated type of [element] from [_variables], performing any
   /// necessary substitutions.
   ///
@@ -319,7 +323,7 @@
             source: targetType,
             destination: onType,
             hard: targetExpression == null ||
-                _postDominatedLocals.isReferenceInScope(targetExpression));
+                _isReferenceInScope(targetExpression));
         // (3) substitute those decorated types into the declared type of the
         // extension method or extension property, so that the caller will match
         // up parameter types and the return type appropriately.
@@ -507,8 +511,7 @@
         bool isPure = otherOperand is SimpleIdentifier;
         var conditionInfo = _ConditionInfo(node,
             isPure: isPure,
-            postDominatingIntent:
-                _postDominatedLocals.isReferenceInScope(otherOperand),
+            postDominatingIntent: _isReferenceInScope(otherOperand),
             trueGuard: otherNode,
             falseDemonstratesNonNullIntent: otherNode);
         _conditionInfo = notEqual ? conditionInfo.not(node) : conditionInfo;
@@ -928,7 +931,7 @@
           _elementsWrittenToInLocalFunction;
       try {
         _elementsWrittenToInLocalFunction = {};
-        _postDominatedLocals = _ScopedLocalSet();
+        _postDominatedLocals = ScopedSet<Element>();
         _flowAnalysis!.functionExpression_begin(node);
         _dispatch(node.functionExpression);
         _flowAnalysis!.functionExpression_end();
@@ -993,7 +996,7 @@
       if (node.parent is! FunctionDeclaration) {
         _elementsWrittenToInLocalFunction = {};
       }
-      _postDominatedLocals = _ScopedLocalSet();
+      _postDominatedLocals = ScopedSet<Element>();
       _postDominatedLocals.doScoped(
           elements: node.declaredElement!.parameters,
           action: () => _dispatch(node.body));
@@ -1238,8 +1241,7 @@
         decoratedType.node, IsCheckMainTypeOrigin(source, type));
     _conditionInfo = _ConditionInfo(node,
         isPure: expression is SimpleIdentifier,
-        postDominatingIntent:
-            _postDominatedLocals.isReferenceInScope(expression),
+        postDominatingIntent: _isReferenceInScope(expression),
         trueDemonstratesNonNullIntent: expressionNode);
     if (node.notOperator != null) {
       _conditionInfo = _conditionInfo!.not(node);
@@ -2004,7 +2006,7 @@
     //
     // We cannot make a hard edge from y to never in this case.
     if (node.variables.length == 1) {
-      _postDominatedLocals.add(node.variables.single.declaredElement);
+      _postDominatedLocals.add(node.variables.single.declaredElement!);
     }
 
     return null;
@@ -2061,8 +2063,7 @@
     // there's nothing to do.
     if (_currentExtendedType == null) return;
     var origin = ImplicitThisOrigin(source, node);
-    var hard =
-        _postDominatedLocals.isInScope(_postDominatedLocals.extensionThis);
+    var hard = _postDominatedLocals.isInScope(_extensionThis);
     _graph.makeNonNullable(thisType!.node, origin, hard: hard, guards: _guards);
   }
 
@@ -2329,8 +2330,7 @@
         callee!.name == 'checkNotNull' &&
         node.argumentList.arguments.isNotEmpty) {
       var argument = node.argumentList.arguments.first;
-      if (argument is SimpleIdentifier &&
-          _postDominatedLocals.isReferenceInScope(argument)) {
+      if (argument is SimpleIdentifier && _isReferenceInScope(argument)) {
         var argumentType =
             _variables!.decoratedElementType(argument.staticElement!);
         _graph.makeNonNullable(argumentType.node,
@@ -2475,8 +2475,7 @@
       }
     }
     if (assignmentExpression != null) {
-      var element = _postDominatedLocals
-          .referencedElement(assignmentExpression.leftHandSide);
+      var element = _referencedElement(assignmentExpression.leftHandSide);
       if (element != null) {
         _postDominatedLocals.removeFromAllScopes(element);
         _elementsWrittenToInLocalFunction?.add(element);
@@ -2531,7 +2530,7 @@
     // Push a scope of post-dominated declarations on the stack.
     _postDominatedLocals.pushScope(elements: declaredElement.parameters);
     if (declaredElement.enclosingElement is ExtensionElement) {
-      _postDominatedLocals.add(_postDominatedLocals.extensionThis);
+      _postDominatedLocals.add(_extensionThis);
     }
     try {
       _dispatchList(initializers);
@@ -3090,8 +3089,7 @@
 
     if (isQuiverCheckNull && node.argumentList.arguments.isNotEmpty) {
       var argument = node.argumentList.arguments.first;
-      if (argument is SimpleIdentifier &&
-          _postDominatedLocals.isReferenceInScope(argument)) {
+      if (argument is SimpleIdentifier && _isReferenceInScope(argument)) {
         var argumentType =
             _variables!.decoratedElementType(argument.staticElement!);
         _graph.makeNonNullable(
@@ -3147,6 +3145,11 @@
   bool _isPrefix(Expression? e) =>
       e is SimpleIdentifier && e.staticElement is PrefixElement;
 
+  bool _isReferenceInScope(Expression expression) {
+    var element = _referencedElement(expression);
+    return element != null && _postDominatedLocals.isInScope(element);
+  }
+
   bool _isUntypedParameter(NormalFormalParameter parameter) {
     if (parameter is SimpleFormalParameter) {
       return parameter.type == null;
@@ -3261,6 +3264,19 @@
     return node;
   }
 
+  /// Returns the element referenced directly by [expression], if any; otherwise
+  /// returns `null`.
+  Element? _referencedElement(Expression expression) {
+    expression = expression.unParenthesized;
+    if (expression is SimpleIdentifier) {
+      return expression.staticElement;
+    } else if (expression is ThisExpression || expression is SuperExpression) {
+      return _extensionThis;
+    } else {
+      return null;
+    }
+  }
+
   /// Determines whether uses of [expression] should cause hard edges to be
   /// created in the nullability graph.
   ///
@@ -3288,8 +3304,7 @@
     // expression is unconditionally executed, and (b) the expression is a
     // reference to a local variable or parameter and it post-dominates the
     // declaration of that local variable or parameter.
-    return !isConditionallyExecuted &&
-        _postDominatedLocals.isReferenceInScope(expression);
+    return !isConditionallyExecuted && _isReferenceInScope(expression);
   }
 
   DecoratedType? _thisOrSuper(Expression node) {
@@ -3772,30 +3787,3 @@
       trueDemonstratesNonNullIntent: falseDemonstratesNonNullIntent,
       falseDemonstratesNonNullIntent: trueDemonstratesNonNullIntent);
 }
-
-/// A [ScopedSet] specific to the [Element]s of locals/parameters.
-///
-/// Contains helpers for dealing with expressions as if they were elements.
-class _ScopedLocalSet extends ScopedSet<Element?> {
-  /// The synthetic element we use as a stand-in for `this` when analyzing
-  /// extension methods.
-  Element get extensionThis => DynamicElementImpl.instance;
-
-  bool isReferenceInScope(Expression expression) {
-    var element = referencedElement(expression);
-    return element != null && isInScope(element);
-  }
-
-  /// Returns the element referenced directly by [expression], if any; otherwise
-  /// returns `null`.
-  Element? referencedElement(Expression expression) {
-    expression = expression.unParenthesized;
-    if (expression is SimpleIdentifier) {
-      return expression.staticElement;
-    } else if (expression is ThisExpression || expression is SuperExpression) {
-      return extensionThis;
-    } else {
-      return null;
-    }
-  }
-}
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 3f6d0f7..26c206d 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -3023,8 +3023,11 @@
 }
 
 ArrayPtr Class::OffsetToFieldMap(bool original_classes) const {
-  if (untag()->offset_in_words_to_field() == Array::null()) {
-    ASSERT(is_finalized());
+  ASSERT(is_finalized());
+  if (untag()->offset_in_words_to_field<std::memory_order_acquire>() ==
+      Array::null()) {
+    // Even if multiple threads are calling this concurrently, all of them would
+    // compute the same array, so we intentionally don't acquire any locks here.
     const intptr_t length = untag()->host_instance_size_in_words_;
     const Array& array = Array::Handle(Array::New(length, Heap::kOld));
     Class& cls = Class::Handle(this->ptr());
@@ -3040,9 +3043,10 @@
       }
       cls = cls.SuperClass(original_classes);
     }
-    untag()->set_offset_in_words_to_field(array.ptr());
+    untag()->set_offset_in_words_to_field<std::memory_order_release>(
+        array.ptr());
   }
-  return untag()->offset_in_words_to_field();
+  return untag()->offset_in_words_to_field<std::memory_order_acquire>();
 }
 
 bool Class::HasInstanceFields() const {
diff --git a/runtime/vm/object_store.cc b/runtime/vm/object_store.cc
index 2ffb6ce..8b84d23 100644
--- a/runtime/vm/object_store.cc
+++ b/runtime/vm/object_store.cc
@@ -334,40 +334,46 @@
 }
 
 void ObjectStore::LazyInitCoreTypes() {
-  if (list_class_ == Type::null()) {
-    ASSERT(non_nullable_list_rare_type_ == Type::null());
-    ASSERT(non_nullable_map_rare_type_ == Type::null());
-    Thread* thread = Thread::Current();
-    Zone* zone = thread->zone();
-    const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
-    Class& cls = Class::Handle(zone, core_lib.LookupClass(Symbols::List()));
+  auto* const thread = Thread::Current();
+  SafepointWriteRwLocker locker(thread,
+                                thread->isolate_group()->program_lock());
+  if (list_class_.load() == Type::null()) {
+    ASSERT(non_nullable_list_rare_type_.load() == Type::null());
+    ASSERT(non_nullable_map_rare_type_.load() == Type::null());
+
+    auto* const zone = thread->zone();
+    const auto& core_lib = Library::Handle(zone, Library::CoreLibrary());
+    auto& cls = Class::Handle(zone);
+
+    cls = core_lib.LookupClass(Symbols::List());
     ASSERT(!cls.IsNull());
-    set_list_class(cls);
-    Type& type = Type::Handle(zone);
+    list_class_.store(cls.ptr());
+
+    auto& type = Type::Handle(zone);
     type ^= cls.RareType();
-    set_non_nullable_list_rare_type(type);
+    non_nullable_list_rare_type_.store(type.ptr());
+
     cls = core_lib.LookupClass(Symbols::Map());
     ASSERT(!cls.IsNull());
     type ^= cls.RareType();
-    set_non_nullable_map_rare_type(type);
+    non_nullable_map_rare_type_.store(type.ptr());
   }
 }
 
 void ObjectStore::LazyInitFutureTypes() {
-  if (non_nullable_future_rare_type_ == Type::null()) {
-    ASSERT(non_nullable_future_never_type_ == Type::null() &&
-           nullable_future_null_type_ == Type::null());
-    Thread* thread = Thread::Current();
-    Zone* zone = thread->zone();
-    Class& cls = Class::Handle(zone, future_class());
-    if (cls.IsNull()) {
-      const Library& async_lib = Library::Handle(zone, async_library());
-      ASSERT(!async_lib.IsNull());
-      cls = async_lib.LookupClass(Symbols::Future());
-      ASSERT(!cls.IsNull());
-    }
-    TypeArguments& type_args = TypeArguments::Handle(zone);
-    Type& type = Type::Handle(zone);
+  auto* const thread = Thread::Current();
+  SafepointWriteRwLocker locker(thread,
+                                thread->isolate_group()->program_lock());
+  if (non_nullable_future_rare_type_.load() == Type::null()) {
+    ASSERT(non_nullable_future_never_type_.load() == Type::null());
+    ASSERT(nullable_future_null_type_.load() == Type::null());
+
+    auto* const zone = thread->zone();
+    const auto& cls = Class::Handle(zone, future_class());
+    ASSERT(!cls.IsNull());
+
+    auto& type_args = TypeArguments::Handle(zone);
+    auto& type = Type::Handle(zone);
     type = never_type();
     ASSERT(!type.IsNull());
     type_args = TypeArguments::New(1);
@@ -375,7 +381,8 @@
     type = Type::New(cls, type_args, Nullability::kNonNullable);
     type.SetIsFinalized();
     type ^= type.Canonicalize(thread, nullptr);
-    set_non_nullable_future_never_type(type);
+    non_nullable_future_never_type_.store(type.ptr());
+
     type = null_type();
     ASSERT(!type.IsNull());
     type_args = TypeArguments::New(1);
@@ -383,9 +390,10 @@
     type = Type::New(cls, type_args, Nullability::kNullable);
     type.SetIsFinalized();
     type ^= type.Canonicalize(thread, nullptr);
-    set_nullable_future_null_type(type);
+    nullable_future_null_type_.store(type.ptr());
+
     type ^= cls.RareType();
-    set_non_nullable_future_rare_type(type);
+    non_nullable_future_rare_type_.store(type.ptr());
   }
 }
 
diff --git a/runtime/vm/object_store.h b/runtime/vm/object_store.h
index eec9974e..9e5606a 100644
--- a/runtime/vm/object_store.h
+++ b/runtime/vm/object_store.h
@@ -36,9 +36,9 @@
 //
 // R_ - needs getter only
 // RW - needs getter and setter
-// CW - needs lazy Core init getter and setter
-// FW - needs lazy Future init getter and setter
-#define OBJECT_STORE_FIELD_LIST(R_, RW, CW, FW)                                \
+// CR - needs lazy Core init getter
+// FR - needs lazy Future init getter
+#define OBJECT_STORE_FIELD_LIST(R_, RW, CR, FR)                                \
   RW(Class, object_class)                                                      \
   RW(Type, object_type)                                                        \
   RW(Type, legacy_object_type)                                                 \
@@ -81,12 +81,12 @@
   RW(Type, string_type)                                                        \
   RW(Type, legacy_string_type)                                                 \
   RW(Type, non_nullable_string_type)                                           \
-  CW(Class, list_class)                    /* maybe be null, lazily built */   \
-  CW(Type, non_nullable_list_rare_type)    /* maybe be null, lazily built */   \
-  CW(Type, non_nullable_map_rare_type)     /* maybe be null, lazily built */   \
-  FW(Type, non_nullable_future_rare_type)  /* maybe be null, lazily built */   \
-  FW(Type, non_nullable_future_never_type) /* maybe be null, lazily built */   \
-  FW(Type, nullable_future_null_type)      /* maybe be null, lazily built */   \
+  CR(Class, list_class)                    /* maybe be null, lazily built */   \
+  CR(Type, non_nullable_list_rare_type)    /* maybe be null, lazily built */   \
+  CR(Type, non_nullable_map_rare_type)     /* maybe be null, lazily built */   \
+  FR(Type, non_nullable_future_rare_type)  /* maybe be null, lazily built */   \
+  FR(Type, non_nullable_future_never_type) /* maybe be null, lazily built */   \
+  FR(Type, nullable_future_null_type)      /* maybe be null, lazily built */   \
   RW(TypeArguments, type_argument_int)                                         \
   RW(TypeArguments, type_argument_legacy_int)                                  \
   RW(TypeArguments, type_argument_non_nullable_int)                            \
@@ -395,27 +395,25 @@
   void set_##name(const Type& value) { name##_ = value.ptr(); }
 #define DECLARE_LAZY_INIT_GETTER(Type, name, init)                             \
   Type##Ptr name() {                                                           \
-    if (name##_ == Type::null()) {                                             \
+    if (name##_.load() == Type::null()) {                                      \
       init();                                                                  \
     }                                                                          \
-    return name##_;                                                            \
+    return name##_.load();                                                     \
   }                                                                            \
   static intptr_t name##_offset() { return OFFSET_OF(ObjectStore, name##_); }
-#define DECLARE_LAZY_INIT_CORE_GETTER_AND_SETTER(Type, name)                   \
-  DECLARE_LAZY_INIT_GETTER(Type, name, LazyInitCoreTypes)                      \
-  void set_##name(const Type& value) { name##_ = value.ptr(); }
-#define DECLARE_LAZY_INIT_FUTURE_GETTER_AND_SETTER(Type, name)                 \
-  DECLARE_LAZY_INIT_GETTER(Type, name, LazyInitFutureTypes)                    \
-  void set_##name(const Type& value) { name##_ = value.ptr(); }
+#define DECLARE_LAZY_INIT_CORE_GETTER(Type, name)                              \
+  DECLARE_LAZY_INIT_GETTER(Type, name, LazyInitCoreTypes)
+#define DECLARE_LAZY_INIT_FUTURE_GETTER(Type, name)                            \
+  DECLARE_LAZY_INIT_GETTER(Type, name, LazyInitFutureTypes)
   OBJECT_STORE_FIELD_LIST(DECLARE_GETTER,
                           DECLARE_GETTER_AND_SETTER,
-                          DECLARE_LAZY_INIT_CORE_GETTER_AND_SETTER,
-                          DECLARE_LAZY_INIT_FUTURE_GETTER_AND_SETTER)
+                          DECLARE_LAZY_INIT_CORE_GETTER,
+                          DECLARE_LAZY_INIT_FUTURE_GETTER)
 #undef DECLARE_GETTER
 #undef DECLARE_GETTER_AND_SETTER
 #undef DECLARE_LAZY_INIT_GETTER
-#undef DECLARE_LAZY_INIT_CORE_GETTER_AND_SETTER
-#undef DECLARE_LAZY_INIT_FUTURE_GETTER_AND_SETTER
+#undef DECLARE_LAZY_INIT_CORE_GETTER
+#undef DECLARE_LAZY_INIT_FUTURE_GETTER
 
   LibraryPtr bootstrap_library(BootstrapLibraryId index) {
     switch (index) {
@@ -471,10 +469,13 @@
 
   ObjectPtr* from() { return reinterpret_cast<ObjectPtr*>(&object_class_); }
 #define DECLARE_OBJECT_STORE_FIELD(type, name) type##Ptr name##_;
+#define DECLARE_LAZY_OBJECT_STORE_FIELD(type, name)                            \
+  AcqRelAtomic<type##Ptr> name##_;
   OBJECT_STORE_FIELD_LIST(DECLARE_OBJECT_STORE_FIELD,
                           DECLARE_OBJECT_STORE_FIELD,
-                          DECLARE_OBJECT_STORE_FIELD,
-                          DECLARE_OBJECT_STORE_FIELD)
+                          DECLARE_LAZY_OBJECT_STORE_FIELD,
+                          DECLARE_LAZY_OBJECT_STORE_FIELD)
+#undef DECLARE_LAZY_OBJECT_STORE_FIELD
 #undef DECLARE_OBJECT_STORE_FIELD
   ObjectPtr* to() {
     return reinterpret_cast<ObjectPtr*>(&ffi_as_function_internal_);
diff --git a/runtime/vm/version_in.cc b/runtime/vm/version_in.cc
index 206cd1f..4fe06a5 100644
--- a/runtime/vm/version_in.cc
+++ b/runtime/vm/version_in.cc
@@ -10,7 +10,7 @@
 
 namespace dart {
 
-// We use require-release semantics to ensure initializing stores to the string
+// We use acquire-release semantics to ensure initializing stores to the string
 // are visible when the string becomes visible.
 static AcqRelAtomic<const char*> formatted_version = nullptr;
 
diff --git a/runtime/vm/virtual_memory_win.cc b/runtime/vm/virtual_memory_win.cc
index 5348b3c..c4f4269 100644
--- a/runtime/vm/virtual_memory_win.cc
+++ b/runtime/vm/virtual_memory_win.cc
@@ -74,8 +74,9 @@
 
 void VirtualMemory::Cleanup() {
 #if defined(DART_COMPRESSED_POINTERS)
-  VirtualFree(VirtualMemoryCompressedHeap::Cleanup(), kCompressedHeapSize,
-              MEM_RELEASE);
+  void* heap_base = VirtualMemoryCompressedHeap::GetRegion();
+  VirtualFree(heap_base, kCompressedHeapSize, MEM_RELEASE);
+  VirtualMemoryCompressedHeap::Cleanup();
 #endif  // defined(DART_COMPRESSED_POINTERS)
 }
 
diff --git a/tests/lib/lib.status b/tests/lib/lib.status
index 412a98c..f94394e 100644
--- a/tests/lib/lib.status
+++ b/tests/lib/lib.status
@@ -39,6 +39,7 @@
 js/extends_test/extends_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/extends_test/extends_with_es6_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/instanceof_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
+js/is_check_and_as_cast_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/js_util/async_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/js_util/jsify_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/js_util/promise_reject_null_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
diff --git a/tests/lib_2/lib_2.status b/tests/lib_2/lib_2.status
index eb7d1ed..5b9a2a9 100644
--- a/tests/lib_2/lib_2.status
+++ b/tests/lib_2/lib_2.status
@@ -39,6 +39,7 @@
 js/extends_test/extends_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/extends_test/extends_with_es6_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/instanceof_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
+js/is_check_and_as_cast_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/js_util/async_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/js_util/jsify_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
 js/js_util/promise_reject_null_test: SkipByDesign # Issue 42085. CSP policy disallows injected JS code
diff --git a/tools/VERSION b/tools/VERSION
index f61b8cf..7d2ebaa 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 317
+PRERELEASE 318
 PRERELEASE_PATCH 0
\ No newline at end of file