diff --git a/.dart_tool/package_config.json b/.dart_tool/package_config.json
index 5644191..d2df8f3 100644
--- a/.dart_tool/package_config.json
+++ b/.dart_tool/package_config.json
@@ -11,7 +11,7 @@
     "constraint, update this by running tools/generate_package_config.dart."
   ],
   "configVersion": 2,
-  "generated": "2021-08-04T21:18:41.561058",
+  "generated": "2021-08-04T16:42:24.433381",
   "generator": "tools/generate_package_config.dart",
   "packages": [
     {
@@ -226,7 +226,7 @@
       "name": "dart2native",
       "rootUri": "../pkg/dart2native",
       "packageUri": "lib/",
-      "languageVersion": "2.7"
+      "languageVersion": "2.12"
     },
     {
       "name": "dart_internal",
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/extension_member_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/extension_member_contributor.dart
index 655d3dd..d635651 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/extension_member_contributor.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/extension_member_contributor.dart
@@ -10,7 +10,6 @@
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/src/dart/resolver/scope.dart';
 
 /// A contributor that produces suggestions based on the members of an
 /// extension.
@@ -113,8 +112,7 @@
   void _addExtensionMembers(LibraryElement containingLibrary,
       CompletionSuggestionKind? kind, DartType type) {
     var typeSystem = containingLibrary.typeSystem;
-    var nameScope = containingLibrary.scope;
-    for (var extension in nameScope.extensions) {
+    for (var extension in containingLibrary.accessibleExtensions) {
       var extendedType =
           extension.resolvedExtendedType(containingLibrary, type);
       if (extendedType != null && typeSystem.isSubtypeOf(type, extendedType)) {
diff --git a/pkg/analysis_server/lib/src/services/correction/organize_imports.dart b/pkg/analysis_server/lib/src/services/correction/organize_imports.dart
index aceacd3..aacc03d 100644
--- a/pkg/analysis_server/lib/src/services/correction/organize_imports.dart
+++ b/pkg/analysis_server/lib/src/services/correction/organize_imports.dart
@@ -8,6 +8,7 @@
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/source/line_info.dart';
 import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/ignore_comments/ignore_info.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart'
     hide AnalysisError, Element;
 
@@ -234,7 +235,9 @@
   /// Leading comments for the first directive in a file are considered library
   /// comments and not returned unless they contain blank lines, in which case
   /// only the last part of the comment will be returned (unless it is a
-  /// language directive comment, in which case it will also be skipped).
+  /// language directive comment, in which case it will also be skipped) or an
+  /// '// ignore:' comment which should always be treated as attached to the
+  /// import.
   static Token? getLeadingComment(
       CompilationUnit unit, UriBasedDirective directive, LineInfo lineInfo) {
     if (directive.beginToken.precedingComments == null) {
@@ -260,22 +263,25 @@
       firstComment = firstComment.next;
     }
 
-    // Check if the comment is the first comment in the document
-    if (firstComment != unit.beginToken.precedingComments) {
-      var previousDirectiveLine =
-          lineInfo.getLocation(directive.beginToken.previous!.end).lineNumber;
-
-      // Skip over any comments on the same line as the previous directive
-      // as they will be attached to the end of it.
-      var comment = firstComment;
-      while (comment != null &&
-          previousDirectiveLine ==
-              lineInfo.getLocation(comment.offset).lineNumber) {
-        comment = comment.next;
-      }
-      return comment;
+    // If the comment is the first comment in the document then whether we
+    // consider it the leading comment depends on whether it's an ignore comment
+    // or not.
+    if (firstComment != null &&
+        firstComment == unit.beginToken.precedingComments) {
+      return _isIgnoreComment(firstComment) ? firstComment : null;
     }
-    return null;
+
+    // Skip over any comments on the same line as the previous directive
+    // as they will be attached to the end of it.
+    var previousDirectiveLine =
+        lineInfo.getLocation(directive.beginToken.previous!.end).lineNumber;
+    comment = firstComment;
+    while (comment != null &&
+        previousDirectiveLine ==
+            lineInfo.getLocation(comment.offset).lineNumber) {
+      comment = comment.next;
+    }
+    return comment;
   }
 
   /// Gets the last comment token considered to be the trailing comment for this
@@ -295,6 +301,11 @@
     }
     return null;
   }
+
+  /// Returns whether this token is a '// ignore:' comment (but not an
+  /// '// ignore_for_file:' comment).
+  static bool _isIgnoreComment(Token token) =>
+      IgnoreInfo.IGNORE_MATCHER.matchAsPrefix(token.lexeme) != null;
 }
 
 class _DirectiveInfo implements Comparable<_DirectiveInfo> {
diff --git a/pkg/analysis_server/test/services/correction/organize_directives_test.dart b/pkg/analysis_server/test/services/correction/organize_directives_test.dart
index b99492a..f28613f 100644
--- a/pkg/analysis_server/test/services/correction/organize_directives_test.dart
+++ b/pkg/analysis_server/test/services/correction/organize_directives_test.dart
@@ -42,6 +42,46 @@
 ''');
   }
 
+  Future<void> test_ignore_asFirstComment() async {
+    // Usually the first comment is treated as a library comment and not moved
+    // but if it's an 'ignore:' it should be treated as attached to the import.
+    await _computeUnitAndErrors(r'''
+// ignore: unused_import
+import 'dart:io';
+import 'dart:async';
+
+Future a;
+''');
+    // validate change
+    _assertOrganize(r'''
+import 'dart:async';
+// ignore: unused_import
+import 'dart:io';
+
+Future a;
+''');
+  }
+
+  Future<void> test_ignoreForFile_asFirstComment() async {
+    // Unlike 'ignore:', 'ignore_for_file:' still _should_ be kept at the top
+    // of the file and not attached to the import.
+    await _computeUnitAndErrors(r'''
+// ignore_for_file: unused_import
+import 'dart:io';
+import 'dart:async';
+
+Future a;
+''');
+    // validate change
+    _assertOrganize(r'''
+// ignore_for_file: unused_import
+import 'dart:async';
+import 'dart:io';
+
+Future a;
+''');
+  }
+
   Future<void> test_keep_duplicateImports_withDifferentPrefix() async {
     await _computeUnitAndErrors(r'''
 import 'dart:async' as async1;
diff --git a/pkg/analyzer/lib/dart/element/element.dart b/pkg/analyzer/lib/dart/element/element.dart
index 77c23d9..f34732b 100644
--- a/pkg/analyzer/lib/dart/element/element.dart
+++ b/pkg/analyzer/lib/dart/element/element.dart
@@ -1300,6 +1300,10 @@
 ///
 /// Clients may not extend, implement or mix-in this class.
 abstract class LibraryElement implements _ExistingElement {
+  /// Returns a list containing all of the extension elements accessible within
+  /// this library.
+  List<ExtensionElement> get accessibleExtensions;
+
   /// Return the compilation unit that defines this library.
   CompilationUnitElement get definingCompilationUnit;
 
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index ed78b2e..53fdfae 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -80,7 +80,7 @@
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 167;
+  static const int DATA_VERSION = 168;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.
diff --git a/pkg/analyzer/lib/src/dart/analysis/unlinked_api_signature.dart b/pkg/analyzer/lib/src/dart/analysis/unlinked_api_signature.dart
index 74e302c..6dc30c4 100644
--- a/pkg/analyzer/lib/src/dart/analysis/unlinked_api_signature.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/unlinked_api_signature.dart
@@ -63,9 +63,7 @@
       if (member is ConstructorDeclaration) {
         signature.addInt(_kindConstructorDeclaration);
         _addTokens(member.beginToken, member.parameters.endToken);
-        if (member.constKeyword != null) {
-          _addNodeList(member.initializers);
-        }
+        _addNodeList(member.initializers);
         _addNode(member.redirectedConstructor);
       } else if (member is FieldDeclaration) {
         signature.addInt(_kindFieldDeclaration);
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index c998b6a..531e95f 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -3689,6 +3689,9 @@
         super(name, offset);
 
   @override
+  List<ExtensionElement> get accessibleExtensions => scope.extensions;
+
+  @override
   CompilationUnitElement get definingCompilationUnit =>
       _definingCompilationUnit;
 
@@ -3942,7 +3945,7 @@
   }
 
   @override
-  Scope get scope {
+  LibraryScope get scope {
     return _scope ??= LibraryScope(this);
   }
 
diff --git a/pkg/analyzer/lib/src/dart/resolver/extension_member_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/extension_member_resolver.dart
index 6ad246d..3f5ac4f 100644
--- a/pkg/analyzer/lib/src/dart/resolver/extension_member_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/extension_member_resolver.dart
@@ -6,7 +6,6 @@
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/syntactic_entity.dart';
 import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/scope.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/type_provider.dart';
 import 'package:analyzer/error/listener.dart';
@@ -19,7 +18,6 @@
 import 'package:analyzer/src/dart/element/type_schema.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/resolution_result.dart';
-import 'package:analyzer/src/dart/resolver/scope.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/util/either.dart';
@@ -37,8 +35,6 @@
   bool get _genericMetadataIsEnabled =>
       _resolver.definingLibrary.featureSet.isEnabled(Feature.generic_metadata);
 
-  Scope get _nameScope => _resolver.nameScope;
-
   TypeProvider get _typeProvider => _resolver.typeProvider;
 
   TypeSystemImpl get _typeSystem => _resolver.typeSystem;
@@ -397,7 +393,7 @@
       }
     }
 
-    for (var extension in _nameScope.extensions) {
+    for (var extension in _resolver.definingLibrary.accessibleExtensions) {
       checkExtension(extension);
     }
     return candidates;
diff --git a/pkg/analyzer/lib/src/dart/resolver/scope.dart b/pkg/analyzer/lib/src/dart/resolver/scope.dart
index 845c8e1..83c03c4 100644
--- a/pkg/analyzer/lib/src/dart/resolver/scope.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/scope.dart
@@ -6,9 +6,7 @@
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/scope.dart';
 import 'package:analyzer/src/dart/element/element.dart';
-import 'package:analyzer/src/dart/element/scope.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart';
 
@@ -350,20 +348,3 @@
     return null;
   }
 }
-
-extension ScopeExtension on Scope {
-  List<ExtensionElement> get extensions {
-    return _enclosingLibraryScope.extensions;
-  }
-
-  LibraryScope get _enclosingLibraryScope {
-    Scope? scope = this;
-    while (scope != null) {
-      if (scope is LibraryScope) {
-        return scope;
-      }
-      scope = (scope as EnclosedScope).parent;
-    }
-    throw StateError('Can only be used in a LibraryScope.');
-  }
-}
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 6a09580..4c75b2a 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -2507,6 +2507,7 @@
         nameScope,
         element.typeParameters,
       );
+      _setNodeNameScope(node, nameScope);
       visitClassDeclarationInScope(node);
 
       nameScope = ClassScope(nameScope, element);
@@ -2669,6 +2670,7 @@
         nameScope,
         element.typeParameters,
       );
+      _setNodeNameScope(node, nameScope);
       visitExtensionDeclarationInScope(node);
 
       nameScope = ExtensionScope(nameScope, element);
@@ -2788,6 +2790,7 @@
         nameScope,
         element.typeParameters,
       );
+      _setNodeNameScope(node, nameScope);
       visitFunctionDeclarationInScope(node);
     } finally {
       nameScope = outerScope;
@@ -2895,6 +2898,7 @@
       GenericFunctionTypeElement element =
           (node as GenericFunctionTypeImpl).declaredElement!;
       nameScope = TypeParameterScope(nameScope, element.typeParameters);
+      _setNodeNameScope(node, nameScope);
       super.visitGenericFunctionType(node);
     } finally {
       nameScope = outerScope;
@@ -2908,6 +2912,7 @@
     try {
       var element = node.declaredElement as TypeAliasElement;
       nameScope = TypeParameterScope(nameScope, element.typeParameters);
+      _setNodeNameScope(node, nameScope);
       visitGenericTypeAliasInScope(node);
 
       var aliasedElement = element.aliasedElement;
@@ -2962,6 +2967,7 @@
         nameScope,
         element.typeParameters,
       );
+      _setNodeNameScope(node, nameScope);
       visitMethodDeclarationInScope(node);
     } finally {
       nameScope = outerScope;
@@ -2990,6 +2996,7 @@
       node.metadata.accept(this);
 
       nameScope = TypeParameterScope(nameScope, element.typeParameters);
+      _setNodeNameScope(node, nameScope);
       visitMixinDeclarationInScope(node);
 
       nameScope = ClassScope(nameScope, element);
diff --git a/pkg/analyzer/lib/src/summary2/ast_resolver.dart b/pkg/analyzer/lib/src/summary2/ast_resolver.dart
index da1447b..0c63950 100644
--- a/pkg/analyzer/lib/src/summary2/ast_resolver.dart
+++ b/pkg/analyzer/lib/src/summary2/ast_resolver.dart
@@ -66,14 +66,11 @@
   }
 
   void resolveConstructorNode(ConstructorDeclarationImpl node) {
-    var isConst = node.constKeyword != null;
     // We don't want to visit the whole node because that will try to create an
     // element for it; we just want to process its children so that we can
     // resolve initializers and/or a redirection.
     void visit(AstVisitor<Object?> visitor) {
-      if (isConst) {
-        node.initializers.accept(visitor);
-      }
+      node.initializers.accept(visitor);
       node.redirectedConstructor?.accept(visitor);
     }
 
diff --git a/pkg/analyzer/lib/src/summary2/bundle_reader.dart b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
index 51a33b6..2c9d02c 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_reader.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
@@ -162,11 +162,8 @@
     );
     reader._addFormalParameters(element.parameters);
     _readFormalParameters(reader, element.parameters);
-    if (element.isConst || element.isFactory) {
-      element.redirectedConstructor =
-          reader.readElement() as ConstructorElement?;
-      element.constantInitializers = reader._readNodeList();
-    }
+    element.redirectedConstructor = reader.readElement() as ConstructorElement?;
+    element.constantInitializers = reader._readNodeList();
     applyConstantOffsets?.perform();
   }
 }
diff --git a/pkg/analyzer/lib/src/summary2/bundle_writer.dart b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
index 5fd0bf8..4b67169 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_writer.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
@@ -165,10 +165,8 @@
     try {
       _writeList(element.parameters, _writeParameterElement);
       _writeMacro(element.macro);
-      if (element.isConst || element.isFactory) {
-        _resolutionSink.writeElement(element.redirectedConstructor);
-        _resolutionSink._writeNodeList(element.constantInitializers);
-      }
+      _resolutionSink.writeElement(element.redirectedConstructor);
+      _resolutionSink._writeNodeList(element.constantInitializers);
     } finally {
       _resolutionSink.localElements.popScope();
     }
diff --git a/pkg/analyzer/lib/src/test_utilities/find_element.dart b/pkg/analyzer/lib/src/test_utilities/find_element.dart
index bc471b2..195647b 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_element.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_element.dart
@@ -285,6 +285,10 @@
       findInClass(class_);
     }
 
+    for (var extension_ in unitElement.extensions) {
+      findIn(extension_.typeParameters);
+    }
+
     for (var mixin in unitElement.mixins) {
       findInClass(mixin);
     }
diff --git a/pkg/analyzer/test/src/dart/analysis/unlinked_api_signature_test.dart b/pkg/analyzer/test/src/dart/analysis/unlinked_api_signature_test.dart
index 1507f47..5d2201c 100644
--- a/pkg/analyzer/test/src/dart/analysis/unlinked_api_signature_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/unlinked_api_signature_test.dart
@@ -117,7 +117,7 @@
   }
 
   test_class_constructor_initializer_empty() {
-    assertSameSignature(r'''
+    assertNotSameSignature(r'''
 class C {
   C.foo() : ;
 }
@@ -128,8 +128,9 @@
 ''');
   }
 
+  /// See https://github.com/dart-lang/sdk/issues/46206
   test_class_constructor_initializer_notConst() {
-    assertSameSignature(r'''
+    assertNotSameSignature(r'''
 class C {
   final int f;
   C.foo() : f = 1;
diff --git a/pkg/analyzer/test/src/lint/linter/resolve_name_in_scope_test.dart b/pkg/analyzer/test/src/lint/linter/resolve_name_in_scope_test.dart
index 036ee36..0520a63 100644
--- a/pkg/analyzer/test/src/lint/linter/resolve_name_in_scope_test.dart
+++ b/pkg/analyzer/test/src/lint/linter/resolve_name_in_scope_test.dart
@@ -68,6 +68,38 @@
     _checkGetterDifferent(import.topSet('foo'));
   }
 
+  test_class_getter_fromExtends_blockBody() async {
+    await resolve('''
+class A {
+  int get foo => 0;
+}
+
+class B extends A {
+  void bar(int foo) {
+    this.foo;
+  }
+}
+''');
+    _checkGetterRequested(
+      findElement.parameter('foo'),
+    );
+  }
+
+  test_class_getter_fromExtends_expressionBody() async {
+    await resolve('''
+class A {
+  int get foo => 0;
+}
+
+class B extends A {
+  void bar(int foo) => this.foo;
+}
+''');
+    _checkGetterRequested(
+      findElement.parameter('foo'),
+    );
+  }
+
   test_class_getter_none_fromExtends() async {
     await resolve('''
 class A {
@@ -408,6 +440,16 @@
     _checkMethodRequested(findElement.typeParameter('foo'));
   }
 
+  test_class_method_typeParameter() async {
+    await resolve('''
+class A {
+  void foo<T>(int T) {}
+}
+''');
+    var node = findNode.simple('T)');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
   test_class_setter_different_formalParameter_constructor() async {
     await resolve('''
 class A {
@@ -538,6 +580,46 @@
     _checkSetterRequested(findElement.setter('foo'));
   }
 
+  test_class_typeParameter_inConstructor() async {
+    await resolve('''
+class A<T> {
+  A(int T) {}
+}
+''');
+    var node = findNode.simple('T)');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
+  test_class_typeParameter_inField() async {
+    await resolve('''
+class A<T> {
+  T? a;
+}
+''');
+    var node = findNode.simple('T?');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
+  test_class_typeParameter_inMethod() async {
+    await resolve('''
+class A<T> {
+  void foo(int T) {}
+}
+''');
+    var node = findNode.simple('T)');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
+  test_class_typeParameter_inSetter() async {
+    await resolve('''
+class A<T> {
+  set foo(int T) {}
+}
+''');
+    var node = findNode.simple('T)');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
   test_extension_method_none_fromExtended() async {
     await resolve('''
 class A {
@@ -608,6 +690,41 @@
     _checkMethodRequested(findElement.method('foo'));
   }
 
+  test_extension_typeParameter_inMethod() async {
+    await resolve('''
+extension E<T> on int {
+  void foo(int T) {}
+}
+''');
+    var node = findNode.simple('T)');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
+  test_function_typeParameter() async {
+    await resolve('''
+void foo<T>(int T) {}
+''');
+    var node = findNode.simple('T)');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
+  test_genericFunctionType_typeParameter() async {
+    await resolve('''
+void foo(void Function<T>(String T) b) {}
+''');
+    var node = findNode.simple('T)');
+    var T = findNode.typeParameter('T>').declaredElement!;
+    _resultRequested(node, 'T', false, T);
+  }
+
+  test_genericTypeAlias_typeParameter() async {
+    await resolve('''
+typedef A<T> = List<T>;
+''');
+    var node = findNode.simple('T>;');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
   test_mixin_method_requested_formalParameter_method() async {
     await resolve('''
 mixin M {
@@ -634,6 +751,26 @@
     _checkMethodRequested(findElement.method('foo'));
   }
 
+  test_mixin_typeParameter_inField() async {
+    await resolve('''
+mixin A<T> {
+  T? a;
+}
+''');
+    var node = findNode.simple('T?');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
+  test_mixin_typeParameter_inMethod() async {
+    await resolve('''
+mixin A<T> {
+  void foo(int T) {}
+}
+''');
+    var node = findNode.simple('T)');
+    _resultRequested(node, 'T', false, findElement.typeParameter('T'));
+  }
+
   void _checkGetterDifferent(Element expected) {
     var node = findNode.this_('this.foo;');
     _resultDifferent(node, 'foo', false, expected);
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 8473b16..9adf69a 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -13388,6 +13388,7 @@
             periodOffset: 13
             nameEnd: 19
           @25
+            redirectedConstructor: self::@class::C::@constructor::named
 ''');
   }
 
@@ -13467,6 +13468,7 @@
           named @21
             periodOffset: 20
             nameEnd: 26
+            redirectedConstructor: self::@class::C::@constructor::•
 ''');
   }
 
diff --git a/pkg/compiler/pubspec.yaml b/pkg/compiler/pubspec.yaml
index 1073c93..ada6b1e 100644
--- a/pkg/compiler/pubspec.yaml
+++ b/pkg/compiler/pubspec.yaml
@@ -39,6 +39,7 @@
   path: any
   source_maps: any
   test: any
+  cli_util: any
   # Unpublished packages that can be used via path dependency
   async_helper:
     path: ../async_helper
diff --git a/pkg/compiler/tool/kernel_visitor/dart_html_metrics_visitor.dart b/pkg/compiler/tool/kernel_visitor/dart_html_metrics_visitor.dart
new file mode 100644
index 0000000..13cc373
--- /dev/null
+++ b/pkg/compiler/tool/kernel_visitor/dart_html_metrics_visitor.dart
@@ -0,0 +1,247 @@
+// 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 "dart:convert";
+import "dart:io";
+import "package:kernel/kernel.dart";
+import "package:kernel/ast.dart";
+
+main(List<String> args) async {
+  // Ensure right args are passed.
+  if (args.length < 1) {
+    print("usage: ${Platform.script} a.dill");
+  }
+
+  // Parse .dill and extract component.
+  var dill = args[0];
+  var component = loadComponentFromBinary(dill);
+  var visitor = MetricsVisitor(["dart:html"]);
+
+  // Visit component.
+  component.accept(visitor);
+
+  // Save data to file.
+  visitor.saveDataToFile("dart2html_metrics.json");
+}
+
+/// Visits classes in libraries specified by `libraryFilter`
+/// and aggregates metrics by class.
+class MetricsVisitor extends RecursiveVisitor {
+  String currentClass;
+  List<String> libraryFilter;
+  Map<String, ClassMetrics> classInfo = {};
+
+  MetricsVisitor([filter]) {
+    libraryFilter = filter ?? [];
+  }
+
+  @override
+  void visitComponent(Component node) {
+    super.visitComponent(node);
+    _processData();
+  }
+
+  @override
+  void visitLibrary(Library node) {
+    // Check if this is a library we want to visit.
+    var visit = libraryFilter.isNotEmpty
+        ? libraryFilter
+            .contains("${node.importUri.scheme}:${node.importUri.path}")
+        : true;
+
+    if (visit) {
+      super.visitLibrary(node);
+    }
+  }
+
+  @override
+  void visitProcedure(Procedure node) {
+    classInfo[currentClass].methods.add(ClassMetricsMethod(
+        node.name.text,
+        node.containsSuperCalls,
+        node.isInstanceMember,
+        node.isExternal,
+        node.isAbstract,
+        node.kind.toString()));
+  }
+
+  @override
+  void visitClass(Class node) {
+    // Dont want to add duplicate info.
+    // When mixed, anonymous mixin class generated so we want to ignore.
+    if (!node.isAnonymousMixin) {
+      currentClass = node.name;
+      var metrics = ClassMetrics();
+
+      // Check if class contains native members.
+      if (node.annotations.any(_isNativeMarkerAnnotation)) {
+        metrics.containsNativeMember = true;
+      }
+
+      // Check if Mixed.
+      if (node.superclass?.isAnonymousMixin ?? false) {
+        metrics.mixed = true;
+        metrics.mixins = _filterMixins(node.superclass.demangledName);
+      }
+
+      // Add parents.
+      if (node.superclass != null) {
+        var unmangledParent = _getParent(node.superclass);
+        metrics.parent = unmangledParent;
+      }
+
+      // Check for implemented classes.
+      if (node.implementedTypes.length > 0) {
+        var implementedTypes =
+            node.implementedTypes.map((type) => type.className.asClass.name);
+        metrics.implementedTypes = implementedTypes.toList();
+      }
+
+      classInfo[currentClass] = metrics;
+
+      super.visitClass(node);
+    }
+  }
+
+  // Returns List of parsed mixins from superclass name.
+  List<String> _filterMixins(String superWithMixins) {
+    var start = superWithMixins.indexOf("with") + 4;
+    var mixins = superWithMixins.substring(start);
+    mixins = mixins.replaceAll(" ", "");
+
+    return mixins.split(",");
+  }
+
+  // Recursively searches superclasses, filtering anonymous mixins,
+  // and returns parent class name.
+  String _getParent(Class node) {
+    if (node.isAnonymousMixin) {
+      return _getParent(node.superclass);
+    }
+
+    return node.name;
+  }
+
+  // Returns true if a class Annotation is Native.
+  bool _isNativeMarkerAnnotation(Expression annotation) {
+    if (annotation is ConstructorInvocation) {
+      var type = annotation.constructedType;
+      if (type.classNode.name == "Native") {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Passes through the aggregated data and processes,
+  // adding child classes and overridden methods from parent.
+  void _processData() {
+    classInfo.keys.forEach((className) {
+      var parentName = classInfo[className].parent;
+      if (classInfo[parentName] != null) {
+        classInfo[parentName].inheritedBy.add(className);
+
+        var notOverridden = <String>[];
+        var parentMethods = classInfo[parentName].methods.map((m) => m.name);
+        var classMethods = classInfo[className].methods.map((m) => m.name);
+
+        parentMethods.forEach((method) =>
+            {if (!classMethods.contains(method)) notOverridden.add(method)});
+
+        // Update Method Info.
+        classInfo[className].notOverriddenMethods = notOverridden;
+      }
+    });
+  }
+
+  // Saves the data to file.
+  void saveDataToFile(String filename) {
+    var formatted = jsonFormat(classInfo);
+
+    File(filename).writeAsStringSync(formatted);
+  }
+
+  // Converts the passed Map to a pretty print JSON string.
+  String jsonFormat(Map<String, ClassMetrics> info) {
+    JsonEncoder encoder = new JsonEncoder.withIndent("  ");
+    return encoder.convert(info);
+  }
+}
+
+/// Tracks info compiled for a class.
+class ClassMetrics {
+  List<ClassMetricsMethod> methods;
+  List<String> mixins;
+  List<String> implementedTypes;
+  List<String> notOverriddenMethods;
+  List<String> inheritedBy;
+  String parent;
+  bool mixed;
+  bool containsNativeMember;
+
+  ClassMetrics(
+      {this.mixed = false,
+      this.containsNativeMember = false,
+      this.parent,
+      methods,
+      mixins,
+      notOverridden,
+      implementedTypes,
+      inheritedBy}) {
+    this.methods = methods ?? [];
+    this.mixins = mixins ?? [];
+    this.notOverriddenMethods = notOverridden ?? [];
+    this.implementedTypes = implementedTypes ?? [];
+    this.inheritedBy = inheritedBy ?? [];
+  }
+
+  bool get invokesSuper {
+    if (methods.isNotEmpty) {
+      return methods.any((e) => e.invokesSuper);
+    }
+
+    return false;
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      "invokesSuper": invokesSuper,
+      "methods": methods,
+      "mixed": mixed,
+      "mixins": mixins,
+      "parent": parent,
+      "inheritedBy": inheritedBy,
+      "containsNativeMember": containsNativeMember,
+      "notOverriddenMethods": notOverriddenMethods,
+      "implementedTypes": implementedTypes
+    };
+  }
+}
+
+/// Tracks info related to a specific method.
+class ClassMetricsMethod {
+  String name;
+  String methodKind;
+  bool invokesSuper;
+  bool isInstanceMember;
+  bool isExternal;
+  bool isAbstract;
+
+  ClassMetricsMethod(this.name,
+      [this.invokesSuper = false,
+      this.isInstanceMember = false,
+      this.isExternal = false,
+      this.isAbstract = false,
+      this.methodKind = ""]);
+
+  Map<String, dynamic> toJson() {
+    return {
+      "name": name,
+      "invokesSuper": invokesSuper,
+      "isInstanceMember": isInstanceMember,
+      "isExternal": isExternal,
+      "isAbstract": isAbstract,
+      "methodKind": methodKind
+    };
+  }
+}
diff --git a/pkg/compiler/tool/kernel_visitor/test/info_visitor_test.dart b/pkg/compiler/tool/kernel_visitor/test/info_visitor_test.dart
new file mode 100644
index 0000000..1e24648
--- /dev/null
+++ b/pkg/compiler/tool/kernel_visitor/test/info_visitor_test.dart
@@ -0,0 +1,96 @@
+// 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:kernel/kernel.dart";
+import "package:expect/expect.dart";
+import "package:expect/minitest.dart";
+import "../dart_html_metrics_visitor.dart";
+import "package:cli_util/cli_util.dart";
+import "package:path/path.dart" as path;
+import "dart:io";
+
+main() async {
+  // Compile Dill
+  var sdkPath = getSdkPath();
+  if (!sdkPath.contains("ReleaseX64")) sdkPath = path.join(sdkPath, "ReleaseX64", "dart-sdk");
+  var scriptPath = Platform.script.path;
+  var pkgPath = path.dirname(
+      path.dirname(path.dirname(path.dirname(path.dirname(scriptPath)))));
+  var compilePath = path.canonicalize(
+      path.join(pkgPath, "front_end", "tool", "_fasta", "compile.dart"));
+  var testClassesPath = path
+      .canonicalize(path.join(path.dirname(scriptPath), "test_classes.dart"));
+  var ddcOutlinePath =
+      path.canonicalize(path.join(sdkPath, "lib", "_internal", "ddc_sdk.dill"));
+  var dillPath = path
+      .canonicalize(path.join(path.dirname(scriptPath), "test_classes.dill"));
+
+  await Process.run(path.join(sdkPath, "bin", "dart"), [
+    compilePath,
+    "--target=dartdevc",
+    "--platform=${ddcOutlinePath}",
+    "-o=${dillPath}",
+    testClassesPath
+  ]);
+
+  // Dill compiled from test_classes.dart using ddc.
+  var component = loadComponentFromBinary(dillPath);
+  var visitor = MetricsVisitor(["file:${testClassesPath}"]);
+
+  component.accept(visitor);
+
+  test("Class A does not call super", () {
+    Expect.equals(visitor.classInfo["A"].invokesSuper, false);
+  });
+
+  test("Class B does call super", () {
+    Expect.equals(visitor.classInfo["B"].invokesSuper, true);
+
+    var callingMethod = visitor.classInfo["B"].methods
+        .where((m) => m.name == "testSuper")
+        .toList()[0];
+    Expect.equals(callingMethod.invokesSuper, true);
+  });
+
+  test("Class C does not call super", () {
+    Expect.equals(visitor.classInfo["C"].invokesSuper, false);
+  });
+
+  test("Class A inherited by B", () {
+    Expect.equals(visitor.classInfo["A"].inheritedBy.contains("B"), true);
+    Expect.equals(visitor.classInfo["B"].parent, "A");
+  });
+
+  test("Class B inherited by C", () {
+    Expect.equals(visitor.classInfo["B"].inheritedBy.contains("C"), true);
+    Expect.equals(visitor.classInfo["C"].parent, "B");
+  });
+
+  test("Class B inherited by F", () {
+    Expect.equals(visitor.classInfo["B"].inheritedBy.contains("F"), true);
+    Expect.equals(visitor.classInfo["F"].parent, "B");
+  });
+
+  test("Class C inherited by nothing", () {
+    Expect.equals(visitor.classInfo["C"].inheritedBy.length, 0);
+  });
+
+  test("Class D mixed with Mix1 and Mix2", () {
+    Expect.equals(visitor.classInfo["D"].mixed, true);
+    Expect.deepEquals(visitor.classInfo["D"].mixins, ["Mix1", "Mix2"]);
+  });
+
+  test("Class F mixed with Mix1 and Mix2", () {
+    Expect.equals(visitor.classInfo["F"].mixed, true);
+    Expect.deepEquals(visitor.classInfo["F"].mixins, ["Mix1", "Mix2"]);
+  });
+
+  test("Class E implements A", () {
+    Expect.equals(visitor.classInfo["E"].implementedTypes.contains("A"), true);
+  });
+
+  test("Class G extends A but fails to override getValue()", () {
+    Expect.equals(
+        visitor.classInfo["G"].notOverriddenMethods.contains("getValue"), true);
+  });
+}
diff --git a/pkg/compiler/tool/kernel_visitor/test/test_classes.dart b/pkg/compiler/tool/kernel_visitor/test/test_classes.dart
new file mode 100644
index 0000000..2b02ef8
--- /dev/null
+++ b/pkg/compiler/tool/kernel_visitor/test/test_classes.dart
@@ -0,0 +1,60 @@
+// 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.
+library info_visitor_test_classes;
+
+// Test superclass value.
+class A {
+  A();
+
+  getValue() {
+    return "Value";
+  }
+}
+
+// Test subclass calling "super".
+class B extends A {
+  B();
+
+  testSuper() {
+    return super.getValue();
+  }
+}
+
+// Test subclass not calling "super".
+class C extends B {
+  C();
+
+  @override
+  getValue() {
+    return "Value";
+  }
+}
+
+// Test class with mixins.
+class Mix1 {}
+
+class Mix2 {}
+
+class D with Mix1, Mix2 {
+  D();
+}
+
+class F extends B with Mix1, Mix2 {
+  F();
+}
+
+// Test class with interface
+class E implements A {
+  E();
+
+  @override
+  getValue() {
+    return "E Value";
+  }
+}
+
+// Test class with unoverriden superclass method
+class G extends A {
+  G();
+}
diff --git a/pkg/dart2native/bin/dart2native.dart b/pkg/dart2native/bin/dart2native.dart
index d5d888a..f8e95ef 100644
--- a/pkg/dart2native/bin/dart2native.dart
+++ b/pkg/dart2native/bin/dart2native.dart
@@ -21,7 +21,7 @@
 
 Future<void> main(List<String> args) async {
   // If we're outputting to a terminal, wrap usage text to that width.
-  int outputLineWidth;
+  int? outputLineWidth;
   try {
     outputLineWidth = stdout.terminalColumns;
   } catch (_) {/* Ignore. */}
diff --git a/pkg/dart2native/lib/dart2native.dart b/pkg/dart2native/lib/dart2native.dart
index 3329a8d..f5f0dfe 100644
--- a/pkg/dart2native/lib/dart2native.dart
+++ b/pkg/dart2native/lib/dart2native.dart
@@ -44,7 +44,7 @@
     String platformDill,
     String sourceFile,
     String kernelFile,
-    String packages,
+    String? packages,
     List<String> defines,
     {String enableExperiment = '',
     List<String> extraGenKernelOptions = const []}) {
@@ -68,7 +68,7 @@
     String genSnapshot,
     String kernelFile,
     String snapshotFile,
-    String debugFile,
+    String? debugFile,
     bool enableAsserts,
     List<String> extraGenSnapshotOptions) {
   return Process.run(genSnapshot, [
diff --git a/pkg/dart2native/lib/generate.dart b/pkg/dart2native/lib/generate.dart
index 8c773d6..23797c9 100644
--- a/pkg/dart2native/lib/generate.dart
+++ b/pkg/dart2native/lib/generate.dart
@@ -21,14 +21,14 @@
 
 Future<void> generateNative({
   String kind = 'exe',
-  String sourceFile,
-  String outputFile,
-  String debugFile,
-  String packages,
-  List<String> defines,
+  required String sourceFile,
+  String? outputFile,
+  String? debugFile,
+  String? packages,
+  required List<String> defines,
   String enableExperiment = '',
   bool enableAsserts = false,
-  bool soundNullSafety,
+  bool? soundNullSafety,
   bool verbose = false,
   String verbosity = 'all',
   List<String> extraOptions = const [],
@@ -42,13 +42,13 @@
     final Kind outputKind = {
       'aot': Kind.aot,
       'exe': Kind.exe,
-    }[kind];
+    }[kind]!;
     final sourceWithoutDart = sourcePath.replaceFirst(RegExp(r'\.dart$'), '');
     final outputPath = path.canonicalize(path.normalize(outputFile ??
         {
           Kind.aot: '$sourceWithoutDart.aot',
           Kind.exe: '$sourceWithoutDart.exe',
-        }[outputKind]));
+        }[outputKind]!));
     final debugPath =
         debugFile != null ? path.canonicalize(path.normalize(debugFile)) : null;
 
diff --git a/pkg/dart2native/pubspec.yaml b/pkg/dart2native/pubspec.yaml
index 1e858a5..439a0cb 100644
--- a/pkg/dart2native/pubspec.yaml
+++ b/pkg/dart2native/pubspec.yaml
@@ -3,7 +3,7 @@
 publish_to: none
 
 environment:
-  sdk: "^2.7.0"
+  sdk: '>=2.12.0 <3.0.0'
 
 # Add the bin/dart2native.dart script to the scripts pub installs.
 executables:
diff --git a/pkg/front_end/lib/src/api_unstable/dart2js.dart b/pkg/front_end/lib/src/api_unstable/dart2js.dart
index e811ba1..b8d1d74 100644
--- a/pkg/front_end/lib/src/api_unstable/dart2js.dart
+++ b/pkg/front_end/lib/src/api_unstable/dart2js.dart
@@ -241,3 +241,23 @@
 // TODO(sigmund): Delete this API once `member.isRedirectingFactory`
 // is implemented correctly for patch files (Issue #33495).
 bool isRedirectingFactory(ir.Procedure member) => member.isRedirectingFactory;
+
+/// Determines what `ProcedureKind` the given extension [member] is based on
+/// the member name.
+///
+/// Note: classifies operators as `ProcedureKind.Method`.
+ir.ProcedureKind getExtensionMemberKind(ir.Procedure member) {
+  assert(member.isExtensionMember);
+  String name = member.name.text;
+  int pipeIndex = name.indexOf('|');
+  int poundIndex = name.indexOf('#');
+  assert(pipeIndex >= 0);
+  if (poundIndex >= 0) {
+    String getOrSet = name.substring(pipeIndex + 1, poundIndex);
+    return getOrSet == 'get'
+        ? ir.ProcedureKind.Getter
+        : ir.ProcedureKind.Setter;
+  } else {
+    return member.kind;
+  }
+}
diff --git a/pkg/front_end/test/desugar_test.dart b/pkg/front_end/test/desugar_test.dart
index f8078d1..b74e0bd 100644
--- a/pkg/front_end/test/desugar_test.dart
+++ b/pkg/front_end/test/desugar_test.dart
@@ -28,6 +28,7 @@
     await testRedirectingFactoryDirect();
     await testRedirectingFactorySerialized();
     await testRedirectingFactoryPatchFile();
+    await testExtensionMemberKind();
   });
 }
 
@@ -79,3 +80,97 @@
   _B(int x);
 }
 ''';
+
+testExtensionMemberKind() async {
+  var component = await compileUnit(['e.dart'], {'e.dart': extensionSource});
+  var library = component.libraries
+      .firstWhere((l) => l.importUri.path.endsWith('e.dart'));
+  var descriptors =
+      library.extensions.expand((extension) => extension.members).toList();
+
+  // Check generated getters and setters for fields.
+  var fieldGetter =
+      findExtensionField(descriptors, 'field', ir.ExtensionMemberKind.Getter);
+  Expect.equals(
+      api.getExtensionMemberKind(fieldGetter), ir.ProcedureKind.Getter);
+  var fieldSetter =
+      findExtensionField(descriptors, 'field', ir.ExtensionMemberKind.Setter);
+  Expect.equals(
+      api.getExtensionMemberKind(fieldSetter), ir.ProcedureKind.Setter);
+  var staticFieldGetter = findExtensionField(
+      descriptors, 'staticField', ir.ExtensionMemberKind.Getter);
+  Expect.equals(
+      api.getExtensionMemberKind(staticFieldGetter), ir.ProcedureKind.Getter);
+  var staticFieldSetter = findExtensionField(
+      descriptors, 'staticField', ir.ExtensionMemberKind.Setter);
+  Expect.equals(
+      api.getExtensionMemberKind(staticFieldSetter), ir.ProcedureKind.Setter);
+
+  // Check getters and setters.
+  var getter = findExtensionMember(descriptors, 'getter');
+  Expect.equals(api.getExtensionMemberKind(getter), ir.ProcedureKind.Getter);
+  var setter = findExtensionMember(descriptors, 'setter');
+  Expect.equals(api.getExtensionMemberKind(setter), ir.ProcedureKind.Setter);
+  var staticGetter = findExtensionMember(descriptors, 'staticGetter');
+  Expect.equals(
+      api.getExtensionMemberKind(staticGetter), ir.ProcedureKind.Getter);
+  var staticSetter = findExtensionMember(descriptors, 'staticSetter');
+  Expect.equals(
+      api.getExtensionMemberKind(staticSetter), ir.ProcedureKind.Setter);
+
+  // Check methods.
+  var method = findExtensionMember(descriptors, 'method');
+  Expect.equals(api.getExtensionMemberKind(method), ir.ProcedureKind.Method);
+  var methodTearoff = findExtensionTearoff(descriptors, 'get#method');
+  Expect.equals(
+      api.getExtensionMemberKind(methodTearoff), ir.ProcedureKind.Getter);
+  var staticMethod = findExtensionMember(descriptors, 'staticMethod');
+  Expect.equals(
+      api.getExtensionMemberKind(staticMethod), ir.ProcedureKind.Method);
+
+  // Check operators.
+  var operator = findExtensionMember(descriptors, '+');
+  Expect.equals(api.getExtensionMemberKind(operator), ir.ProcedureKind.Method);
+}
+
+ir.Member findExtensionMember(
+    List<ir.ExtensionMemberDescriptor> descriptors, String memberName) {
+  return descriptors
+      .firstWhere((d) => d.name.text == memberName)
+      .member
+      .asMember;
+}
+
+ir.Member findExtensionField(List<ir.ExtensionMemberDescriptor> descriptors,
+    String fieldName, ir.ExtensionMemberKind kind) {
+  return descriptors
+      .firstWhere((d) => d.name.text == fieldName && d.kind == kind)
+      .member
+      .asMember;
+}
+
+ir.Member findExtensionTearoff(
+    List<ir.ExtensionMemberDescriptor> descriptors, String memberName) {
+  return descriptors
+      .map((d) => d.member.asMember)
+      .firstWhere((m) => m.name.text.contains(memberName));
+}
+
+const extensionSource = '''
+class Foo {}
+
+extension Ext on Foo {
+  external int field;
+  external static int staticField;
+
+  external get getter;
+  external set setter(_);
+  external static get staticGetter;
+  external static set staticSetter(_);
+
+  external int method();
+  external static int staticMethod();
+
+  external operator +(_);
+}
+''';
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index aed39dd..201c0e11 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -391,8 +391,8 @@
 enforced
 enforces
 enforcing
-enters
 engineered
+enters
 enumerates
 env
 eof
@@ -896,6 +896,7 @@
 physically
 pi
 picking
+pipe
 pkg
 play
 player
@@ -911,6 +912,7 @@
 pos
 possibility
 postfix
+pound
 pow
 pragma
 pre
diff --git a/runtime/tests/vm/dart/regress_46799_test.dart b/runtime/tests/vm/dart/regress_46799_test.dart
new file mode 100644
index 0000000..0d44c95
--- /dev/null
+++ b/runtime/tests/vm/dart/regress_46799_test.dart
@@ -0,0 +1,20 @@
+// 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.
+
+// Reduced from
+// The Dart Project Fuzz Tester (1.91).
+// Program generated as:
+//   dart dartfuzz.dart --seed 1052527605 --no-fp --no-ffi --flat
+
+bool var31 = bool.hasEnvironment('z');
+
+@pragma('vm:never-inline')
+num foo0() {
+  print(var31);
+  return -4294967296;
+}
+
+main() {
+  print(((-67) ~/ (var31 ? -83 : foo0())));
+}
diff --git a/runtime/tests/vm/dart_2/regress_46799_test.dart b/runtime/tests/vm/dart_2/regress_46799_test.dart
new file mode 100644
index 0000000..0d44c95
--- /dev/null
+++ b/runtime/tests/vm/dart_2/regress_46799_test.dart
@@ -0,0 +1,20 @@
+// 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.
+
+// Reduced from
+// The Dart Project Fuzz Tester (1.91).
+// Program generated as:
+//   dart dartfuzz.dart --seed 1052527605 --no-fp --no-ffi --flat
+
+bool var31 = bool.hasEnvironment('z');
+
+@pragma('vm:never-inline')
+num foo0() {
+  print(var31);
+  return -4294967296;
+}
+
+main() {
+  print(((-67) ~/ (var31 ? -83 : foo0())));
+}
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index 2b984a0..c531f98 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -59,7 +59,7 @@
 // StorageTrait for HashTable which allows to create hash tables backed by
 // zone memory. Used to compute cluster order for canonical clusters.
 struct GrowableArrayStorageTraits {
-  class Array {
+  class Array : public ZoneAllocated {
    public:
     explicit Array(Zone* zone, intptr_t length)
         : length_(length), array_(zone->Alloc<ObjectPtr>(length)) {}
diff --git a/runtime/vm/compiler/backend/type_propagator.cc b/runtime/vm/compiler/backend/type_propagator.cc
index 06edf78..acb00ca 100644
--- a/runtime/vm/compiler/backend/type_propagator.cc
+++ b/runtime/vm/compiler/backend/type_propagator.cc
@@ -1348,8 +1348,9 @@
   // TODO(alexmarkov): calculate type of InstanceCallInstr eagerly
   // (in optimized mode) and avoid keeping separate result_type.
   CompileType* inferred_type = result_type();
-  if ((inferred_type != NULL) &&
-      (inferred_type->ToNullableCid() != kDynamicCid)) {
+  if ((inferred_type != nullptr) &&
+      ((inferred_type->ToNullableCid() != kDynamicCid) ||
+       (!inferred_type->ToAbstractType()->IsDynamicType()))) {
     TraceStrongModeType(this, inferred_type);
     return *inferred_type;
   }
@@ -1441,8 +1442,11 @@
   if (is_known_list_constructor()) {
     return ComputeListFactoryType(inferred_type, ArgumentValueAt(0));
   }
-  if ((inferred_type != NULL) &&
-      (inferred_type->ToNullableCid() != kDynamicCid)) {
+
+  if ((inferred_type != nullptr) &&
+      ((inferred_type->ToNullableCid() != kDynamicCid) ||
+       (!inferred_type->ToAbstractType()->IsDynamicType()))) {
+    TraceStrongModeType(this, inferred_type);
     return *inferred_type;
   }
 
diff --git a/runtime/vm/isolate_reload.cc b/runtime/vm/isolate_reload.cc
index 182c090..999790d 100644
--- a/runtime/vm/isolate_reload.cc
+++ b/runtime/vm/isolate_reload.cc
@@ -2274,7 +2274,10 @@
       instance_ ^= value.ptr();
       if (!instance_.IsAssignableTo(type_, instantiator_type_arguments_,
                                     function_type_arguments_)) {
-        ASSERT(!FLAG_identity_reload);
+        // Even if doing an identity reload, type check can fail if hot reload
+        // happens while constructor is still running and field is not
+        // initialized yet, so it has a null value.
+        ASSERT(!FLAG_identity_reload || instance_.IsNull());
         field.set_needs_load_guard(true);
       } else {
         cache_.AddCheck(instance_cid_or_signature_, type_,
diff --git a/runtime/vm/message_snapshot.cc b/runtime/vm/message_snapshot.cc
index 1c5e2db..b9400ee 100644
--- a/runtime/vm/message_snapshot.cc
+++ b/runtime/vm/message_snapshot.cc
@@ -780,13 +780,17 @@
     objects_.Add(instance);
 
     const intptr_t next_field_offset = next_field_offset_;
+#if defined(DART_PRECOMPILED_RUNTIME)
     const auto unboxed_fields_bitmap =
         s->isolate_group()->shared_class_table()->GetUnboxedFieldsMapAt(cid_);
+#endif
     for (intptr_t offset = Instance::NextFieldOffset();
          offset < next_field_offset; offset += kCompressedWordSize) {
+#if defined(DART_PRECOMPILED_RUNTIME)
       if (unboxed_fields_bitmap.Get(offset / kCompressedWordSize)) {
         continue;
       }
+#endif
       s->Push(reinterpret_cast<CompressedObjectPtr*>(
                   reinterpret_cast<uword>(instance->untag()) + offset)
                   ->Decompress(instance->untag()->heap_base()));
@@ -810,20 +814,24 @@
       Instance* instance = objects_[i];
 
       const intptr_t next_field_offset = next_field_offset_;
+#if defined(DART_PRECOMPILED_RUNTIME)
       const auto unboxed_fields_bitmap =
           s->isolate_group()->shared_class_table()->GetUnboxedFieldsMapAt(cid_);
+#endif
       for (intptr_t offset = Instance::NextFieldOffset();
            offset < next_field_offset; offset += kCompressedWordSize) {
+#if defined(DART_PRECOMPILED_RUNTIME)
         if (unboxed_fields_bitmap.Get(offset / kCompressedWordSize)) {
           // Writes 32 bits of the unboxed value at a time
           const uword value = *reinterpret_cast<compressed_uword*>(
               reinterpret_cast<uword>(instance->untag()) + offset);
           s->WriteWordWith32BitWrites(value);
-        } else {
-          s->WriteRef(reinterpret_cast<CompressedObjectPtr*>(
-                          reinterpret_cast<uword>(instance->untag()) + offset)
-                          ->Decompress(instance->untag()->heap_base()));
+          continue;
         }
+#endif
+        s->WriteRef(reinterpret_cast<CompressedObjectPtr*>(
+                        reinterpret_cast<uword>(instance->untag()) + offset)
+                        ->Decompress(instance->untag()->heap_base()));
       }
     }
   }
@@ -853,37 +861,44 @@
 
   void ReadEdges(MessageDeserializer* d) {
     const intptr_t next_field_offset = cls_.host_next_field_offset();
-    const intptr_t type_argument_field_offset =
-        cls_.host_type_arguments_field_offset();
+#if defined(DART_PRECOMPILED_RUNTIME)
     const auto unboxed_fields_bitmap =
         d->isolate_group()->shared_class_table()->GetUnboxedFieldsMapAt(
             cls_.id());
+#else
+    const intptr_t type_argument_field_offset =
+        cls_.host_type_arguments_field_offset();
     const bool use_field_guards = d->isolate_group()->use_field_guards();
     const Array& field_map = Array::Handle(d->zone(), cls_.OffsetToFieldMap());
+    Field& field = Field::Handle(d->zone());
+#endif
     Instance& instance = Instance::Handle(d->zone());
     Object& value = Object::Handle(d->zone());
-    Field& field = Field::Handle(d->zone());
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       instance ^= d->Ref(id);
       for (intptr_t offset = Instance::NextFieldOffset();
            offset < next_field_offset; offset += kCompressedWordSize) {
+#if defined(DART_PRECOMPILED_RUNTIME)
         if (unboxed_fields_bitmap.Get(offset / kCompressedWordSize)) {
           compressed_uword* p = reinterpret_cast<compressed_uword*>(
               reinterpret_cast<uword>(instance.untag()) + offset);
           // Reads 32 bits of the unboxed value at a time
           *p = d->ReadWordWith32BitReads();
-        } else {
-          value = d->ReadRef();
-          instance.SetFieldAtOffset(offset, value);
-          if (use_field_guards && (offset != type_argument_field_offset) &&
-              (value.ptr() != Object::sentinel().ptr())) {
-            field ^= field_map.At(offset >> kCompressedWordSizeLog2);
-            ASSERT(!field.IsNull());
-            ASSERT(field.HostOffset() == offset);
-            field.RecordStore(value);
-          }
+          continue;
         }
+#endif
+        value = d->ReadRef();
+        instance.SetFieldAtOffset(offset, value);
+#if !defined(DART_PRECOMPILED_RUNTIME)
+        if (use_field_guards && (offset != type_argument_field_offset) &&
+            (value.ptr() != Object::sentinel().ptr())) {
+          field ^= field_map.At(offset >> kCompressedWordSizeLog2);
+          ASSERT(!field.IsNull());
+          ASSERT(field.HostOffset() == offset);
+          field.RecordStore(value);
+        }
+#endif
       }
     }
   }
diff --git a/runtime/vm/port.cc b/runtime/vm/port.cc
index a671373..51029ae 100644
--- a/runtime/vm/port.cc
+++ b/runtime/vm/port.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "include/dart_api.h"
 #include "platform/utils.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ -40,6 +41,8 @@
 Dart_Port PortMap::AllocatePort() {
   Dart_Port result;
 
+  ASSERT(mutex_->IsOwnedByCurrentThread());
+
   // Keep getting new values while we have an illegal port number or the port
   // number is already in use.
   do {
@@ -68,6 +71,9 @@
 
 void PortMap::SetPortState(Dart_Port port, PortState state) {
   MutexLocker ml(mutex_);
+  if (ports_ == nullptr) {
+    return;
+  }
 
   auto it = ports_->TryLookup(port);
   ASSERT(it != ports_->end());
@@ -93,6 +99,10 @@
 Dart_Port PortMap::CreatePort(MessageHandler* handler) {
   ASSERT(handler != NULL);
   MutexLocker ml(mutex_);
+  if (ports_ == nullptr) {
+    return ILLEGAL_PORT;
+  }
+
 #if defined(DEBUG)
   handler->CheckAccess();
 #endif
@@ -126,6 +136,9 @@
   MessageHandler* handler = NULL;
   {
     MutexLocker ml(mutex_);
+    if (ports_ == nullptr) {
+      return false;
+    }
     auto it = ports_->TryLookup(port);
     if (it == ports_->end()) {
       return false;
@@ -165,6 +178,9 @@
 void PortMap::ClosePorts(MessageHandler* handler) {
   {
     MutexLocker ml(mutex_);
+    if (ports_ == nullptr) {
+      return;
+    }
     // The MessageHandler::ports_ is only accessed by [PortMap], it is guarded
     // by the [PortMap::mutex_] we already hold.
     for (auto isolate_it = handler->ports_.begin();
@@ -189,6 +205,9 @@
 bool PortMap::PostMessage(std::unique_ptr<Message> message,
                           bool before_events) {
   MutexLocker ml(mutex_);
+  if (ports_ == nullptr) {
+    return false;
+  }
   auto it = ports_->TryLookup(message->dest_port());
   if (it == ports_->end()) {
     // Ownership of external data remains with the poster.
@@ -203,6 +222,9 @@
 
 bool PortMap::IsLocalPort(Dart_Port id) {
   MutexLocker ml(mutex_);
+  if (ports_ == nullptr) {
+    return false;
+  }
   auto it = ports_->TryLookup(id);
   if (it == ports_->end()) {
     // Port does not exist.
@@ -216,6 +238,9 @@
 
 bool PortMap::IsLivePort(Dart_Port id) {
   MutexLocker ml(mutex_);
+  if (ports_ == nullptr) {
+    return false;
+  }
   auto it = ports_->TryLookup(id);
   if (it == ports_->end()) {
     // Port does not exist.
@@ -228,6 +253,9 @@
 
 Isolate* PortMap::GetIsolate(Dart_Port id) {
   MutexLocker ml(mutex_);
+  if (ports_ == nullptr) {
+    return nullptr;
+  }
   auto it = ports_->TryLookup(id);
   if (it == ports_->end()) {
     // Port does not exist.
@@ -241,6 +269,9 @@
 bool PortMap::IsReceiverInThisIsolateGroup(Dart_Port receiver,
                                            IsolateGroup* group) {
   MutexLocker ml(mutex_);
+  if (ports_ == nullptr) {
+    return false;
+  }
   auto it = ports_->TryLookup(receiver);
   if (it == ports_->end()) return false;
   auto isolate = (*it).handler->isolate();
@@ -249,7 +280,6 @@
 }
 
 void PortMap::Init() {
-  // TODO(bkonyi): don't keep ports_ after Dart_Cleanup.
   if (mutex_ == NULL) {
     mutex_ = new Mutex();
   }
@@ -276,11 +306,12 @@
   }
   ports_->Rebalance();
 
+  // Grab the mutex and delete the port set.
+  MutexLocker ml(mutex_);
   delete prng_;
   prng_ = NULL;
-  // TODO(bkonyi): find out why deleting map_ sometimes causes crashes.
-  // delete ports_;
-  // ports_ = nullptr;
+  delete ports_;
+  ports_ = nullptr;
 }
 
 void PortMap::PrintPortsForMessageHandler(MessageHandler* handler,
@@ -292,6 +323,9 @@
   {
     JSONArray ports(&jsobj, "ports");
     SafepointMutexLocker ml(mutex_);
+    if (ports_ == nullptr) {
+      return;
+    }
     for (auto& entry : *ports_) {
       if (entry.handler == handler) {
         if (entry.state == kLivePort) {
@@ -309,6 +343,9 @@
 
 void PortMap::DebugDumpForMessageHandler(MessageHandler* handler) {
   SafepointMutexLocker ml(mutex_);
+  if (ports_ == nullptr) {
+    return;
+  }
   Object& msg_handler = Object::Handle();
   for (auto& entry : *ports_) {
     if (entry.handler == handler) {
diff --git a/runtime/vm/zone.cc b/runtime/vm/zone.cc
index 1679e2c..744c8a5 100644
--- a/runtime/vm/zone.cc
+++ b/runtime/vm/zone.cc
@@ -163,23 +163,23 @@
 // is created within a new thread or ApiNativeScope when calculating high
 // watermarks or memory consumption.
 Zone::Zone()
-    : initial_buffer_(buffer_, kInitialChunkSize),
-      position_(initial_buffer_.start()),
-      limit_(initial_buffer_.end()),
+    : canary_(kCanary),
+      position_(reinterpret_cast<uword>(&buffer_)),
+      limit_(position_ + kInitialChunkSize),
       head_(NULL),
       large_segments_(NULL),
-      handles_(),
-      previous_(NULL) {
+      previous_(NULL),
+      handles_() {
   ASSERT(Utils::IsAligned(position_, kAlignment));
   Segment::IncrementMemoryCapacity(kInitialChunkSize);
 #ifdef DEBUG
   // Zap the entire initial buffer.
-  memset(initial_buffer_.pointer(), kZapUninitializedByte,
-         initial_buffer_.size());
+  memset(&buffer_, kZapUninitializedByte, kInitialChunkSize);
 #endif
 }
 
 Zone::~Zone() {
+  ASSERT(canary_ == kCanary);
   if (FLAG_trace_zones) {
     DumpZoneSizes();
   }
@@ -198,10 +198,10 @@
   }
 // Reset zone state.
 #ifdef DEBUG
-  memset(initial_buffer_.pointer(), kZapDeletedByte, initial_buffer_.size());
+  memset(&buffer_, kZapDeletedByte, kInitialChunkSize);
 #endif
-  position_ = initial_buffer_.start();
-  limit_ = initial_buffer_.end();
+  position_ = reinterpret_cast<uword>(&buffer_);
+  limit_ = position_ + kInitialChunkSize;
   small_segment_capacity_ = 0;
   head_ = NULL;
   large_segments_ = NULL;
@@ -215,9 +215,9 @@
     size += s->size();
   }
   if (head_ == NULL) {
-    return size + (position_ - initial_buffer_.start());
+    return size + (position_ - reinterpret_cast<uword>(&buffer_));
   }
-  size += initial_buffer_.size();
+  size += kInitialChunkSize;
   for (Segment* s = head_->next(); s != NULL; s = s->next()) {
     size += s->size();
   }
@@ -230,9 +230,9 @@
     size += s->size();
   }
   if (head_ == NULL) {
-    return size + initial_buffer_.size();
+    return size + kInitialChunkSize;
   }
-  size += initial_buffer_.size();
+  size += kInitialChunkSize;
   for (Segment* s = head_; s != NULL; s = s->next()) {
     size += s->size();
   }
diff --git a/runtime/vm/zone.h b/runtime/vm/zone.h
index cb45741..e4a0030 100644
--- a/runtime/vm/zone.h
+++ b/runtime/vm/zone.h
@@ -141,13 +141,9 @@
   template <class ElementType>
   static inline void CheckLength(intptr_t len);
 
-  // This buffer is used for allocation before any segments.
-  // This would act as the initial stack allocated chunk so that we don't
-  // end up calling malloc/free on zone scopes that allocate less than
-  // kChunkSize
-  COMPILE_ASSERT(kAlignment <= 8);
-  ALIGN8 uint8_t buffer_[kInitialChunkSize];
-  MemoryRegion initial_buffer_;
+  // Guard against `new (zone) DoesNotExtendZoneAllocated()`.
+  static constexpr uint64_t kCanary = 0x656e6f7a74726164ull;  // "dartzone"
+  uint64_t canary_;
 
   // The free region in the current (head) segment or the initial buffer is
   // represented as the half-open interval [position, limit). The 'position'
@@ -169,11 +165,18 @@
   // List of large segments allocated in this zone; may be NULL.
   Segment* large_segments_;
 
+  // Used for chaining zones in order to allow unwinding of stacks.
+  Zone* previous_;
+
   // Structure for managing handles allocation.
   VMHandles handles_;
 
-  // Used for chaining zones in order to allow unwinding of stacks.
-  Zone* previous_;
+  // This buffer is used for allocation before any segments.
+  // This would act as the initial stack allocated chunk so that we don't
+  // end up calling malloc/free on zone scopes that allocate less than
+  // kChunkSize
+  COMPILE_ASSERT(kAlignment <= 8);
+  ALIGN8 uint8_t buffer_[kInitialChunkSize];
 
   friend class StackZone;
   friend class ApiZone;
@@ -274,23 +277,26 @@
                                   intptr_t new_len) {
   CheckLength<ElementType>(new_len);
   const intptr_t kElementSize = sizeof(ElementType);
-  uword old_end = reinterpret_cast<uword>(old_data) + (old_len * kElementSize);
-  // Resize existing allocation if nothing was allocated in between...
-  if (Utils::RoundUp(old_end, kAlignment) == position_) {
-    uword new_end =
-        reinterpret_cast<uword>(old_data) + (new_len * kElementSize);
-    // ...and there is sufficient space.
-    if (new_end <= limit_) {
-      ASSERT(new_len >= old_len);
-      position_ = Utils::RoundUp(new_end, kAlignment);
+  if (old_data != nullptr) {
+    uword old_end =
+        reinterpret_cast<uword>(old_data) + (old_len * kElementSize);
+    // Resize existing allocation if nothing was allocated in between...
+    if (Utils::RoundUp(old_end, kAlignment) == position_) {
+      uword new_end =
+          reinterpret_cast<uword>(old_data) + (new_len * kElementSize);
+      // ...and there is sufficient space.
+      if (new_end <= limit_) {
+        ASSERT(new_len >= old_len);
+        position_ = Utils::RoundUp(new_end, kAlignment);
+        return old_data;
+      }
+    }
+    if (new_len <= old_len) {
       return old_data;
     }
   }
-  if (new_len <= old_len) {
-    return old_data;
-  }
   ElementType* new_data = Alloc<ElementType>(new_len);
-  if (old_data != 0) {
+  if (old_data != nullptr) {
     memmove(reinterpret_cast<void*>(new_data),
             reinterpret_cast<void*>(old_data), old_len * kElementSize);
   }
diff --git a/tools/VERSION b/tools/VERSION
index 3cb9897..c9d32db 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 385
+PRERELEASE 386
 PRERELEASE_PATCH 0
\ No newline at end of file