diff --git a/DEPS b/DEPS
index 727abd3..d76a003 100644
--- a/DEPS
+++ b/DEPS
@@ -130,7 +130,6 @@
   "protobuf_rev": "3746c8fd3f2b0147623a8e3db89c3ff4330de760",
   "pub_rev": "5b4df5a6f931c63622ac349602d6ef0367e8070f",
   "pub_semver_tag": "v1.4.4",
-  "quiver-dart_tag": "246e754fe45cecb6aa5f3f13b4ed61037ff0d784",
   "resource_rev": "6b79867d0becf5395e5819a75720963b8298e9a7",
   "root_certificates_rev": "7e5ec82c99677a2e5b95ce296c4d68b0d3378ed8",
   "rust_revision": "b7856f695d65a8ebc846754f97d15814bcb1c244",
@@ -387,10 +386,6 @@
       Var("dart_git") + "pub_semver.git" + "@" + Var("pub_semver_tag"),
   Var("dart_root") + "/third_party/pkg/pub":
       Var("dart_git") + "pub.git" + "@" + Var("pub_rev"),
-  Var("dart_root") + "/third_party/pkg/quiver":
-      Var("chromium_git")
-      + "/external/github.com/google/quiver-dart.git"
-      + "@" + Var("quiver-dart_tag"),
   Var("dart_root") + "/third_party/pkg/resource":
       Var("dart_git") + "resource.git" + "@" + Var("resource_rev"),
   Var("dart_root") + "/third_party/pkg/shelf":
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/modifier_context.dart b/pkg/_fe_analyzer_shared/lib/src/parser/modifier_context.dart
index 904871b..3ef7898 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/modifier_context.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/modifier_context.dart
@@ -220,6 +220,12 @@
     assert(optional('abstract', next));
     if (abstractToken == null) {
       abstractToken = next;
+
+      if (varFinalOrConst != null) {
+        reportModifierOutOfOrder(next, varFinalOrConst.lexeme);
+      } else if (covariantToken != null) {
+        reportModifierOutOfOrder(next, covariantToken.lexeme);
+      }
       return next;
     }
 
@@ -308,6 +314,10 @@
         reportModifierOutOfOrder(next, staticToken.lexeme);
       } else if (lateToken != null) {
         reportModifierOutOfOrder(next, lateToken.lexeme);
+      } else if (varFinalOrConst != null) {
+        reportModifierOutOfOrder(next, varFinalOrConst.lexeme);
+      } else if (covariantToken != null) {
+        reportModifierOutOfOrder(next, covariantToken.lexeme);
       }
       return next;
     }
diff --git a/pkg/dev_compiler/tool/dartdevc_nnbd_sdk_error_golden.txt b/pkg/dev_compiler/tool/dartdevc_nnbd_sdk_error_golden.txt
index 35dd9b3..39bf88b 100644
--- a/pkg/dev_compiler/tool/dartdevc_nnbd_sdk_error_golden.txt
+++ b/pkg/dev_compiler/tool/dartdevc_nnbd_sdk_error_golden.txt
@@ -1,11 +1,11 @@
 ERROR|COMPILE_TIME_ERROR|CONST_CONSTRUCTOR_THROWS_EXCEPTION|lib/core/core.dart|3679|5|94|Const constructors can't throw exceptions.
-ERROR|COMPILE_TIME_ERROR|CONST_CONSTRUCTOR_THROWS_EXCEPTION|lib/core/core.dart|7879|5|97|Const constructors can't throw exceptions.
+ERROR|COMPILE_TIME_ERROR|CONST_CONSTRUCTOR_THROWS_EXCEPTION|lib/core/core.dart|7880|5|97|Const constructors can't throw exceptions.
 ERROR|COMPILE_TIME_ERROR|CONST_CONSTRUCTOR_THROWS_EXCEPTION|lib/core/core.dart|893|5|95|Const constructors can't throw exceptions.
 ERROR|COMPILE_TIME_ERROR|CONST_CONSTRUCTOR_THROWS_EXCEPTION|lib/core/core.dart|926|5|94|Const constructors can't throw exceptions.
 ERROR|COMPILE_TIME_ERROR|INVALID_ASSIGNMENT|lib/_internal/js_dev_runtime/private/interceptors.dart|1358|18|27|A value of type 'double' can't be assigned to a variable of type 'int'.
 ERROR|COMPILE_TIME_ERROR|RETURN_OF_INVALID_TYPE|lib/_internal/js_dev_runtime/private/interceptors.dart|1225|14|38|A value of type 'double' can't be returned from method '%' because it has a return type of 'JSNumber'.
 ERROR|COMPILE_TIME_ERROR|RETURN_OF_INVALID_TYPE|lib/_internal/js_dev_runtime/private/interceptors.dart|1227|14|38|A value of type 'double' can't be returned from method '%' because it has a return type of 'JSNumber'.
 ERROR|SYNTACTIC_ERROR|CONST_FACTORY|lib/core/core.dart|3677|3|5|Only redirecting factory constructors can be declared to be 'const'.
-ERROR|SYNTACTIC_ERROR|CONST_FACTORY|lib/core/core.dart|7877|3|5|Only redirecting factory constructors can be declared to be 'const'.
+ERROR|SYNTACTIC_ERROR|CONST_FACTORY|lib/core/core.dart|7878|3|5|Only redirecting factory constructors can be declared to be 'const'.
 ERROR|SYNTACTIC_ERROR|CONST_FACTORY|lib/core/core.dart|891|3|5|Only redirecting factory constructors can be declared to be 'const'.
 ERROR|SYNTACTIC_ERROR|CONST_FACTORY|lib/core/core.dart|924|3|5|Only redirecting factory constructors can be declared to be 'const'.
diff --git a/pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart b/pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart
index c08ebe5..88124b4 100644
--- a/pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart
@@ -116,6 +116,8 @@
   final Name name;
   ClassMember declaredMember;
   ClassMember declaredSetter;
+  ClassMember mixedInMember;
+  ClassMember mixedInSetter;
   ClassMember extendedMember;
   ClassMember extendedSetter;
   List<ClassMember> implementedMembers;
@@ -125,6 +127,10 @@
       : assert(!declaredMember.forSetter),
         this.name = declaredMember.name;
 
+  Tuple.mixInMember(this.mixedInMember)
+      : assert(!mixedInMember.forSetter),
+        this.name = mixedInMember.name;
+
   Tuple.extendMember(this.extendedMember)
       : assert(!extendedMember.forSetter),
         this.name = extendedMember.name;
@@ -138,6 +144,10 @@
       : assert(declaredSetter.forSetter),
         this.name = declaredSetter.name;
 
+  Tuple.mixInSetter(this.mixedInSetter)
+      : assert(mixedInSetter.forSetter),
+        this.name = mixedInSetter.name;
+
   Tuple.extendSetter(this.extendedSetter)
       : assert(extendedSetter.forSetter),
         this.name = extendedSetter.name;
@@ -164,6 +174,18 @@
       sb.write(declaredSetter);
       comma = ',';
     }
+    if (mixedInMember != null) {
+      sb.write(comma);
+      sb.write('mixedInMember=');
+      sb.write(mixedInMember);
+      comma = ',';
+    }
+    if (mixedInSetter != null) {
+      sb.write(comma);
+      sb.write('mixedInSetter=');
+      sb.write(mixedInSetter);
+      comma = ',';
+    }
     if (extendedMember != null) {
       sb.write(comma);
       sb.write('extendedMember=');
@@ -1677,28 +1699,10 @@
       assert(supernode != null);
     }
 
-    Scope scope = classBuilder.scope;
-    if (classBuilder.isMixinApplication) {
-      TypeBuilder mixedInTypeBuilder = classBuilder.mixedInTypeBuilder;
-      TypeDeclarationBuilder mixin = mixedInTypeBuilder.declaration;
-      inferMixinApplication();
-      while (mixin.isNamedMixinApplication) {
-        ClassBuilder named = mixin;
-        mixedInTypeBuilder = named.mixedInTypeBuilder;
-        mixin = mixedInTypeBuilder.declaration;
-      }
-      if (mixin is TypeAliasBuilder) {
-        TypeAliasBuilder aliasBuilder = mixin;
-        NamedTypeBuilder namedBuilder = mixedInTypeBuilder;
-        mixin = aliasBuilder.unaliasDeclaration(namedBuilder.arguments);
-      }
-      if (mixin is ClassBuilder) {
-        scope = mixin.scope.computeMixinScope();
-      }
-    }
-
     Map<Name, Tuple> memberMap = {};
 
+    Scope scope = classBuilder.scope;
+
     for (MemberBuilder memberBuilder in scope.localMembers) {
       for (ClassMember classMember in memberBuilder.localMembers) {
         Tuple tuple = memberMap[classMember.name];
@@ -1737,6 +1741,63 @@
       }
     }
 
+    if (classBuilder.isMixinApplication) {
+      TypeBuilder mixedInTypeBuilder = classBuilder.mixedInTypeBuilder;
+      TypeDeclarationBuilder mixin = mixedInTypeBuilder.declaration;
+      inferMixinApplication();
+      while (mixin.isNamedMixinApplication) {
+        ClassBuilder named = mixin;
+        mixedInTypeBuilder = named.mixedInTypeBuilder;
+        mixin = mixedInTypeBuilder.declaration;
+      }
+      if (mixin is TypeAliasBuilder) {
+        TypeAliasBuilder aliasBuilder = mixin;
+        NamedTypeBuilder namedBuilder = mixedInTypeBuilder;
+        mixin = aliasBuilder.unaliasDeclaration(namedBuilder.arguments);
+      }
+      if (mixin is ClassBuilder) {
+        scope = mixin.scope.computeMixinScope();
+
+        for (MemberBuilder memberBuilder in scope.localMembers) {
+          for (ClassMember classMember in memberBuilder.localMembers) {
+            Tuple tuple = memberMap[classMember.name];
+            if (tuple == null) {
+              memberMap[classMember.name] = new Tuple.mixInMember(classMember);
+            } else {
+              tuple.mixedInMember = classMember;
+            }
+          }
+          for (ClassMember classMember in memberBuilder.localSetters) {
+            Tuple tuple = memberMap[classMember.name];
+            if (tuple == null) {
+              memberMap[classMember.name] = new Tuple.mixInSetter(classMember);
+            } else {
+              tuple.mixedInSetter = classMember;
+            }
+          }
+        }
+
+        for (MemberBuilder memberBuilder in scope.localSetters) {
+          for (ClassMember classMember in memberBuilder.localMembers) {
+            Tuple tuple = memberMap[classMember.name];
+            if (tuple == null) {
+              memberMap[classMember.name] = new Tuple.mixInMember(classMember);
+            } else {
+              tuple.mixedInMember = classMember;
+            }
+          }
+          for (ClassMember classMember in memberBuilder.localSetters) {
+            Tuple tuple = memberMap[classMember.name];
+            if (tuple == null) {
+              memberMap[classMember.name] = new Tuple.mixInSetter(classMember);
+            } else {
+              tuple.mixedInSetter = classMember;
+            }
+          }
+        }
+      }
+    }
+
     List<Supertype> superclasses;
 
     List<Supertype> interfaces;
@@ -1973,8 +2034,16 @@
         }
       }
 
-      ClassMember computeClassMember(ClassMember declaredMember,
-          ClassMember extendedMember, bool forSetter) {
+      ClassMember computeClassMember(
+          ClassMember declaredMember,
+          ClassMember mixedInMember,
+          ClassMember extendedMember,
+          bool forSetter) {
+        if (mixedInMember != null) {
+          // TODO(johnniwinther): Handle members declared in mixin applications
+          // correctly.
+          declaredMember = null;
+        }
         if (declaredMember != null) {
           if (extendedMember != null && !extendedMember.isStatic) {
             if (declaredMember == extendedMember) return declaredMember;
@@ -2021,11 +2090,79 @@
                     concrete.name);
                 hierarchy.registerMemberComputation(result);
               }
-            } else if (classBuilder.isMixinApplication &&
-                declaredMember.classBuilder != classBuilder) {
+            }
+            assert(
+                !(classBuilder.isMixinApplication &&
+                    declaredMember.classBuilder != classBuilder),
+                "Unexpected declared member ${declaredMember} in "
+                "${classBuilder} from foreign class.");
+
+            if (result.name == noSuchMethodName &&
+                !result.isObjectMember(objectClass)) {
+              hasNoSuchMethod = true;
+            }
+            return result;
+          } else {
+            if (declaredMember.isAbstract) {
+              recordAbstractMember(declaredMember);
+            }
+            return declaredMember;
+          }
+        } else if (mixedInMember != null) {
+          if (extendedMember != null && !extendedMember.isStatic) {
+            if (mixedInMember == extendedMember) return mixedInMember;
+            if (mixedInMember.isDuplicate || extendedMember.isDuplicate) {
+              // Don't check overrides involving duplicated members.
+              return mixedInMember;
+            }
+            ClassMember result =
+                checkInheritanceConflict(mixedInMember, extendedMember);
+            if (result != null) return result;
+            assert(
+                mixedInMember.isProperty == extendedMember.isProperty,
+                "Unexpected member combination: "
+                "$mixedInMember vs $extendedMember");
+            result = mixedInMember;
+
+            // [declaredMember] is a method declared in [cls]. This means it
+            // defines the interface of this class regardless if its abstract.
+            if (!mixedInMember.isSynthesized) {
+              registerOverrideDependency(
+                  mixedInMember, extendedMember.abstract);
+              registerOverrideCheck(mixedInMember, extendedMember.abstract);
+            }
+
+            if (mixedInMember.isAbstract) {
+              if (extendedMember.isAbstract) {
+                recordAbstractMember(mixedInMember);
+              } else {
+                if (!classBuilder.isAbstract) {
+                  // The interface of this class is [declaredMember]. But the
+                  // implementation is [extendedMember]. So [extendedMember]
+                  // must implement [declaredMember], unless [cls] is abstract.
+                  registerOverrideCheck(extendedMember, mixedInMember);
+                }
+                ClassMember concrete = extendedMember.concrete;
+                result = new AbstractMemberOverridingImplementation(
+                    classBuilder,
+                    mixedInMember,
+                    concrete,
+                    mixedInMember.isProperty,
+                    forSetter,
+                    shouldModifyKernel,
+                    concrete.isAbstract,
+                    concrete.name);
+                hierarchy.registerMemberComputation(result);
+              }
+            } else {
+              assert(
+                  (classBuilder.isMixinApplication &&
+                      mixedInMember.classBuilder != classBuilder),
+                  "Unexpected mixed in member ${mixedInMember} in "
+                  "${classBuilder} from the current class.");
               result = InheritedImplementationInterfaceConflict.combined(
                   classBuilder,
-                  declaredMember,
+                  mixedInMember,
                   extendedMember,
                   forSetter,
                   shouldModifyKernel,
@@ -2041,10 +2178,10 @@
             }
             return result;
           } else {
-            if (declaredMember.isAbstract) {
-              recordAbstractMember(declaredMember);
+            if (mixedInMember.isAbstract) {
+              recordAbstractMember(mixedInMember);
             }
-            return declaredMember;
+            return mixedInMember;
           }
         } else if (extendedMember != null && !extendedMember.isStatic) {
           if (extendedMember.isAbstract) {
@@ -2235,20 +2372,24 @@
         }
       }
 
-      ClassMember classMember =
-          computeClassMember(tuple.declaredMember, tuple.extendedMember, false);
+      ClassMember classMember = computeClassMember(tuple.declaredMember,
+          tuple.mixedInMember, tuple.extendedMember, false);
       ClassMember interfaceMember =
           computeInterfaceMember(classMember, tuple.implementedMembers, false);
-      ClassMember classSetter =
-          computeClassMember(tuple.declaredSetter, tuple.extendedSetter, true);
+      ClassMember classSetter = computeClassMember(tuple.declaredSetter,
+          tuple.mixedInSetter, tuple.extendedSetter, true);
       ClassMember interfaceSetter =
           computeInterfaceMember(classSetter, tuple.implementedSetters, true);
 
-      if (tuple.declaredMember != null && classSetter != null) {
-        checkMemberVsSetter(tuple.declaredMember, classSetter);
+      if ((tuple.mixedInMember != null || tuple.declaredMember != null) &&
+          classSetter != null) {
+        checkMemberVsSetter(
+            tuple.mixedInMember ?? tuple.declaredMember, classSetter);
       }
-      if (tuple.declaredSetter != null && classMember != null) {
-        checkMemberVsSetter(tuple.declaredSetter, classMember);
+      if ((tuple.mixedInSetter != null || tuple.declaredSetter != null) &&
+          classMember != null) {
+        checkMemberVsSetter(
+            tuple.mixedInSetter ?? tuple.declaredSetter, classMember);
       }
       if (classMember != null && interfaceSetter != null) {
         checkMemberVsSetter(classMember, interfaceSetter);
@@ -2317,8 +2458,10 @@
           }
         }
 
-        registerOverrideDependencies(tuple.declaredMember);
-        registerOverrideDependencies(tuple.declaredSetter);
+        registerOverrideDependencies(
+            tuple.mixedInMember ?? tuple.declaredMember);
+        registerOverrideDependencies(
+            tuple.mixedInSetter ?? tuple.declaredSetter);
       }
     });
 
diff --git a/pkg/front_end/messages.status b/pkg/front_end/messages.status
index 30cf0bb..555f531 100644
--- a/pkg/front_end/messages.status
+++ b/pkg/front_end/messages.status
@@ -281,6 +281,8 @@
 ExtraneousModifier/part_wrapped_script3: Fail
 ExtraneousModifier/part_wrapped_script4: Fail
 ExtraneousModifier/part_wrapped_script5: Fail
+ExtraneousModifier/part_wrapped_script6: Fail # Fails because two errors are given. Only one should be given though.
+ExtraneousModifier/script6: Fail # Fails because two errors are given. Only one should be given though.
 ExtraneousModifier/part_wrapped_script7: Fail
 ExtraneousModifier/part_wrapped_script8: Fail
 ExtraneousModifier/part_wrapped_script9: Fail
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart
new file mode 100644
index 0000000..03e4492
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart
@@ -0,0 +1,21 @@
+// https://github.com/dart-lang/sdk/issues/43855
+// https://github.com/dart-lang/sdk/issues/43856
+// https://github.com/dart-lang/sdk/issues/43857
+
+abstract class C {
+  final abstract int i1;
+  final abstract i2;
+  covariant abstract num i3;
+  covariant abstract var i4;
+  final abstract i5;
+  var abstract i6;
+  C abstract i7;
+}
+
+// This currently give 2 errors which is hardly ideal.
+var abstract foo;
+
+abstract class Bar {
+  // This currently give 2 errors which is hardly ideal.
+  covariant required x;
+}
\ No newline at end of file
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.expect b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.expect
new file mode 100644
index 0000000..12e6b31
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.expect
@@ -0,0 +1,195 @@
+Problems reported:
+
+parser/nnbd/error_recovery/abstract_placement:6:9: The modifier 'abstract' should be before the modifier 'final'.
+  final abstract int i1;
+        ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:7:9: The modifier 'abstract' should be before the modifier 'final'.
+  final abstract i2;
+        ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:8:13: The modifier 'abstract' should be before the modifier 'covariant'.
+  covariant abstract num i3;
+            ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:9:13: The modifier 'abstract' should be before the modifier 'covariant'.
+  covariant abstract var i4;
+            ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:10:9: The modifier 'abstract' should be before the modifier 'final'.
+  final abstract i5;
+        ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:11:7: The modifier 'abstract' should be before the modifier 'var'.
+  var abstract i6;
+      ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:12:5: Expected ';' after this.
+  C abstract i7;
+    ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:12:14: Variables must be declared using the keywords 'const', 'final', 'var' or a type name.
+  C abstract i7;
+             ^^
+
+parser/nnbd/error_recovery/abstract_placement:16:5: The modifier 'abstract' should be before the modifier 'var'.
+var abstract foo;
+    ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:16:5: Can't have modifier 'abstract' here.
+var abstract foo;
+    ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:20:13: The modifier 'required' should be before the modifier 'covariant'.
+  covariant required x;
+            ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:20:13: Can't have modifier 'required' here.
+  covariant required x;
+            ^^^^^^^^
+
+parser/nnbd/error_recovery/abstract_placement:20:22: Variables must be declared using the keywords 'const', 'final', 'var' or a type name.
+  covariant required x;
+                     ^
+
+beginCompilationUnit(abstract)
+  beginMetadataStar(abstract)
+  endMetadataStar(0)
+  beginClassOrNamedMixinApplicationPrelude(abstract)
+    handleIdentifier(C, classOrMixinDeclaration)
+    handleNoTypeVariables({)
+    beginClassDeclaration(abstract, abstract, C)
+      handleNoType(C)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleClassOrMixinImplements(null, 0)
+      handleClassHeader(abstract, class, null)
+      beginClassOrMixinBody(DeclarationKind.Class, {)
+        beginMetadataStar(final)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}], abstract, abstract)
+        beginMember()
+          beginFields({)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(i1)
+            handleType(int, null)
+            handleIdentifier(i1, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(abstract, null, null, null, null, final, 1, final, ;)
+        endMember()
+        beginMetadataStar(final)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}], abstract, abstract)
+        beginMember()
+          beginFields(;)
+            handleNoType(abstract)
+            handleIdentifier(i2, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(abstract, null, null, null, null, final, 1, final, ;)
+        endMember()
+        beginMetadataStar(covariant)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: abstract, string2: covariant}], abstract, abstract)
+        beginMember()
+          beginFields(;)
+            handleIdentifier(num, typeReference)
+            handleNoTypeArguments(i3)
+            handleType(num, null)
+            handleIdentifier(i3, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(abstract, null, null, covariant, null, null, 1, covariant, ;)
+        endMember()
+        beginMetadataStar(covariant)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: abstract, string2: covariant}], abstract, abstract)
+        beginMember()
+          beginFields(;)
+            handleNoType(var)
+            handleIdentifier(i4, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(abstract, null, null, covariant, null, var, 1, covariant, ;)
+        endMember()
+        beginMetadataStar(final)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}], abstract, abstract)
+        beginMember()
+          beginFields(;)
+            handleNoType(abstract)
+            handleIdentifier(i5, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(abstract, null, null, null, null, final, 1, final, ;)
+        endMember()
+        beginMetadataStar(var)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'var'., Try re-ordering the modifiers., {string: abstract, string2: var}], abstract, abstract)
+        beginMember()
+          beginFields(;)
+            handleNoType(abstract)
+            handleIdentifier(i6, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(abstract, null, null, null, null, var, 1, var, ;)
+        endMember()
+        beginMetadataStar(C)
+        endMetadataStar(0)
+        beginMember()
+          beginFields(;)
+            handleIdentifier(C, typeReference)
+            handleNoTypeArguments(abstract)
+            handleType(C, null)
+            handleIdentifier(abstract, fieldDeclaration)
+            handleNoFieldInitializer(i7)
+            handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], abstract, abstract)
+          endClassFields(null, null, null, null, null, null, 1, C, ;)
+        endMember()
+        beginMetadataStar(i7)
+        endMetadataStar(0)
+        beginMember()
+          beginFields(;)
+            handleRecoverableError(MissingConstFinalVarOrType, i7, i7)
+            handleNoType(;)
+            handleIdentifier(i7, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(null, null, null, null, null, null, 1, i7, ;)
+        endMember()
+      endClassOrMixinBody(DeclarationKind.Class, 8, {, })
+    endClassDeclaration(abstract, })
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'var'., Try re-ordering the modifiers., {string: abstract, string2: var}], abstract, abstract)
+    handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'abstract' here., Try removing 'abstract'., {token: abstract}], abstract, abstract)
+    beginFields(})
+      handleNoType(abstract)
+      handleIdentifier(foo, topLevelVariableDeclaration)
+      handleNoFieldInitializer(;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(abstract)
+  beginMetadataStar(abstract)
+  endMetadataStar(0)
+  beginClassOrNamedMixinApplicationPrelude(abstract)
+    handleIdentifier(Bar, classOrMixinDeclaration)
+    handleNoTypeVariables({)
+    beginClassDeclaration(abstract, abstract, Bar)
+      handleNoType(Bar)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleClassOrMixinImplements(null, 0)
+      handleClassHeader(abstract, class, null)
+      beginClassOrMixinBody(DeclarationKind.Class, {)
+        beginMetadataStar(covariant)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'required' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: required, string2: covariant}], required, required)
+        handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'required' here., Try removing 'required'., {token: required}], required, required)
+        beginMember()
+          beginFields({)
+            handleRecoverableError(MissingConstFinalVarOrType, x, x)
+            handleNoType(required)
+            handleIdentifier(x, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(null, null, null, covariant, null, null, 1, covariant, ;)
+        endMember()
+      endClassOrMixinBody(DeclarationKind.Class, 1, {, })
+    endClassDeclaration(abstract, })
+  endTopLevelDeclaration()
+endCompilationUnit(3, )
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.intertwined.expect
new file mode 100644
index 0000000..0ce64ff
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.intertwined.expect
@@ -0,0 +1,250 @@
+parseUnit(abstract)
+  skipErrorTokens(abstract)
+  listener: beginCompilationUnit(abstract)
+  syntheticPreviousToken(abstract)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(abstract)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext')
+      parseClassDeclarationModifiers(, class)
+        parseTopLevelKeywordModifiers(abstract, class)
+      parseClassOrNamedMixinApplication(abstract, class)
+        listener: beginClassOrNamedMixinApplicationPrelude(abstract)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(C, classOrMixinDeclaration)
+        listener: handleNoTypeVariables({)
+        listener: beginClassDeclaration(abstract, abstract, C)
+        parseClass(C, abstract, class, C)
+          parseClassHeaderOpt(C, abstract, class)
+            parseClassExtendsOpt(C)
+              listener: handleNoType(C)
+              listener: handleClassExtends(null, 1)
+            parseWithClauseOpt(C)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinImplementsOpt(C)
+              listener: handleClassOrMixinImplements(null, 0)
+            listener: handleClassHeader(abstract, class, null)
+          parseClassOrMixinOrExtensionBody(C, DeclarationKind.Class, C)
+            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
+            notEofOrValue(}, final)
+            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, C)
+              parseMetadataStar({)
+                listener: beginMetadataStar(final)
+                listener: endMetadataStar(0)
+              reportRecoverableError(abstract, Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}], abstract, abstract)
+              listener: beginMember()
+              parseFields({, abstract, null, null, null, null, final, abstract, Instance of 'SimpleType', i1, DeclarationKind.Class, C, false)
+                listener: beginFields({)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(i1)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
+                  listener: handleIdentifier(i1, fieldDeclaration)
+                parseFieldInitializerOpt(i1, i1, null, abstract, null, final, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(abstract, null, null, null, null, final, 1, final, ;)
+              listener: endMember()
+            notEofOrValue(}, final)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(final)
+                listener: endMetadataStar(0)
+              reportRecoverableError(abstract, Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}], abstract, abstract)
+              listener: beginMember()
+              parseFields(;, abstract, null, null, null, null, final, abstract, Instance of 'NoType', i2, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleNoType(abstract)
+                ensureIdentifierPotentiallyRecovered(abstract, fieldDeclaration, false)
+                  listener: handleIdentifier(i2, fieldDeclaration)
+                parseFieldInitializerOpt(i2, i2, null, abstract, null, final, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(abstract, null, null, null, null, final, 1, final, ;)
+              listener: endMember()
+            notEofOrValue(}, covariant)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(covariant)
+                listener: endMetadataStar(0)
+              reportRecoverableError(abstract, Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: abstract, string2: covariant}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: abstract, string2: covariant}], abstract, abstract)
+              listener: beginMember()
+              parseFields(;, abstract, null, null, covariant, null, null, abstract, Instance of 'SimpleType', i3, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleIdentifier(num, typeReference)
+                listener: handleNoTypeArguments(i3)
+                listener: handleType(num, null)
+                ensureIdentifierPotentiallyRecovered(num, fieldDeclaration, false)
+                  listener: handleIdentifier(i3, fieldDeclaration)
+                parseFieldInitializerOpt(i3, i3, null, abstract, null, null, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(abstract, null, null, covariant, null, null, 1, covariant, ;)
+              listener: endMember()
+            notEofOrValue(}, covariant)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(covariant)
+                listener: endMetadataStar(0)
+              reportRecoverableError(abstract, Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: abstract, string2: covariant}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: abstract, string2: covariant}], abstract, abstract)
+              listener: beginMember()
+              parseFields(;, abstract, null, null, covariant, null, var, var, Instance of 'NoType', i4, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleNoType(var)
+                ensureIdentifierPotentiallyRecovered(var, fieldDeclaration, false)
+                  listener: handleIdentifier(i4, fieldDeclaration)
+                parseFieldInitializerOpt(i4, i4, null, abstract, null, var, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(abstract, null, null, covariant, null, var, 1, covariant, ;)
+              listener: endMember()
+            notEofOrValue(}, final)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(final)
+                listener: endMetadataStar(0)
+              reportRecoverableError(abstract, Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'final'., Try re-ordering the modifiers., {string: abstract, string2: final}], abstract, abstract)
+              listener: beginMember()
+              parseFields(;, abstract, null, null, null, null, final, abstract, Instance of 'NoType', i5, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleNoType(abstract)
+                ensureIdentifierPotentiallyRecovered(abstract, fieldDeclaration, false)
+                  listener: handleIdentifier(i5, fieldDeclaration)
+                parseFieldInitializerOpt(i5, i5, null, abstract, null, final, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(abstract, null, null, null, null, final, 1, final, ;)
+              listener: endMember()
+            notEofOrValue(}, var)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(var)
+                listener: endMetadataStar(0)
+              reportRecoverableError(abstract, Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'var'., Try re-ordering the modifiers., {string: abstract, string2: var}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'var'., Try re-ordering the modifiers., {string: abstract, string2: var}], abstract, abstract)
+              listener: beginMember()
+              parseFields(;, abstract, null, null, null, null, var, abstract, Instance of 'NoType', i6, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleNoType(abstract)
+                ensureIdentifierPotentiallyRecovered(abstract, fieldDeclaration, false)
+                  listener: handleIdentifier(i6, fieldDeclaration)
+                parseFieldInitializerOpt(i6, i6, null, abstract, null, var, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(abstract, null, null, null, null, var, 1, var, ;)
+              listener: endMember()
+            notEofOrValue(}, C)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(C)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseFields(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', abstract, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleIdentifier(C, typeReference)
+                listener: handleNoTypeArguments(abstract)
+                listener: handleType(C, null)
+                ensureIdentifierPotentiallyRecovered(C, fieldDeclaration, false)
+                  listener: handleIdentifier(abstract, fieldDeclaration)
+                parseFieldInitializerOpt(abstract, abstract, null, null, null, null, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(i7)
+                ensureSemicolon(abstract)
+                  reportRecoverableError(abstract, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], abstract, abstract)
+                  rewriter()
+                listener: endClassFields(null, null, null, null, null, null, 1, C, ;)
+              listener: endMember()
+            notEofOrValue(}, i7)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(i7)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(;)
+              parseFields(;, null, null, null, null, null, null, ;, Instance of 'NoType', i7, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                reportRecoverableError(i7, MissingConstFinalVarOrType)
+                  listener: handleRecoverableError(MissingConstFinalVarOrType, i7, i7)
+                listener: handleNoType(;)
+                ensureIdentifierPotentiallyRecovered(;, fieldDeclaration, false)
+                  listener: handleIdentifier(i7, fieldDeclaration)
+                parseFieldInitializerOpt(i7, i7, null, null, null, null, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(null, null, null, null, null, null, 1, i7, ;)
+              listener: endMember()
+            notEofOrValue(}, })
+            listener: endClassOrMixinBody(DeclarationKind.Class, 8, {, })
+          listener: endClassDeclaration(abstract, })
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
+    parseMetadataStar(})
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(})
+      listener: beginTopLevelMember(var)
+      reportRecoverableError(abstract, Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'var'., Try re-ordering the modifiers., {string: abstract, string2: var}])
+        listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'abstract' should be before the modifier 'var'., Try re-ordering the modifiers., {string: abstract, string2: var}], abstract, abstract)
+      reportRecoverableErrorWithToken(abstract, Instance of 'Template<(Token) => Message>')
+        listener: handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'abstract' here., Try removing 'abstract'., {token: abstract}], abstract, abstract)
+      parseFields(}, null, null, null, null, null, var, abstract, Instance of 'NoType', foo, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(})
+        listener: handleNoType(abstract)
+        ensureIdentifierPotentiallyRecovered(abstract, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(foo, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(foo, foo, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: handleNoFieldInitializer(;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(abstract)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(abstract)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext')
+      parseClassDeclarationModifiers(;, class)
+        parseTopLevelKeywordModifiers(abstract, class)
+      parseClassOrNamedMixinApplication(abstract, class)
+        listener: beginClassOrNamedMixinApplicationPrelude(abstract)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(Bar, classOrMixinDeclaration)
+        listener: handleNoTypeVariables({)
+        listener: beginClassDeclaration(abstract, abstract, Bar)
+        parseClass(Bar, abstract, class, Bar)
+          parseClassHeaderOpt(Bar, abstract, class)
+            parseClassExtendsOpt(Bar)
+              listener: handleNoType(Bar)
+              listener: handleClassExtends(null, 1)
+            parseWithClauseOpt(Bar)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinImplementsOpt(Bar)
+              listener: handleClassOrMixinImplements(null, 0)
+            listener: handleClassHeader(abstract, class, null)
+          parseClassOrMixinOrExtensionBody(Bar, DeclarationKind.Class, Bar)
+            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
+            notEofOrValue(}, covariant)
+            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Bar)
+              parseMetadataStar({)
+                listener: beginMetadataStar(covariant)
+                listener: endMetadataStar(0)
+              reportRecoverableError(required, Message[ModifierOutOfOrder, The modifier 'required' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: required, string2: covariant}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'required' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: required, string2: covariant}], required, required)
+              reportRecoverableErrorWithToken(required, Instance of 'Template<(Token) => Message>')
+                listener: handleRecoverableError(Message[ExtraneousModifier, Can't have modifier 'required' here., Try removing 'required'., {token: required}], required, required)
+              listener: beginMember()
+              isReservedKeyword(;)
+              parseFields({, null, null, null, covariant, null, null, required, Instance of 'NoType', x, DeclarationKind.Class, Bar, false)
+                listener: beginFields({)
+                reportRecoverableError(x, MissingConstFinalVarOrType)
+                  listener: handleRecoverableError(MissingConstFinalVarOrType, x, x)
+                listener: handleNoType(required)
+                ensureIdentifierPotentiallyRecovered(required, fieldDeclaration, false)
+                  listener: handleIdentifier(x, fieldDeclaration)
+                parseFieldInitializerOpt(x, x, null, null, null, null, DeclarationKind.Class, Bar)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(null, null, null, covariant, null, null, 1, covariant, ;)
+              listener: endMember()
+            notEofOrValue(}, })
+            listener: endClassOrMixinBody(DeclarationKind.Class, 1, {, })
+          listener: endClassDeclaration(abstract, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(abstract)
+  listener: endCompilationUnit(3, )
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.parser.expect b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.parser.expect
new file mode 100644
index 0000000..3a6fad5
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.parser.expect
@@ -0,0 +1,37 @@
+NOTICE: Stream was rewritten by parser!
+
+abstract class C {
+final abstract int i1;
+final abstract i2;
+covariant abstract num i3;
+covariant abstract var i4;
+final abstract i5;
+var abstract i6;
+C abstract ;i7;
+}
+
+
+var abstract foo;
+
+abstract class Bar {
+
+covariant required x;
+}
+
+abstract[KeywordToken] class[KeywordToken] C[StringToken] {[BeginToken]
+final[KeywordToken] abstract[KeywordToken] int[StringToken] i1[StringToken];[SimpleToken]
+final[KeywordToken] abstract[KeywordToken] i2[StringToken];[SimpleToken]
+covariant[KeywordToken] abstract[KeywordToken] num[StringToken] i3[StringToken];[SimpleToken]
+covariant[KeywordToken] abstract[KeywordToken] var[KeywordToken] i4[StringToken];[SimpleToken]
+final[KeywordToken] abstract[KeywordToken] i5[StringToken];[SimpleToken]
+var[KeywordToken] abstract[KeywordToken] i6[StringToken];[SimpleToken]
+C[StringToken] abstract[KeywordToken] ;[SyntheticToken]i7[StringToken];[SimpleToken]
+}[SimpleToken]
+
+
+var[KeywordToken] abstract[KeywordToken] foo[StringToken];[SimpleToken]
+
+abstract[KeywordToken] class[KeywordToken] Bar[StringToken] {[BeginToken]
+
+covariant[KeywordToken] required[KeywordToken] x[StringToken];[SimpleToken]
+}[SimpleToken][SimpleToken]
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.scanner.expect b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.scanner.expect
new file mode 100644
index 0000000..602f1128
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/abstract_placement.dart.scanner.expect
@@ -0,0 +1,35 @@
+abstract class C {
+final abstract int i1;
+final abstract i2;
+covariant abstract num i3;
+covariant abstract var i4;
+final abstract i5;
+var abstract i6;
+C abstract i7;
+}
+
+
+var abstract foo;
+
+abstract class Bar {
+
+covariant required x;
+}
+
+abstract[KeywordToken] class[KeywordToken] C[StringToken] {[BeginToken]
+final[KeywordToken] abstract[KeywordToken] int[StringToken] i1[StringToken];[SimpleToken]
+final[KeywordToken] abstract[KeywordToken] i2[StringToken];[SimpleToken]
+covariant[KeywordToken] abstract[KeywordToken] num[StringToken] i3[StringToken];[SimpleToken]
+covariant[KeywordToken] abstract[KeywordToken] var[KeywordToken] i4[StringToken];[SimpleToken]
+final[KeywordToken] abstract[KeywordToken] i5[StringToken];[SimpleToken]
+var[KeywordToken] abstract[KeywordToken] i6[StringToken];[SimpleToken]
+C[StringToken] abstract[KeywordToken] i7[StringToken];[SimpleToken]
+}[SimpleToken]
+
+
+var[KeywordToken] abstract[KeywordToken] foo[StringToken];[SimpleToken]
+
+abstract[KeywordToken] class[KeywordToken] Bar[StringToken] {[BeginToken]
+
+covariant[KeywordToken] required[KeywordToken] x[StringToken];[SimpleToken]
+}[SimpleToken][SimpleToken]
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart
new file mode 100644
index 0000000..b1cc0ba
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart
@@ -0,0 +1,15 @@
+// https://github.com/dart-lang/sdk/issues/43851
+// https://github.com/dart-lang/sdk/issues/43858
+// https://github.com/dart-lang/sdk/issues/43859
+
+final external int i1;
+var external i2;
+
+class C {
+  covariant external num i3;
+  final external int i4;
+  final external i5;
+  static external final i6;
+  static final external i7;
+  final static external i8;
+}
\ No newline at end of file
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.expect b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.expect
new file mode 100644
index 0000000..b26632d
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.expect
@@ -0,0 +1,142 @@
+Problems reported:
+
+parser/nnbd/error_recovery/external_placement:5:7: The modifier 'external' should be before the modifier 'final'.
+final external int i1;
+      ^^^^^^^^
+
+parser/nnbd/error_recovery/external_placement:6:5: The modifier 'external' should be before the modifier 'var'.
+var external i2;
+    ^^^^^^^^
+
+parser/nnbd/error_recovery/external_placement:9:13: The modifier 'external' should be before the modifier 'covariant'.
+  covariant external num i3;
+            ^^^^^^^^
+
+parser/nnbd/error_recovery/external_placement:10:9: The modifier 'external' should be before the modifier 'final'.
+  final external int i4;
+        ^^^^^^^^
+
+parser/nnbd/error_recovery/external_placement:11:9: The modifier 'external' should be before the modifier 'final'.
+  final external i5;
+        ^^^^^^^^
+
+parser/nnbd/error_recovery/external_placement:12:10: The modifier 'external' should be before the modifier 'static'.
+  static external final i6;
+         ^^^^^^^^
+
+parser/nnbd/error_recovery/external_placement:13:16: The modifier 'external' should be before the modifier 'static'.
+  static final external i7;
+               ^^^^^^^^
+
+parser/nnbd/error_recovery/external_placement:14:9: The modifier 'static' should be before the modifier 'final'.
+  final static external i8;
+        ^^^^^^
+
+parser/nnbd/error_recovery/external_placement:14:16: The modifier 'external' should be before the modifier 'static'.
+  final static external i8;
+               ^^^^^^^^
+
+beginCompilationUnit(final)
+  beginMetadataStar(final)
+  endMetadataStar(0)
+  beginTopLevelMember(final)
+    handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}], external, external)
+    beginFields()
+      handleIdentifier(int, typeReference)
+      handleNoTypeArguments(i1)
+      handleType(int, null)
+      handleIdentifier(i1, topLevelVariableDeclaration)
+      handleNoFieldInitializer(;)
+    endTopLevelFields(external, null, null, null, final, 1, final, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'var'., Try re-ordering the modifiers., {string: external, string2: var}], external, external)
+    beginFields(;)
+      handleNoType(external)
+      handleIdentifier(i2, topLevelVariableDeclaration)
+      handleNoFieldInitializer(;)
+    endTopLevelFields(external, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(class)
+  beginMetadataStar(class)
+  endMetadataStar(0)
+  beginClassOrNamedMixinApplicationPrelude(class)
+    handleIdentifier(C, classOrMixinDeclaration)
+    handleNoTypeVariables({)
+    beginClassDeclaration(class, null, C)
+      handleNoType(C)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleClassOrMixinImplements(null, 0)
+      handleClassHeader(class, class, null)
+      beginClassOrMixinBody(DeclarationKind.Class, {)
+        beginMetadataStar(covariant)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: external, string2: covariant}], external, external)
+        beginMember()
+          beginFields({)
+            handleIdentifier(num, typeReference)
+            handleNoTypeArguments(i3)
+            handleType(num, null)
+            handleIdentifier(i3, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(null, external, null, covariant, null, null, 1, covariant, ;)
+        endMember()
+        beginMetadataStar(final)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}], external, external)
+        beginMember()
+          beginFields(;)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments(i4)
+            handleType(int, null)
+            handleIdentifier(i4, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(null, external, null, null, null, final, 1, final, ;)
+        endMember()
+        beginMetadataStar(final)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}], external, external)
+        beginMember()
+          beginFields(;)
+            handleNoType(external)
+            handleIdentifier(i5, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(null, external, null, null, null, final, 1, final, ;)
+        endMember()
+        beginMetadataStar(static)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}], external, external)
+        beginMember()
+          beginFields(;)
+            handleNoType(final)
+            handleIdentifier(i6, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(null, external, static, null, null, final, 1, static, ;)
+        endMember()
+        beginMetadataStar(static)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}], external, external)
+        beginMember()
+          beginFields(;)
+            handleNoType(external)
+            handleIdentifier(i7, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(null, external, static, null, null, final, 1, static, ;)
+        endMember()
+        beginMetadataStar(final)
+        endMetadataStar(0)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'static' should be before the modifier 'final'., Try re-ordering the modifiers., {string: static, string2: final}], static, static)
+        handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}], external, external)
+        beginMember()
+          beginFields(;)
+            handleNoType(external)
+            handleIdentifier(i8, fieldDeclaration)
+            handleNoFieldInitializer(;)
+          endClassFields(null, external, static, null, null, final, 1, final, ;)
+        endMember()
+      endClassOrMixinBody(DeclarationKind.Class, 6, {, })
+    endClassDeclaration(class, })
+  endTopLevelDeclaration()
+endCompilationUnit(3, )
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.intertwined.expect
new file mode 100644
index 0000000..ec0650f
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.intertwined.expect
@@ -0,0 +1,178 @@
+parseUnit(final)
+  skipErrorTokens(final)
+  listener: beginCompilationUnit(final)
+  syntheticPreviousToken(final)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(final)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl()
+      listener: beginTopLevelMember(final)
+      reportRecoverableError(external, Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}])
+        listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}], external, external)
+      parseFields(, null, external, null, null, null, final, external, Instance of 'SimpleType', i1, DeclarationKind.TopLevel, null, false)
+        listener: beginFields()
+        listener: handleIdentifier(int, typeReference)
+        listener: handleNoTypeArguments(i1)
+        listener: handleType(int, null)
+        ensureIdentifierPotentiallyRecovered(int, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(i1, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(i1, i1, null, null, external, final, DeclarationKind.TopLevel, null)
+          listener: handleNoFieldInitializer(;)
+        listener: endTopLevelFields(external, null, null, null, final, 1, final, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      reportRecoverableError(external, Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'var'., Try re-ordering the modifiers., {string: external, string2: var}])
+        listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'var'., Try re-ordering the modifiers., {string: external, string2: var}], external, external)
+      parseFields(;, null, external, null, null, null, var, external, Instance of 'NoType', i2, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(external)
+        ensureIdentifierPotentiallyRecovered(external, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(i2, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(i2, i2, null, null, external, var, DeclarationKind.TopLevel, null)
+          listener: handleNoFieldInitializer(;)
+        listener: endTopLevelFields(external, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(class)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(class)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext')
+      parseClassDeclarationModifiers(;, class)
+      parseClassOrNamedMixinApplication(null, class)
+        listener: beginClassOrNamedMixinApplicationPrelude(class)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(C, classOrMixinDeclaration)
+        listener: handleNoTypeVariables({)
+        listener: beginClassDeclaration(class, null, C)
+        parseClass(C, class, class, C)
+          parseClassHeaderOpt(C, class, class)
+            parseClassExtendsOpt(C)
+              listener: handleNoType(C)
+              listener: handleClassExtends(null, 1)
+            parseWithClauseOpt(C)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinImplementsOpt(C)
+              listener: handleClassOrMixinImplements(null, 0)
+            listener: handleClassHeader(class, class, null)
+          parseClassOrMixinOrExtensionBody(C, DeclarationKind.Class, C)
+            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
+            notEofOrValue(}, covariant)
+            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, C)
+              parseMetadataStar({)
+                listener: beginMetadataStar(covariant)
+                listener: endMetadataStar(0)
+              reportRecoverableError(external, Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: external, string2: covariant}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'covariant'., Try re-ordering the modifiers., {string: external, string2: covariant}], external, external)
+              listener: beginMember()
+              parseFields({, null, external, null, covariant, null, null, external, Instance of 'SimpleType', i3, DeclarationKind.Class, C, false)
+                listener: beginFields({)
+                listener: handleIdentifier(num, typeReference)
+                listener: handleNoTypeArguments(i3)
+                listener: handleType(num, null)
+                ensureIdentifierPotentiallyRecovered(num, fieldDeclaration, false)
+                  listener: handleIdentifier(i3, fieldDeclaration)
+                parseFieldInitializerOpt(i3, i3, null, null, external, null, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(null, external, null, covariant, null, null, 1, covariant, ;)
+              listener: endMember()
+            notEofOrValue(}, final)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(final)
+                listener: endMetadataStar(0)
+              reportRecoverableError(external, Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}], external, external)
+              listener: beginMember()
+              parseFields(;, null, external, null, null, null, final, external, Instance of 'SimpleType', i4, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleIdentifier(int, typeReference)
+                listener: handleNoTypeArguments(i4)
+                listener: handleType(int, null)
+                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
+                  listener: handleIdentifier(i4, fieldDeclaration)
+                parseFieldInitializerOpt(i4, i4, null, null, external, final, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(null, external, null, null, null, final, 1, final, ;)
+              listener: endMember()
+            notEofOrValue(}, final)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(final)
+                listener: endMetadataStar(0)
+              reportRecoverableError(external, Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'final'., Try re-ordering the modifiers., {string: external, string2: final}], external, external)
+              listener: beginMember()
+              parseFields(;, null, external, null, null, null, final, external, Instance of 'NoType', i5, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleNoType(external)
+                ensureIdentifierPotentiallyRecovered(external, fieldDeclaration, false)
+                  listener: handleIdentifier(i5, fieldDeclaration)
+                parseFieldInitializerOpt(i5, i5, null, null, external, final, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(null, external, null, null, null, final, 1, final, ;)
+              listener: endMember()
+            notEofOrValue(}, static)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(static)
+                listener: endMetadataStar(0)
+              reportRecoverableError(external, Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}], external, external)
+              listener: beginMember()
+              parseFields(;, null, external, static, null, null, final, final, Instance of 'NoType', i6, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleNoType(final)
+                ensureIdentifierPotentiallyRecovered(final, fieldDeclaration, false)
+                  listener: handleIdentifier(i6, fieldDeclaration)
+                parseFieldInitializerOpt(i6, i6, null, null, external, final, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(null, external, static, null, null, final, 1, static, ;)
+              listener: endMember()
+            notEofOrValue(}, static)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(static)
+                listener: endMetadataStar(0)
+              reportRecoverableError(external, Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}], external, external)
+              listener: beginMember()
+              parseFields(;, null, external, static, null, null, final, external, Instance of 'NoType', i7, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleNoType(external)
+                ensureIdentifierPotentiallyRecovered(external, fieldDeclaration, false)
+                  listener: handleIdentifier(i7, fieldDeclaration)
+                parseFieldInitializerOpt(i7, i7, null, null, external, final, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(null, external, static, null, null, final, 1, static, ;)
+              listener: endMember()
+            notEofOrValue(}, final)
+            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(final)
+                listener: endMetadataStar(0)
+              reportRecoverableError(static, Message[ModifierOutOfOrder, The modifier 'static' should be before the modifier 'final'., Try re-ordering the modifiers., {string: static, string2: final}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'static' should be before the modifier 'final'., Try re-ordering the modifiers., {string: static, string2: final}], static, static)
+              reportRecoverableError(external, Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}])
+                listener: handleRecoverableError(Message[ModifierOutOfOrder, The modifier 'external' should be before the modifier 'static'., Try re-ordering the modifiers., {string: external, string2: static}], external, external)
+              listener: beginMember()
+              parseFields(;, null, external, static, null, null, final, external, Instance of 'NoType', i8, DeclarationKind.Class, C, false)
+                listener: beginFields(;)
+                listener: handleNoType(external)
+                ensureIdentifierPotentiallyRecovered(external, fieldDeclaration, false)
+                  listener: handleIdentifier(i8, fieldDeclaration)
+                parseFieldInitializerOpt(i8, i8, null, null, external, final, DeclarationKind.Class, C)
+                  listener: handleNoFieldInitializer(;)
+                listener: endClassFields(null, external, static, null, null, final, 1, final, ;)
+              listener: endMember()
+            notEofOrValue(}, })
+            listener: endClassOrMixinBody(DeclarationKind.Class, 6, {, })
+          listener: endClassDeclaration(class, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(final)
+  listener: endCompilationUnit(3, )
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.parser.expect b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.parser.expect
new file mode 100644
index 0000000..2b628f5
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.parser.expect
@@ -0,0 +1,23 @@
+final external int i1;
+var external i2;
+
+class C {
+covariant external num i3;
+final external int i4;
+final external i5;
+static external final i6;
+static final external i7;
+final static external i8;
+}
+
+final[KeywordToken] external[KeywordToken] int[StringToken] i1[StringToken];[SimpleToken]
+var[KeywordToken] external[KeywordToken] i2[StringToken];[SimpleToken]
+
+class[KeywordToken] C[StringToken] {[BeginToken]
+covariant[KeywordToken] external[KeywordToken] num[StringToken] i3[StringToken];[SimpleToken]
+final[KeywordToken] external[KeywordToken] int[StringToken] i4[StringToken];[SimpleToken]
+final[KeywordToken] external[KeywordToken] i5[StringToken];[SimpleToken]
+static[KeywordToken] external[KeywordToken] final[KeywordToken] i6[StringToken];[SimpleToken]
+static[KeywordToken] final[KeywordToken] external[KeywordToken] i7[StringToken];[SimpleToken]
+final[KeywordToken] static[KeywordToken] external[KeywordToken] i8[StringToken];[SimpleToken]
+}[SimpleToken][SimpleToken]
diff --git a/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.scanner.expect b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.scanner.expect
new file mode 100644
index 0000000..2b628f5
--- /dev/null
+++ b/pkg/front_end/parser_testcases/nnbd/error_recovery/external_placement.dart.scanner.expect
@@ -0,0 +1,23 @@
+final external int i1;
+var external i2;
+
+class C {
+covariant external num i3;
+final external int i4;
+final external i5;
+static external final i6;
+static final external i7;
+final static external i8;
+}
+
+final[KeywordToken] external[KeywordToken] int[StringToken] i1[StringToken];[SimpleToken]
+var[KeywordToken] external[KeywordToken] i2[StringToken];[SimpleToken]
+
+class[KeywordToken] C[StringToken] {[BeginToken]
+covariant[KeywordToken] external[KeywordToken] num[StringToken] i3[StringToken];[SimpleToken]
+final[KeywordToken] external[KeywordToken] int[StringToken] i4[StringToken];[SimpleToken]
+final[KeywordToken] external[KeywordToken] i5[StringToken];[SimpleToken]
+static[KeywordToken] external[KeywordToken] final[KeywordToken] i6[StringToken];[SimpleToken]
+static[KeywordToken] final[KeywordToken] external[KeywordToken] i7[StringToken];[SimpleToken]
+final[KeywordToken] static[KeywordToken] external[KeywordToken] i8[StringToken];[SimpleToken]
+}[SimpleToken][SimpleToken]
diff --git a/pkg/front_end/test/spell_checking_list_tests.txt b/pkg/front_end/test/spell_checking_list_tests.txt
index 8022b92..d50f907 100644
--- a/pkg/front_end/test/spell_checking_list_tests.txt
+++ b/pkg/front_end/test/spell_checking_list_tests.txt
@@ -310,6 +310,7 @@
 gulp
 gunk
 hackish
+hardly
 helper2
 hest
 heuristics
@@ -326,6 +327,7 @@
 hurray
 i'm
 ia
+ideal
 idle
 ikg
 illustrate
diff --git a/sdk/lib/core/set.dart b/sdk/lib/core/set.dart
index ae1e381..6f47e07 100644
--- a/sdk/lib/core/set.dart
+++ b/sdk/lib/core/set.dart
@@ -253,7 +253,8 @@
    */
   void clear();
 
-  /* Creates a [Set] with the same elements and behavior as this `Set`.
+  /**
+   * Creates a [Set] with the same elements and behavior as this `Set`.
    *
    * The returned set behaves the same as this set
    * with regard to adding and removing elements.
diff --git a/tools/VERSION b/tools/VERSION
index 4c85e50..09a704e 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 11
 PATCH 0
-PRERELEASE 249
+PRERELEASE 250
 PRERELEASE_PATCH 0
\ No newline at end of file