diff --git a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
index ed754b3..73824a7 100644
--- a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
@@ -2162,6 +2162,18 @@
 }
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeDeprecateDartExt = messageDeprecateDartExt;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageDeprecateDartExt = const MessageCode(
+    "DeprecateDartExt",
+    severity: Severity.info,
+    message:
+        r"""Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.""",
+    tip:
+        r"""Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<
         Message Function(
             int count, int count2, num _num1, num _num2, num _num3)>
diff --git a/pkg/analyzer/lib/src/dart/micro/resolve_file.dart b/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
index 6ce2ccd..8696184 100644
--- a/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
+++ b/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
@@ -447,8 +447,16 @@
         completionPath: path,
         performance: performance,
       );
-      var result =
-          libraryUnit.units!.firstWhere((element) => element.path == path);
+      var result = libraryUnit.units!
+          .firstWhereOrNull((element) => element.path == path);
+      // TODO(scheglov) Fix and remove.
+      if (result == null) {
+        throw StateError('''
+libraryFile.path: ${libraryFile.path}
+path: $path
+units: ${libraryUnit.units!.map((e) => '(${e.uri} = ${e.path})').toList()}
+''');
+      }
       return result;
     });
   }
diff --git a/pkg/analyzer/lib/src/generated/element_resolver.dart b/pkg/analyzer/lib/src/generated/element_resolver.dart
index 1da17d4..87c0e77 100644
--- a/pkg/analyzer/lib/src/generated/element_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/element_resolver.dart
@@ -83,10 +83,6 @@
   /// The element for the library containing the compilation unit being visited.
   final LibraryElement _definingLibrary;
 
-  /// Whether constant evaluation errors should be reported during resolution.
-  @Deprecated('This field is no longer used')
-  final bool reportConstEvaluationErrors;
-
   /// Helper for resolving properties on types.
   final TypePropertyResolver _typePropertyResolver;
 
@@ -95,8 +91,7 @@
   /// Initialize a newly created visitor to work for the given [_resolver] to
   /// resolve the nodes in a compilation unit.
   ElementResolver(this._resolver,
-      {this.reportConstEvaluationErrors = true,
-      MigratableAstInfoProvider migratableAstInfoProvider =
+      {MigratableAstInfoProvider migratableAstInfoProvider =
           const MigratableAstInfoProvider()})
       : _definingLibrary = _resolver.definingLibrary,
         _typePropertyResolver = _resolver.typePropertyResolver {
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 0aefca2..b8101a1 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -275,7 +275,6 @@
       AnalysisErrorListener errorListener,
       {FeatureSet? featureSet,
       Scope? nameScope,
-      bool reportConstEvaluationErrors = true,
       FlowAnalysisHelper? flowAnalysisHelper})
       : this._(
             inheritanceManager,
@@ -287,7 +286,6 @@
             featureSet ??
                 definingLibrary.context.analysisOptions.contextFeatures,
             nameScope,
-            reportConstEvaluationErrors,
             flowAnalysisHelper,
             const MigratableAstInfoProvider(),
             null);
@@ -301,7 +299,6 @@
       AnalysisErrorListener errorListener,
       FeatureSet featureSet,
       Scope? nameScope,
-      bool reportConstEvaluationErrors,
       this.flowAnalysis,
       this._migratableAstInfoProvider,
       MigrationResolutionHooks? migrationResolutionHooks)
@@ -371,7 +368,6 @@
       flowAnalysis,
     );
     elementResolver = ElementResolver(this,
-        reportConstEvaluationErrors: reportConstEvaluationErrors,
         migratableAstInfoProvider: _migratableAstInfoProvider);
     inferenceContext = InferenceContext._(this);
     typeAnalyzer = StaticTypeAnalyzer(this, migrationResolutionHooks);
@@ -2413,7 +2409,6 @@
             errorListener,
             featureSet,
             null,
-            true,
             FlowAnalysisHelperForMigration(
                 typeSystem, migrationResolutionHooks, true),
             migrationResolutionHooks,
diff --git a/pkg/analyzer/lib/src/summary2/ast_resolver.dart b/pkg/analyzer/lib/src/summary2/ast_resolver.dart
index 87dfa28..83100d7 100644
--- a/pkg/analyzer/lib/src/summary2/ast_resolver.dart
+++ b/pkg/analyzer/lib/src/summary2/ast_resolver.dart
@@ -48,7 +48,6 @@
     _errorListener,
     featureSet: _featureSet,
     nameScope: _nameScope,
-    reportConstEvaluationErrors: false,
     flowAnalysisHelper: _flowAnalysis,
   );
 
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 b09820a..91da0d0 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
@@ -722,6 +722,7 @@
     String nativePath;
     const String nativeExtensionScheme = "dart-ext:";
     if (uri.startsWith(nativeExtensionScheme)) {
+      addProblem(messageDeprecateDartExt, charOffset, noLength, fileUri);
       String strippedUri = uri.substring(nativeExtensionScheme.length);
       if (strippedUri.startsWith("package")) {
         resolvedUri = resolve(this.importUri, strippedUri,
diff --git a/pkg/front_end/messages.status b/pkg/front_end/messages.status
index c890c30..709f244 100644
--- a/pkg/front_end/messages.status
+++ b/pkg/front_end/messages.status
@@ -174,6 +174,8 @@
 DeferredExtensionImport/part_wrapped_script: Fail
 DeferredPrefixDuplicated/example: Fail
 DeferredTypeAnnotation/example: Fail
+DeprecateDartExt/analyzerCode: Fail
+DeprecateDartExt/part_wrapped_script: Fail # Example uses import declaration.
 DillOutlineSummary/analyzerCode: Fail
 DillOutlineSummary/example: Fail
 DirectiveAfterDeclaration/part_wrapped_script1: Fail
diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index b00bab2..c411adb 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -5180,3 +5180,10 @@
   script: |
     // @dart=2.9
     main() {}
+
+DeprecateDartExt:
+  template: "Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK."
+  tip: "Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)"
+  severity: INFO
+  script: |
+    import 'dart-ext:foo.dart';
diff --git a/pkg/front_end/test/spell_checking_list_messages.txt b/pkg/front_end/test/spell_checking_list_messages.txt
index 4d51529..808f9f1 100644
--- a/pkg/front_end/test/spell_checking_list_messages.txt
+++ b/pkg/front_end/test/spell_checking_list_messages.txt
@@ -34,6 +34,7 @@
 ffi
 flutter_runner
 futureor
+guides
 h
 https
 interop
@@ -42,6 +43,7 @@
 libraries.json
 list.filled
 loadlibrary
+migrate
 name.#name
 name.stack
 nameokempty
diff --git a/pkg/front_end/testcases/general/external_import.dart.weak.expect b/pkg/front_end/testcases/general/external_import.dart.weak.expect
index 0a7d177..36d348d1 100644
--- a/pkg/front_end/testcases/general/external_import.dart.weak.expect
+++ b/pkg/front_end/testcases/general/external_import.dart.weak.expect
@@ -2,6 +2,24 @@
 @#C4
 @#C6
 library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/external_import.dart:7:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:here';
+// ^
+//
+// pkg/front_end/testcases/general/external_import.dart:8:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:foo/../there';
+// ^
+//
+// pkg/front_end/testcases/general/external_import.dart:9:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:/usr/local/somewhere';
+// ^
+//
 import self as self;
 import "dart:_internal" as _in;
 
diff --git a/pkg/front_end/testcases/general/external_import.dart.weak.outline.expect b/pkg/front_end/testcases/general/external_import.dart.weak.outline.expect
index c82b9e6..046113e 100644
--- a/pkg/front_end/testcases/general/external_import.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/external_import.dart.weak.outline.expect
@@ -2,6 +2,24 @@
 @dart._internal::ExternalName::•("dart-ext:foo/../there")
 @dart._internal::ExternalName::•("dart-ext:/usr/local/somewhere")
 library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/external_import.dart:7:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:here';
+// ^
+//
+// pkg/front_end/testcases/general/external_import.dart:8:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:foo/../there';
+// ^
+//
+// pkg/front_end/testcases/general/external_import.dart:9:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:/usr/local/somewhere';
+// ^
+//
 import self as self;
 import "dart:_internal" as _in;
 
diff --git a/pkg/front_end/testcases/general/external_import.dart.weak.transformed.expect b/pkg/front_end/testcases/general/external_import.dart.weak.transformed.expect
index 0a7d177..36d348d1 100644
--- a/pkg/front_end/testcases/general/external_import.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/external_import.dart.weak.transformed.expect
@@ -2,6 +2,24 @@
 @#C4
 @#C6
 library;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/external_import.dart:7:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:here';
+// ^
+//
+// pkg/front_end/testcases/general/external_import.dart:8:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:foo/../there';
+// ^
+//
+// pkg/front_end/testcases/general/external_import.dart:9:1: Info: Dart native extensions are deprecated and will be removed in the 2.15 release of Dart SDK.
+// Migrate to using FFI instead (https://dart.dev/guides/libraries/c-interop)
+// import 'dart-ext:/usr/local/somewhere';
+// ^
+//
 import self as self;
 import "dart:_internal" as _in;
 
diff --git a/runtime/tests/concurrency/stress_test_list.json b/runtime/tests/concurrency/stress_test_list.json
index 4044c33..502555d 100644
--- a/runtime/tests/concurrency/stress_test_list.json
+++ b/runtime/tests/concurrency/stress_test_list.json
@@ -2696,7 +2696,6 @@
     "../../../tests/language/unsorted/cyclic_default_values_test.dart",
     "../../../tests/language/unsorted/default_implementation_test.dart",
     "../../../tests/language/unsorted/default_init_test.dart",
-    "../../../tests/language/unsorted/disassemble_test.dart",
     "../../../tests/language/unsorted/efficient_length_warning_test.dart",
     "../../../tests/language/unsorted/emit_const_fields_test.dart",
     "../../../tests/language/unsorted/expect_test.dart",
@@ -6059,7 +6058,6 @@
     "../../../tests/language_2/unsorted/cyclic_default_values_test.dart",
     "../../../tests/language_2/unsorted/default_implementation_test.dart",
     "../../../tests/language_2/unsorted/default_init_test.dart",
-    "../../../tests/language_2/unsorted/disassemble_test.dart",
     "../../../tests/language_2/unsorted/efficient_length_warning_test.dart",
     "../../../tests/language_2/unsorted/emit_const_fields_test.dart",
     "../../../tests/language_2/unsorted/expect_test.dart",
diff --git a/runtime/tests/vm/dart/disassemble_aot_test.dart b/runtime/tests/vm/dart/disassemble_aot_test.dart
new file mode 100644
index 0000000..1ad2312
--- /dev/null
+++ b/runtime/tests/vm/dart/disassemble_aot_test.dart
@@ -0,0 +1,48 @@
+// 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.
+
+// Tests proper object recognition in disassembler.
+import 'dart:async';
+import 'dart:io';
+
+import 'package:expect/expect.dart';
+import 'package:path/path.dart' as path;
+
+import 'use_flag_test_helper.dart';
+
+Future<void> main(List<String> args) async {
+  if (Platform.isAndroid) {
+    return; // SDK tree and gen_snapshot not available on the test device.
+  }
+
+  final buildDir = path.dirname(Platform.executable);
+  final sdkDir = path.dirname(path.dirname(buildDir));
+  final platformDill = path.join(buildDir, 'vm_platform_strong.dill');
+  final genSnapshot = path.join(buildDir, 'gen_snapshot');
+
+  await withTempDir('disassemble_aot', (String tempDir) async {
+    final scriptDill = path.join(tempDir, 'out.dill');
+
+    // Compile script to Kernel IR.
+    await run('pkg/vm/tool/gen_kernel', <String>[
+      '--aot',
+      '--platform=$platformDill',
+      '-o',
+      scriptDill,
+      Platform.script.toString(),
+    ]);
+
+    // Run the AOT compiler with the disassemble flags set.
+    final elfFile = path.join(tempDir, 'aot.snapshot');
+    await Future.wait(<Future>[
+      run(genSnapshot, <String>[
+        '--snapshot-kind=app-aot-elf',
+        '--disassemble',
+        '--always_generate_trampolines_for_testing',
+        '--elf=$elfFile',
+        scriptDill,
+      ]),
+    ]);
+  });
+}
diff --git a/runtime/tests/vm/dart/disassemble_determinism_test.dart b/runtime/tests/vm/dart/disassemble_determinism_test.dart
index 1ff1091..682787c 100644
--- a/runtime/tests/vm/dart/disassemble_determinism_test.dart
+++ b/runtime/tests/vm/dart/disassemble_determinism_test.dart
@@ -33,22 +33,28 @@
     return; // Our IA32 code is not position independent.
   }
 
-  final result1 = await runDart('GENERATE DISASSEMBLY 1', [
-    '--deterministic',
-    '--disassemble',
-    '--disassemble-relative',
-    Platform.script.toFilePath(),
-    '--child'
-  ]);
+  final result1 = await runDart(
+      'GENERATE DISASSEMBLY 1',
+      [
+        '--deterministic',
+        '--disassemble',
+        '--disassemble-relative',
+        Platform.script.toFilePath(),
+        '--child'
+      ],
+      printOut: false);
   final asm1 = result1.processResult.stderr;
 
-  final result2 = await runDart('GENERATE DISASSEMBLY 2', [
-    '--deterministic',
-    '--disassemble',
-    '--disassemble-relative',
-    Platform.script.toFilePath(),
-    '--child'
-  ]);
+  final result2 = await runDart(
+      'GENERATE DISASSEMBLY 2',
+      [
+        '--deterministic',
+        '--disassemble',
+        '--disassemble-relative',
+        Platform.script.toFilePath(),
+        '--child'
+      ],
+      printOut: false);
   final asm2 = result2.processResult.stderr;
 
   Expect.isTrue(
diff --git a/runtime/tests/vm/dart/snapshot_test_helper.dart b/runtime/tests/vm/dart/snapshot_test_helper.dart
index 1f61650..80d3344 100644
--- a/runtime/tests/vm/dart/snapshot_test_helper.dart
+++ b/runtime/tests/vm/dart/snapshot_test_helper.dart
@@ -58,12 +58,14 @@
 final String checkedInDartVM =
     p.join("tools", "sdks", "dart-sdk", "bin", "dart${executableSuffix}");
 
-Future<Result> runDart(String prefix, List<String> arguments) {
+Future<Result> runDart(String prefix, List<String> arguments,
+    {bool printOut: true}) {
   final augmentedArguments = <String>[]
     ..addAll(Platform.executableArguments)
     ..add('--verbosity=warning')
     ..addAll(arguments);
-  return runBinary(prefix, Platform.executable, augmentedArguments);
+  return runBinary(prefix, Platform.executable, augmentedArguments,
+      printOut: printOut);
 }
 
 Future<Result> runGenKernel(String prefix, List<String> arguments) {
@@ -89,21 +91,23 @@
 }
 
 Future<Result> runBinary(String prefix, String binary, List<String> arguments,
-    {Map<String, String>? environment, bool runInShell: false}) async {
+    {Map<String, String>? environment,
+    bool runInShell: false,
+    bool printOut: true}) async {
   print("+ $binary " + arguments.join(" "));
   final processResult = await Process.run(binary, arguments,
       environment: environment, runInShell: runInShell);
   final result =
       new Result('[$prefix] ${binary} ${arguments.join(' ')}', processResult);
 
-  if (processResult.stdout.isNotEmpty) {
+  if (printOut && processResult.stdout.isNotEmpty) {
     print('''
 
 Command stdout:
 ${processResult.stdout}''');
   }
 
-  if (processResult.stderr.isNotEmpty) {
+  if (printOut && processResult.stderr.isNotEmpty) {
     print('''
 
 Command stderr:
diff --git a/runtime/tests/vm/dart_2/disassemble_aot_test.dart b/runtime/tests/vm/dart_2/disassemble_aot_test.dart
new file mode 100644
index 0000000..1ad2312
--- /dev/null
+++ b/runtime/tests/vm/dart_2/disassemble_aot_test.dart
@@ -0,0 +1,48 @@
+// 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.
+
+// Tests proper object recognition in disassembler.
+import 'dart:async';
+import 'dart:io';
+
+import 'package:expect/expect.dart';
+import 'package:path/path.dart' as path;
+
+import 'use_flag_test_helper.dart';
+
+Future<void> main(List<String> args) async {
+  if (Platform.isAndroid) {
+    return; // SDK tree and gen_snapshot not available on the test device.
+  }
+
+  final buildDir = path.dirname(Platform.executable);
+  final sdkDir = path.dirname(path.dirname(buildDir));
+  final platformDill = path.join(buildDir, 'vm_platform_strong.dill');
+  final genSnapshot = path.join(buildDir, 'gen_snapshot');
+
+  await withTempDir('disassemble_aot', (String tempDir) async {
+    final scriptDill = path.join(tempDir, 'out.dill');
+
+    // Compile script to Kernel IR.
+    await run('pkg/vm/tool/gen_kernel', <String>[
+      '--aot',
+      '--platform=$platformDill',
+      '-o',
+      scriptDill,
+      Platform.script.toString(),
+    ]);
+
+    // Run the AOT compiler with the disassemble flags set.
+    final elfFile = path.join(tempDir, 'aot.snapshot');
+    await Future.wait(<Future>[
+      run(genSnapshot, <String>[
+        '--snapshot-kind=app-aot-elf',
+        '--disassemble',
+        '--always_generate_trampolines_for_testing',
+        '--elf=$elfFile',
+        scriptDill,
+      ]),
+    ]);
+  });
+}
diff --git a/runtime/tests/vm/dart_2/disassemble_determinism_test.dart b/runtime/tests/vm/dart_2/disassemble_determinism_test.dart
index 1ff1091..682787c 100644
--- a/runtime/tests/vm/dart_2/disassemble_determinism_test.dart
+++ b/runtime/tests/vm/dart_2/disassemble_determinism_test.dart
@@ -33,22 +33,28 @@
     return; // Our IA32 code is not position independent.
   }
 
-  final result1 = await runDart('GENERATE DISASSEMBLY 1', [
-    '--deterministic',
-    '--disassemble',
-    '--disassemble-relative',
-    Platform.script.toFilePath(),
-    '--child'
-  ]);
+  final result1 = await runDart(
+      'GENERATE DISASSEMBLY 1',
+      [
+        '--deterministic',
+        '--disassemble',
+        '--disassemble-relative',
+        Platform.script.toFilePath(),
+        '--child'
+      ],
+      printOut: false);
   final asm1 = result1.processResult.stderr;
 
-  final result2 = await runDart('GENERATE DISASSEMBLY 2', [
-    '--deterministic',
-    '--disassemble',
-    '--disassemble-relative',
-    Platform.script.toFilePath(),
-    '--child'
-  ]);
+  final result2 = await runDart(
+      'GENERATE DISASSEMBLY 2',
+      [
+        '--deterministic',
+        '--disassemble',
+        '--disassemble-relative',
+        Platform.script.toFilePath(),
+        '--child'
+      ],
+      printOut: false);
   final asm2 = result2.processResult.stderr;
 
   Expect.isTrue(
diff --git a/runtime/tests/vm/dart_2/snapshot_test_helper.dart b/runtime/tests/vm/dart_2/snapshot_test_helper.dart
index 476b205..ddbd803 100644
--- a/runtime/tests/vm/dart_2/snapshot_test_helper.dart
+++ b/runtime/tests/vm/dart_2/snapshot_test_helper.dart
@@ -58,12 +58,14 @@
 final String checkedInDartVM =
     p.join("tools", "sdks", "dart-sdk", "bin", "dart${executableSuffix}");
 
-Future<Result> runDart(String prefix, List<String> arguments) {
+Future<Result> runDart(String prefix, List<String> arguments,
+    {bool printOut: true}) {
   final augmentedArguments = <String>[]
     ..addAll(Platform.executableArguments)
     ..add('--verbosity=warning')
     ..addAll(arguments);
-  return runBinary(prefix, Platform.executable, augmentedArguments);
+  return runBinary(prefix, Platform.executable, augmentedArguments,
+      printOut: printOut);
 }
 
 Future<Result> runGenKernel(String prefix, List<String> arguments) {
@@ -89,21 +91,23 @@
 }
 
 Future<Result> runBinary(String prefix, String binary, List<String> arguments,
-    {Map<String, String> environment, bool runInShell: false}) async {
+    {Map<String, String> environment,
+    bool runInShell: false,
+    bool printOut: true}) async {
   print("+ $binary " + arguments.join(" "));
   final processResult = await Process.run(binary, arguments,
       environment: environment, runInShell: runInShell);
   final result =
       new Result('[$prefix] ${binary} ${arguments.join(' ')}', processResult);
 
-  if (processResult.stdout.isNotEmpty) {
+  if (printOut && processResult.stdout.isNotEmpty) {
     print('''
 
 Command stdout:
 ${processResult.stdout}''');
   }
 
-  if (processResult.stderr.isNotEmpty) {
+  if (printOut && processResult.stderr.isNotEmpty) {
     print('''
 
 Command stderr:
diff --git a/runtime/tests/vm/vm.status b/runtime/tests/vm/vm.status
index 6003995..ee4e386 100644
--- a/runtime/tests/vm/vm.status
+++ b/runtime/tests/vm/vm.status
@@ -30,6 +30,10 @@
 dart_2/stack_overflow_shared_test: Pass, Slow # Uses --shared-slow-path-triggers-gc flag.
 dart_2/use_bare_instructions_flag_test: Pass, Slow # Spawns several subprocesses
 
+[ $arch == ia32 ]
+dart/disassemble_aot_test: SkipByDesign # IA32 does not support AOT.
+dart_2/disassemble_aot_test: SkipByDesign # IA32 does not support AOT.
+
 [ $builder_tag == asan ]
 dart/transferable_throws_oom_test: SkipByDesign # This test tries to allocate too much memory on purpose. Still dartbug.com/37188
 dart_2/transferable_throws_oom_test: SkipByDesign # This test tries to allocate too much memory on purpose. Still dartbug.com/37188
@@ -99,8 +103,10 @@
 
 [ $compiler != dartkp ]
 dart/base_il_serialization: SkipByDesign # Serialization currently supported only when compiling with --aot.
+dart/disassemble_aot_test: SkipByDesign # runs gen snapshot.
 dart/entrypoints/aot/*: SkipByDesign # These tests should only run on AOT.
 dart_2/base_il_serialization: SkipByDesign # Serialization currently supported only when compiling with --aot.
+dart_2/disassemble_aot_test: SkipByDesign # runs gen snapshot.
 dart_2/entrypoints/aot/*: SkipByDesign # These tests should only run on AOT.
 
 [ $compiler == fasta ]
diff --git a/tests/language/language.status b/tests/language/language.status
index 02f2ef4..f0b144b 100644
--- a/tests/language/language.status
+++ b/tests/language/language.status
@@ -37,6 +37,9 @@
 stack_trace/demangle_ctors_test: SkipByDesign # Names are not scrubbed.
 type/checks_in_factory_method_test: SkipByDesign # Requires checked mode.
 
+[ $runtime != vm ]
+unsorted/disassemble_test: Skip # VM only test
+
 [ $compiler != dart2analyzer && $compiler != fasta ]
 identifier/built_in_type_annotation_test/*: SkipByDesign # Analyzer/CFE only tests.
 
diff --git a/tests/language/language_kernel.status b/tests/language/language_kernel.status
index 71b36a0..a0fb2d7 100644
--- a/tests/language/language_kernel.status
+++ b/tests/language/language_kernel.status
@@ -6,10 +6,12 @@
 [ $compiler == app_jitk ]
 main/no_main_test/01: Crash
 number/web_int_literals_test/*: SkipByDesign # Test applies only to JavaScript targets
+unsorted/disassemble_test: SkipByDesign # Tested in JIT mode.
 vm/regress_27671_test: SkipByDesign # Relies on string comparison of exception message which may return '<optimized out>'
 
 [ $compiler == dartkp ]
 number/web_int_literals_test/*: SkipByDesign # Test applies only to JavaScript targets
+unsorted/disassemble_test: SkipByDesign # JIT only test
 
 [ $compiler == fasta ]
 number/web_int_literals_test/*: SkipByDesign # Test applies only to JavaScript targets
diff --git a/tests/language/unsorted/disassemble_test.dart b/tests/language/unsorted/disassemble_test.dart
index bc3b032..2618d1e 100644
--- a/tests/language/unsorted/disassemble_test.dart
+++ b/tests/language/unsorted/disassemble_test.dart
@@ -2,15 +2,31 @@
 // 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.
 
-// VMOptions=--disassemble
-// VMOptions=--disassemble --always_generate_trampolines_for_testing
-
 // Tests proper object recognition in disassembler.
+import 'dart:async';
+import 'dart:io';
+import "package:expect/expect.dart";
+
+Future runBinary(String binary, List<String> arguments) async {
+  print("+ $binary " + arguments.join(" "));
+  final result = await Process.run(binary, arguments);
+  return result;
+}
 
 f(x) {
   return "foo";
 }
 
-main() {
-  print(f(0));
+Future<void> main(List<String> args) async {
+  if (args.contains('--child')) {
+    print(f(0));
+    return;
+  }
+  if (Platform.executable.contains("Product")) {
+    return; // No disassembler in product mode.
+  }
+
+  final result = await runBinary(Platform.executable,
+      ['--disassemble', Platform.script.toFilePath(), '--child']);
+  Expect.equals(0, result.exitCode);
 }
diff --git a/tests/language_2/language_2.status b/tests/language_2/language_2.status
index 536cc7a..4cb75ed 100644
--- a/tests/language_2/language_2.status
+++ b/tests/language_2/language_2.status
@@ -31,6 +31,9 @@
 stack_trace/demangle_ctors_test: SkipByDesign # Names are not scrubbed.
 type/checks_in_factory_method_test: SkipByDesign # Requires checked mode.
 
+[ $runtime != vm ]
+unsorted/disassemble_test: Skip # VM only test
+
 [ $compiler != dart2analyzer && $compiler != fasta ]
 identifier/built_in_type_annotation_test/*: SkipByDesign # Analyzer/CFE only tests.
 
diff --git a/tests/language_2/unsorted/disassemble_test.dart b/tests/language_2/unsorted/disassemble_test.dart
index e4a9efa..b011929 100644
--- a/tests/language_2/unsorted/disassemble_test.dart
+++ b/tests/language_2/unsorted/disassemble_test.dart
@@ -4,15 +4,31 @@
 
 // @dart = 2.9
 
-// VMOptions=--disassemble
-// VMOptions=--disassemble --always_generate_trampolines_for_testing
-
 // Tests proper object recognition in disassembler.
+import 'dart:async';
+import 'dart:io';
+import "package:expect/expect.dart";
+
+Future runBinary(String binary, List<String> arguments) async {
+  print("+ $binary " + arguments.join(" "));
+  final result = await Process.run(binary, arguments);
+  return result;
+}
 
 f(x) {
   return "foo";
 }
 
-main() {
-  print(f(0));
+Future<void> main(List<String> args) async {
+  if (args.contains('--child')) {
+    print(f(0));
+    return;
+  }
+  if (Platform.executable.contains("Product")) {
+    return; // No disassembler in product mode.
+  }
+
+  final result = await runBinary(Platform.executable,
+      ['--disassemble', Platform.script.toFilePath(), '--child']);
+  Expect.equals(0, result.exitCode);
 }
diff --git a/tools/VERSION b/tools/VERSION
index 762f723..245eac3 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 154
+PRERELEASE 155
 PRERELEASE_PATCH 0
\ No newline at end of file
