diff --git a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
index 14682ea..204bd51 100644
--- a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
@@ -1434,6 +1434,17 @@
 }
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeConstEvalFailedAssertionWithNonStringMessage =
+    messageConstEvalFailedAssertionWithNonStringMessage;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageConstEvalFailedAssertionWithNonStringMessage =
+    const MessageCode("ConstEvalFailedAssertionWithNonStringMessage",
+        analyzerCodes: <String>["CONST_EVAL_THROWS_EXCEPTION"],
+        problemMessage:
+            r"""This assertion failed with a non-String message.""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(String nameOKEmpty)>
     templateConstEvalGetterNotFound =
     const Template<Message Function(String nameOKEmpty)>(
diff --git a/pkg/front_end/lib/src/fasta/builder/class_builder.dart b/pkg/front_end/lib/src/fasta/builder/class_builder.dart
index eb36433..e3f96b9 100644
--- a/pkg/front_end/lib/src/fasta/builder/class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/class_builder.dart
@@ -466,11 +466,11 @@
 
   @override
   void forEachDeclaredConstructor(
-      void Function(String name, ConstructorBuilder constructorBuilder)
+      void Function(String name, SourceConstructorBuilder constructorBuilder)
           callback) {
     Set<String> visitedConstructorNames = {};
     void callbackFilteringFieldBuilders(String name, Builder builder) {
-      if (builder is ConstructorBuilder &&
+      if (builder is SourceConstructorBuilder &&
           visitedConstructorNames.add(builder.name)) {
         callback(name, builder);
       }
diff --git a/pkg/front_end/lib/src/fasta/builder/constructor_builder.dart b/pkg/front_end/lib/src/fasta/builder/constructor_builder.dart
index f53cbfa..5426ed8 100644
--- a/pkg/front_end/lib/src/fasta/builder/constructor_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/constructor_builder.dart
@@ -50,45 +50,8 @@
 import 'type_variable_builder.dart';
 
 abstract class ConstructorBuilder implements FunctionBuilder {
-  abstract Token? beginInitializers;
-
-  ConstructorBuilder? get actualOrigin;
-
-  ConstructorBuilder? get patchForTesting;
-
-  Constructor get actualConstructor;
-
-  @override
-  ConstructorBuilder get origin;
-
-  bool get isRedirectingGenerativeConstructor;
-
   /// The [Constructor] built by this builder.
   Constructor get constructor;
-
-  void injectInvalidInitializer(Message message, int charOffset, int length,
-      ExpressionGeneratorHelper helper);
-
-  void addInitializer(Initializer initializer, ExpressionGeneratorHelper helper,
-      {required InitializerInferenceResult? inferenceResult});
-
-  void prepareInitializers();
-
-  /// Infers the types of any untyped initializing formals.
-  void inferFormalTypes();
-
-  /// Registers field as being initialized by this constructor.
-  ///
-  /// The field can be initialized either via an initializing formal or via an
-  /// entry in the constructor initializer list.
-  void registerInitializedField(FieldBuilder fieldBuilder);
-
-  /// Returns the fields registered as initialized by this constructor.
-  ///
-  /// Returns the set of fields previously registered via
-  /// [registerInitializedField] and passes on the ownership of the collection
-  /// to the caller.
-  Set<FieldBuilder>? takeInitializedFields();
 }
 
 class SourceConstructorBuilder extends FunctionBuilderImpl
@@ -106,13 +69,10 @@
 
   RedirectingInitializer? redirectingInitializer;
 
-  @override
   Token? beginInitializers;
 
-  @override
-  ConstructorBuilder? actualOrigin;
+  SourceConstructorBuilder? actualOrigin;
 
-  @override
   Constructor get actualConstructor => _constructor;
 
   SourceConstructorBuilder(
@@ -172,9 +132,8 @@
   Iterable<Member> get exportedMembers => [constructor];
 
   @override
-  ConstructorBuilder get origin => actualOrigin ?? this;
+  SourceConstructorBuilder get origin => actualOrigin ?? this;
 
-  @override
   ConstructorBuilder? get patchForTesting =>
       dataForTesting?.patchForTesting as ConstructorBuilder?;
 
@@ -248,7 +207,7 @@
     return _constructor;
   }
 
-  @override
+  /// Infers the types of any untyped initializing formals.
   void inferFormalTypes() {
     if (formals != null) {
       for (FormalParameterBuilder formal in formals!) {
@@ -315,7 +274,6 @@
   @override
   Member get member => constructor;
 
-  @override
   void injectInvalidInitializer(Message message, int charOffset, int length,
       ExpressionGeneratorHelper helper) {
     List<Initializer> initializers = _constructor.initializers;
@@ -328,7 +286,6 @@
     initializers.add(lastInitializer);
   }
 
-  @override
   void addInitializer(Initializer initializer, ExpressionGeneratorHelper helper,
       {required InitializerInferenceResult? inferenceResult}) {
     List<Initializer> initializers = _constructor.initializers;
@@ -457,7 +414,6 @@
     }
   }
 
-  @override
   void prepareInitializers() {
     // For const constructors we parse initializers already at the outlining
     // stage, there is no easy way to make body building stage skip initializer
@@ -482,12 +438,19 @@
   List<ClassMember> get localSetters =>
       throw new UnsupportedError('${runtimeType}.localSetters');
 
-  @override
+  /// Registers field as being initialized by this constructor.
+  ///
+  /// The field can be initialized either via an initializing formal or via an
+  /// entry in the constructor initializer list.
   void registerInitializedField(FieldBuilder fieldBuilder) {
     (_initializedFields ??= {}).add(fieldBuilder);
   }
 
-  @override
+  /// Returns the fields registered as initialized by this constructor.
+  ///
+  /// Returns the set of fields previously registered via
+  /// [registerInitializedField] and passes on the ownership of the collection
+  /// to the caller.
   Set<FieldBuilder>? takeInitializedFields() {
     Set<FieldBuilder>? result = _initializedFields;
     _initializedFields = null;
diff --git a/pkg/front_end/lib/src/fasta/builder/enum_builder.dart b/pkg/front_end/lib/src/fasta/builder/enum_builder.dart
index a77692c..9c60578 100644
--- a/pkg/front_end/lib/src/fasta/builder/enum_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/enum_builder.dart
@@ -240,7 +240,7 @@
           referencesFromIndexed.lookupSetterReference(valuesName);
     }
 
-    ConstructorBuilder constructorBuilder = new SourceConstructorBuilder(
+    SourceConstructorBuilder constructorBuilder = new SourceConstructorBuilder(
         /* metadata = */ null,
         constMask,
         /* returnType = */ null,
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index 44ee19e..0753eef 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -941,7 +941,7 @@
   void prepareInitializers() {
     FunctionBuilder member = this.member as FunctionBuilder;
     scope = member.computeFormalParameterInitializerScope(scope);
-    if (member is ConstructorBuilder) {
+    if (member is SourceConstructorBuilder) {
       member.prepareInitializers();
       if (member.formals != null) {
         for (FormalParameterBuilder formal in member.formals!) {
@@ -1124,7 +1124,7 @@
         }
       }
     }
-    if (builder is ConstructorBuilder) {
+    if (builder is SourceConstructorBuilder) {
       finishConstructor(builder, asyncModifier, body);
     } else if (builder is ProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
@@ -1632,7 +1632,8 @@
     }
     // We are passing [AsyncMarker.Sync] because the error will be reported
     // already.
-    finishConstructor(member as ConstructorBuilder, AsyncMarker.Sync, null);
+    finishConstructor(
+        member as SourceConstructorBuilder, AsyncMarker.Sync, null);
   }
 
   Expression parseFieldInitializer(Token token) {
@@ -1662,8 +1663,8 @@
     return annotation;
   }
 
-  void finishConstructor(
-      ConstructorBuilder builder, AsyncMarker asyncModifier, Statement? body) {
+  void finishConstructor(SourceConstructorBuilder builder,
+      AsyncMarker asyncModifier, Statement? body) {
     /// Quotes below are from [Dart Programming Language Specification, 4th
     /// Edition](
     /// https://ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf).
@@ -6886,7 +6887,8 @@
                 ]);
           }
         }
-        ConstructorBuilder constructorBuilder = member as ConstructorBuilder;
+        SourceConstructorBuilder constructorBuilder =
+            member as SourceConstructorBuilder;
         constructorBuilder.registerInitializedField(builder);
         return builder.buildInitializer(assignmentOffset, expression,
             isSynthetic: formal != null);
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index cf785bd..f9bfef4 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -1999,14 +1999,12 @@
               statement.condition,
               templateConstEvalFailedAssertionWithMessage
                   .withArguments(message.value));
-        } else {
+        } else if (message is NullConstant) {
           return createEvaluationErrorConstant(
-              statement.message!,
-              templateConstEvalInvalidType.withArguments(
-                  message,
-                  typeEnvironment.coreTypes.stringLegacyRawType,
-                  message.getType(_staticTypeContext!),
-                  isNonNullableByDefault));
+              statement.condition, messageConstEvalFailedAssertion);
+        } else {
+          return createEvaluationErrorConstant(statement.message!,
+              messageConstEvalFailedAssertionWithNonStringMessage);
         }
       }
     } else {
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
index 27f8d35..4cf5f7e 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -395,6 +395,7 @@
       List<SourceClassBuilder> sourceClassBuilders =
           loader.checkSemantics(objectClassBuilder);
       loader.computeMacroDeclarations(sourceClassBuilders);
+      loader.computeMacroApplications();
       loader.finishTypeVariables(objectClassBuilder, dynamicType);
       loader.createTypeInferenceEngine();
       loader.buildComponent();
@@ -416,7 +417,6 @@
       loader.checkMixins(sourceClassBuilders);
       loader.buildOutlineExpressions(
           loader.coreTypes, synthesizedFunctionNodes);
-      loader.computeMacroApplications();
       loader.checkTypes();
       loader.checkRedirectingFactories(sourceClassBuilders);
       loader.checkMainMethods();
@@ -1153,17 +1153,17 @@
     Set<FieldBuilder>? initializedFields = null;
 
     builder.forEachDeclaredConstructor(
-        (String name, ConstructorBuilder constructorBuilder) {
+        (String name, SourceConstructorBuilder constructorBuilder) {
       if (constructorBuilder.isExternal) return;
       // In case of duplicating constructors the earliest ones (those that
       // declared towards the beginning of the file) come last in the list.
       // To report errors on the first definition of a constructor, we need to
       // iterate until that last element.
-      ConstructorBuilder earliest = constructorBuilder;
+      SourceConstructorBuilder earliest = constructorBuilder;
       Builder earliestBuilder = constructorBuilder;
       while (earliestBuilder.next != null) {
         earliestBuilder = earliestBuilder.next!;
-        if (earliestBuilder is ConstructorBuilder) {
+        if (earliestBuilder is SourceConstructorBuilder) {
           earliest = earliestBuilder;
         }
       }
diff --git a/pkg/front_end/lib/src/fasta/kernel/macro.dart b/pkg/front_end/lib/src/fasta/kernel/macro.dart
index dd6dfb1..65a8279 100644
--- a/pkg/front_end/lib/src/fasta/kernel/macro.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/macro.dart
@@ -21,11 +21,19 @@
 }
 
 class MacroApplications {
-  final List<Class> macros;
+  final List<MacroApplication> macros;
 
   MacroApplications(this.macros);
 }
 
+class MacroApplication {
+  final Class cls;
+  final String constructorName;
+  // TODO(johnniwinther): Add support for arguments.
+
+  MacroApplication(this.cls, this.constructorName);
+}
+
 class LibraryMacroApplicationData {
   Map<Class, ClassMacroApplicationData> classData = {};
   Map<Member, MacroApplications> memberApplications = {};
diff --git a/pkg/front_end/lib/src/fasta/kernel/macro_annotation_parser.dart b/pkg/front_end/lib/src/fasta/kernel/macro_annotation_parser.dart
new file mode 100644
index 0000000..118e001
--- /dev/null
+++ b/pkg/front_end/lib/src/fasta/kernel/macro_annotation_parser.dart
@@ -0,0 +1,1927 @@
+// 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:_fe_analyzer_shared/src/messages/codes.dart';
+import 'package:_fe_analyzer_shared/src/parser/parser.dart';
+import 'package:_fe_analyzer_shared/src/scanner/error_token.dart';
+import 'package:_fe_analyzer_shared/src/scanner/token.dart';
+
+import '../builder/builder.dart';
+import '../builder/class_builder.dart';
+import '../builder/member_builder.dart';
+import '../builder/metadata_builder.dart';
+import '../builder/prefix_builder.dart';
+import '../scope.dart';
+import '../source/diet_parser.dart';
+import '../source/source_library_builder.dart';
+
+import 'macro.dart';
+
+List<MacroApplication>? prebuildAnnotations(
+    {required SourceLibraryBuilder enclosingLibrary,
+    required List<MetadataBuilder>? metadataBuilders,
+    required Uri fileUri,
+    required Scope scope}) {
+  if (metadataBuilders == null) return null;
+  List<MacroApplication>? result;
+  for (MetadataBuilder metadataBuilder in metadataBuilders) {
+    _MacroListener listener =
+        new _MacroListener(enclosingLibrary, fileUri, scope);
+    Parser parser = new Parser(listener,
+        useImplicitCreationExpression: useImplicitCreationExpressionInCfe);
+    parser.parseMetadata(
+        parser.syntheticPreviousToken(metadataBuilder.beginToken));
+    MacroApplication? application = listener.popMacroApplication();
+    if (application != null) {
+      result ??= [];
+      result.add(application);
+    }
+  }
+  return result;
+}
+
+class _Node {}
+
+class _UnrecognizedNode implements _Node {
+  const _UnrecognizedNode();
+}
+
+class _MacroClassNode implements _Node {
+  final Token token;
+  final ClassBuilder classBuilder;
+
+  _MacroClassNode(this.token, this.classBuilder);
+}
+
+class _MacroConstructorNode implements _Node {
+  final ClassBuilder classBuilder;
+  final String constructorName;
+
+  _MacroConstructorNode(this.classBuilder, this.constructorName);
+}
+
+class _PrefixNode implements _Node {
+  final PrefixBuilder prefixBuilder;
+
+  _PrefixNode(this.prefixBuilder);
+}
+
+class _MacroApplicationNode implements _Node {
+  final MacroApplication application;
+
+  _MacroApplicationNode(this.application);
+}
+
+class _NoArgumentsNode implements _Node {
+  const _NoArgumentsNode();
+}
+
+class _ArgumentsNode implements _Node {
+  _ArgumentsNode();
+}
+
+class _MacroListener implements Listener {
+  final SourceLibraryBuilder currentLibrary;
+
+  @override
+  final Uri uri;
+
+  final Scope scope;
+
+  final List<_Node> _stack = [];
+
+  Object? _unrecognized;
+
+  bool get unrecognized => _unrecognized != null;
+
+  void set unrecognized(bool value) {
+    if (value) {
+      // TODO(johnniwinther): Remove this when implementation is more mature.
+      _unrecognized = StackTrace.current;
+    } else {
+      _unrecognized = null;
+    }
+  }
+
+  _MacroListener(this.currentLibrary, this.uri, this.scope);
+
+  void pushUnsupported() {
+    push(const _UnrecognizedNode());
+    _unsupported();
+  }
+
+  void push(_Node node) {
+    _stack.add(node);
+  }
+
+  _Node pop() => _stack.removeLast();
+
+  MacroApplication? popMacroApplication() {
+    if (unrecognized) return null;
+    if (_stack.length != 1) return null;
+    _Node node = pop();
+    if (node is _MacroApplicationNode) {
+      return node.application;
+    }
+    return null;
+  }
+
+  @override
+  void beginMetadata(Token token) {
+    // Do nothing.
+  }
+
+  @override
+  void endMetadata(Token beginToken, Token? periodBeforeName, Token endToken) {
+    _Node argumentsNode = pop();
+    _Node referenceNode = pop();
+    if (!unrecognized) {
+      ClassBuilder? macroClass;
+      String? constructorName;
+      if (referenceNode is _MacroClassNode) {
+        macroClass = referenceNode.classBuilder;
+        MemberBuilder? member = referenceNode.classBuilder
+            .findConstructorOrFactory(
+                '', referenceNode.token.charOffset, uri, currentLibrary);
+        if (member != null) {
+          constructorName = '';
+        }
+      } else if (referenceNode is _MacroConstructorNode) {
+        macroClass = referenceNode.classBuilder;
+        constructorName = referenceNode.constructorName;
+      }
+      if (macroClass != null &&
+          constructorName != null &&
+          argumentsNode is _ArgumentsNode) {
+        push(new _MacroApplicationNode(
+            new MacroApplication(macroClass.cls, constructorName)));
+        return;
+      }
+    }
+    pushUnsupported();
+  }
+
+  @override
+  void handleIdentifier(Token token, IdentifierContext context) {
+    switch (context) {
+      case IdentifierContext.metadataReference:
+        Builder? builder = scope.lookup(token.lexeme, token.charOffset, uri);
+        if (builder is ClassBuilder && builder.isMacro) {
+          push(new _MacroClassNode(token, builder));
+        } else if (builder is PrefixBuilder) {
+          push(new _PrefixNode(builder));
+        } else {
+          pushUnsupported();
+        }
+        break;
+      case IdentifierContext.metadataContinuation:
+        _Node node = pop();
+        if (node is _PrefixNode) {
+          Builder? builder =
+              node.prefixBuilder.lookup(token.lexeme, token.charOffset, uri);
+          if (builder is ClassBuilder && builder.isMacro) {
+            push(new _MacroClassNode(token, builder));
+          } else {
+            pushUnsupported();
+          }
+        } else if (node is _MacroClassNode) {
+          MemberBuilder? member = node.classBuilder.findConstructorOrFactory(
+              token.lexeme, token.charOffset, uri, currentLibrary);
+          if (member != null) {
+            push(new _MacroConstructorNode(node.classBuilder, token.lexeme));
+          } else {
+            pushUnsupported();
+          }
+        } else {
+          pushUnsupported();
+        }
+        break;
+      case IdentifierContext.metadataContinuationAfterTypeArguments:
+        _Node node = pop();
+        if (node is _MacroClassNode) {
+          MemberBuilder? member = node.classBuilder.findConstructorOrFactory(
+              token.lexeme, token.charOffset, uri, currentLibrary);
+          if (member != null) {
+            push(new _MacroConstructorNode(node.classBuilder, token.lexeme));
+          } else {
+            pushUnsupported();
+          }
+        } else {
+          pushUnsupported();
+        }
+        break;
+      default:
+        pushUnsupported();
+        break;
+    }
+  }
+
+  @override
+  void beginArguments(Token token) {
+    // Do nothing.
+  }
+
+  @override
+  void endArguments(int count, Token beginToken, Token endToken) {
+    if (count == 0) {
+      push(new _ArgumentsNode());
+    } else {
+      // TODO(johnniwinther): Handle arguments.
+      pushUnsupported();
+    }
+  }
+
+  @override
+  void handleNoArguments(Token token) {
+    push(const _NoArgumentsNode());
+  }
+
+  @override
+  void handleNoTypeArguments(Token token) {
+    // TODO(johnniwinther): Handle type arguments. Ignore for now.
+  }
+
+  @override
+  void handleQualified(Token period) {
+    // Do nothing. Supported qualified names are handled through the identifier
+    // context.
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Stub implementation
+  //////////////////////////////////////////////////////////////////////////////
+
+  /// Called for listener events that are expected but not supported.
+  void _unsupported() {
+    unrecognized = true;
+  }
+
+  /// Called for listener events that are unexpected.
+  void _unexpected() {
+    unrecognized = true;
+  }
+
+  /// Called for listener events that are supported but not handled yet.
+  void _unhandled() {
+    unrecognized = true;
+  }
+
+  /// Called for listener events whose use in unknown.
+  void _unknown() {
+    unrecognized = true;
+  }
+
+  /// Called for listener events that are ignored.
+  void _ignored() {}
+
+  @override
+  void beginAsOperatorType(Token operator) {
+    _unsupported();
+  }
+
+  @override
+  void beginAssert(Token assertKeyword, Assert kind) {
+    _unsupported();
+  }
+
+  @override
+  void beginAwaitExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginBinaryExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginBlock(Token token, BlockKind blockKind) {
+    _unsupported();
+  }
+
+  @override
+  void beginBlockFunctionBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginCascade(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginCaseExpression(Token caseKeyword) {
+    _unsupported();
+  }
+
+  @override
+  void beginCatchClause(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginClassDeclaration(
+      Token begin, Token? abstractToken, Token? macroToken, Token name) {
+    _unexpected();
+  }
+
+  @override
+  void beginClassOrMixinOrExtensionBody(DeclarationKind kind, Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginClassOrMixinOrNamedMixinApplicationPrelude(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginCombinators(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginCompilationUnit(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginConditionalExpression(Token question) {
+    _unsupported();
+  }
+
+  @override
+  void beginConditionalUri(Token ifKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void beginConditionalUris(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginConstExpression(Token constKeyword) {
+    _unhandled();
+  }
+
+  @override
+  void beginConstLiteral(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void beginConstructorReference(Token start) {
+    _unknown();
+  }
+
+  @override
+  void beginDoWhileStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginDoWhileStatementBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginElseStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginEnum(Token enumKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void beginExport(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginExtensionDeclaration(Token extensionKeyword, Token? name) {
+    _unexpected();
+  }
+
+  @override
+  void beginExtensionDeclarationPrelude(Token extensionKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void beginFactoryMethod(DeclarationKind declarationKind, Token lastConsumed,
+      Token? externalToken, Token? constToken) {
+    _unexpected();
+  }
+
+  @override
+  void beginFieldInitializer(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginFields(
+      DeclarationKind declarationKind,
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      Token lastConsumed) {
+    _unexpected();
+  }
+
+  @override
+  void beginForControlFlow(Token? awaitToken, Token forToken) {
+    _unsupported();
+  }
+
+  @override
+  void beginForInBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginForInExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginForStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginForStatementBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginFormalParameter(Token token, MemberKind kind, Token? requiredToken,
+      Token? covariantToken, Token? varFinalOrConst) {
+    _unsupported();
+  }
+
+  @override
+  void beginFormalParameterDefaultValueExpression() {
+    _unsupported();
+  }
+
+  @override
+  void beginFormalParameters(Token token, MemberKind kind) {
+    _unsupported();
+  }
+
+  @override
+  void beginFunctionExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginFunctionName(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginFunctionType(Token beginToken) {
+    _unhandled();
+  }
+
+  @override
+  void beginFunctionTypedFormalParameter(Token token) {
+    _unknown();
+  }
+
+  @override
+  void beginHide(Token hideKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void beginIfControlFlow(Token ifToken) {
+    _unsupported();
+  }
+
+  @override
+  void beginIfStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginImplicitCreationExpression(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void beginImport(Token importKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void beginInitializedIdentifier(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginInitializer(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginInitializers(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginIsOperatorType(Token operator) {
+    _unhandled();
+  }
+
+  @override
+  void beginLabeledStatement(Token token, int labelCount) {
+    _unsupported();
+  }
+
+  @override
+  void beginLibraryName(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginLiteralString(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void beginLiteralSymbol(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void beginLocalFunctionDeclaration(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginMember() {
+    _unexpected();
+  }
+
+  @override
+  void beginMetadataStar(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginMethod(
+      DeclarationKind declarationKind,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? varFinalOrConst,
+      Token? getOrSet,
+      Token name) {
+    _unexpected();
+  }
+
+  @override
+  void beginMixinDeclaration(Token mixinKeyword, Token name) {
+    _unexpected();
+  }
+
+  @override
+  void beginNamedFunctionExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginNamedMixinApplication(
+      Token begin, Token? abstractToken, Token? macroToken, Token name) {
+    _unexpected();
+  }
+
+  @override
+  void beginNewExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginOptionalFormalParameters(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginPart(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginPartOf(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginRedirectingFactoryBody(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginRethrowStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginReturnStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginShow(Token showKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void beginSwitchBlock(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
+    _unsupported();
+  }
+
+  @override
+  void beginSwitchStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginThenStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginTopLevelMember(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginTopLevelMethod(Token lastConsumed, Token? externalToken) {
+    _unexpected();
+  }
+
+  @override
+  void beginTryStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginTypeArguments(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void beginTypeList(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginTypeVariable(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginTypeVariables(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginTypedef(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginUncategorizedTopLevelDeclaration(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void beginVariableInitializer(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginVariablesDeclaration(
+      Token token, Token? lateToken, Token? varFinalOrConst) {
+    _unsupported();
+  }
+
+  @override
+  void beginWhileStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginWhileStatementBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void beginYieldStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endAsOperatorType(Token operator) {
+    _unhandled();
+  }
+
+  @override
+  void endAssert(Token assertKeyword, Assert kind, Token leftParenthesis,
+      Token? commaToken, Token semicolonToken) {
+    _unsupported();
+  }
+
+  @override
+  void endAwaitExpression(Token beginToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endBinaryExpression(Token token) {
+    _unknown();
+  }
+
+  @override
+  void endBlock(
+      int count, Token beginToken, Token endToken, BlockKind blockKind) {
+    _unsupported();
+  }
+
+  @override
+  void endBlockFunctionBody(int count, Token beginToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endCascade() {
+    _unsupported();
+  }
+
+  @override
+  void endCaseExpression(Token colon) {
+    _unsupported();
+  }
+
+  @override
+  void endCatchClause(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endClassConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endClassDeclaration(Token beginToken, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endClassFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endClassFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endClassMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endClassOrMixinOrExtensionBody(
+      DeclarationKind kind, int memberCount, Token beginToken, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endCombinators(int count) {
+    _unexpected();
+  }
+
+  @override
+  void endCompilationUnit(int count, Token token) {
+    _unexpected();
+  }
+
+  @override
+  void endConditionalExpression(Token question, Token colon) {
+    _unhandled();
+  }
+
+  @override
+  void endConditionalUri(Token ifKeyword, Token leftParen, Token? equalSign) {
+    _unexpected();
+  }
+
+  @override
+  void endConditionalUris(int count) {
+    _unexpected();
+  }
+
+  @override
+  void endConstExpression(Token token) {
+    _unknown();
+  }
+
+  @override
+  void endConstLiteral(Token token) {
+    _unknown();
+  }
+
+  @override
+  void endConstructorReference(Token start, Token? periodBeforeName,
+      Token endToken, ConstructorReferenceContext constructorReferenceContext) {
+    _unknown();
+  }
+
+  @override
+  void endDoWhileStatement(
+      Token doKeyword, Token whileKeyword, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endDoWhileStatementBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endElseStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
+    _unexpected();
+  }
+
+  @override
+  void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endEnumFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endEnumFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endExport(Token exportKeyword, Token semicolon) {
+    _unexpected();
+  }
+
+  @override
+  void endExtensionConstructor(Token? getOrSet, Token beginToken,
+      Token beginParam, Token? beginInitializers, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endExtensionDeclaration(Token extensionKeyword, Token? typeKeyword,
+      Token onKeyword, Token? showKeyword, Token? hideKeyword, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endExtensionFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endExtensionFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endExtensionMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endFieldInitializer(Token assignment, Token token) {
+    _unexpected();
+  }
+
+  @override
+  void endForControlFlow(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endForIn(Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endForInBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endForInControlFlow(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endForInExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endForStatement(Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endForStatementBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endFormalParameter(
+      Token? thisKeyword,
+      Token? superKeyword,
+      Token? periodAfterThisOrSuper,
+      Token nameToken,
+      Token? initializerStart,
+      Token? initializerEnd,
+      FormalParameterKind kind,
+      MemberKind memberKind) {
+    _unsupported();
+  }
+
+  @override
+  void endFormalParameterDefaultValueExpression() {
+    _unsupported();
+  }
+
+  @override
+  void endFormalParameters(
+      int count, Token beginToken, Token endToken, MemberKind kind) {
+    _unsupported();
+  }
+
+  @override
+  void endFunctionExpression(Token beginToken, Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endFunctionName(Token beginToken, Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endFunctionType(Token functionToken, Token? questionMark) {
+    _unhandled();
+  }
+
+  @override
+  void endFunctionTypedFormalParameter(Token nameToken, Token? question) {
+    _unknown();
+  }
+
+  @override
+  void endHide(Token hideKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void endIfControlFlow(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endIfElseControlFlow(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endIfStatement(Token ifToken, Token? elseToken) {
+    _unsupported();
+  }
+
+  @override
+  void endImplicitCreationExpression(Token token, Token openAngleBracket) {
+    _unhandled();
+  }
+
+  @override
+  void endImport(Token importKeyword, Token? semicolon) {
+    _unexpected();
+  }
+
+  @override
+  void endInitializedIdentifier(Token nameToken) {
+    _unsupported();
+  }
+
+  @override
+  void endInitializer(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void endInitializers(int count, Token beginToken, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endInvalidAwaitExpression(
+      Token beginToken, Token endToken, MessageCode errorCode) {
+    _unsupported();
+  }
+
+  @override
+  void endInvalidYieldStatement(Token beginToken, Token? starToken,
+      Token endToken, MessageCode errorCode) {
+    _unsupported();
+  }
+
+  @override
+  void endIsOperatorType(Token operator) {
+    _unhandled();
+  }
+
+  @override
+  void endLabeledStatement(int labelCount) {
+    _unsupported();
+  }
+
+  @override
+  void endLibraryName(Token libraryKeyword, Token semicolon) {
+    _unexpected();
+  }
+
+  @override
+  void endLiteralString(int interpolationCount, Token endToken) {
+    _unhandled();
+  }
+
+  @override
+  void endLiteralSymbol(Token hashToken, int identifierCount) {
+    _unhandled();
+  }
+
+  @override
+  void endLocalFunctionDeclaration(Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endMember() {
+    _unexpected();
+  }
+
+  @override
+  void endMetadataStar(int count) {
+    _unsupported();
+  }
+
+  @override
+  void endMixinConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endMixinDeclaration(Token mixinKeyword, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endMixinFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endMixinFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endMixinMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endNamedFunctionExpression(Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endNamedMixinApplication(Token begin, Token classKeyword, Token equals,
+      Token? implementsKeyword, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endNewExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endOptionalFormalParameters(
+      int count, Token beginToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endPart(Token partKeyword, Token semicolon) {
+    _unexpected();
+  }
+
+  @override
+  void endPartOf(
+      Token partKeyword, Token ofKeyword, Token semicolon, bool hasName) {
+    _unexpected();
+  }
+
+  @override
+  void endRedirectingFactoryBody(Token beginToken, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endRethrowStatement(Token rethrowToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endReturnStatement(
+      bool hasExpression, Token beginToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endShow(Token showKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void endSwitchBlock(int caseCount, Token beginToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endSwitchCase(
+      int labelCount,
+      int expressionCount,
+      Token? defaultKeyword,
+      Token? colonAfterDefault,
+      int statementCount,
+      Token firstToken,
+      Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endSwitchStatement(Token switchKeyword, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endThenStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endTopLevelDeclaration(Token nextToken) {
+    _unexpected();
+  }
+
+  @override
+  void endTopLevelFields(
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endTopLevelMethod(Token beginToken, Token? getOrSet, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endTryStatement(
+      int catchCount, Token tryKeyword, Token? finallyKeyword) {
+    _unsupported();
+  }
+
+  @override
+  void endTypeArguments(int count, Token beginToken, Token endToken) {
+    _unhandled();
+  }
+
+  @override
+  void endTypeList(int count) {
+    _unexpected();
+  }
+
+  @override
+  void endTypeVariable(
+      Token token, int index, Token? extendsOrSuper, Token? variance) {
+    _unsupported();
+  }
+
+  @override
+  void endTypeVariables(Token beginToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endTypedef(Token typedefKeyword, Token? equals, Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void endVariableInitializer(Token assignmentOperator) {
+    _unsupported();
+  }
+
+  @override
+  void endVariablesDeclaration(int count, Token? endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endWhileStatement(Token whileKeyword, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void endWhileStatementBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void endYieldStatement(Token yieldToken, Token? starToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleAsOperator(Token operator) {
+    _unhandled();
+  }
+
+  @override
+  void handleAssignmentExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleAsyncModifier(Token? asyncToken, Token? starToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleBreakStatement(
+      bool hasTarget, Token breakKeyword, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleCaseMatch(Token caseKeyword, Token colon) {
+    _unsupported();
+  }
+
+  @override
+  void handleCatchBlock(Token? onKeyword, Token? catchKeyword, Token? comma) {
+    _unsupported();
+  }
+
+  @override
+  void handleClassExtends(Token? extendsKeyword, int typeCount) {
+    _unexpected();
+  }
+
+  @override
+  void handleClassHeader(Token begin, Token classKeyword, Token? nativeToken) {
+    _unexpected();
+  }
+
+  @override
+  void handleClassNoWithClause() {
+    _unexpected();
+  }
+
+  @override
+  void handleClassWithClause(Token withKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void handleCommentReference(
+      Token? newKeyword,
+      Token? firstToken,
+      Token? firstPeriod,
+      Token? secondToken,
+      Token? secondPeriod,
+      Token thirdToken) {
+    _ignored();
+  }
+
+  @override
+  void handleCommentReferenceText(String referenceSource, int referenceOffset) {
+    _ignored();
+  }
+
+  @override
+  void handleConditionalExpressionColon() {
+    _unhandled();
+  }
+
+  @override
+  void handleConstFactory(Token constKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void handleContinueStatement(
+      bool hasTarget, Token continueKeyword, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleDirectivesOnly() {
+    _unknown();
+  }
+
+  @override
+  void handleDottedName(int count, Token firstIdentifier) {
+    _unknown();
+  }
+
+  @override
+  void handleElseControlFlow(Token elseToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleEmptyFunctionBody(Token semicolon) {
+    _unsupported();
+  }
+
+  @override
+  void handleEmptyStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleEndingBinaryExpression(Token token) {
+    _unknown();
+  }
+
+  @override
+  void handleEnumElement(Token beginToken) {
+    _unexpected();
+  }
+
+  @override
+  void handleEnumElements(Token elementsEndToken, int elementsCount) {
+    _unexpected();
+  }
+
+  @override
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    _unexpected();
+  }
+
+  @override
+  void handleEnumNoWithClause() {
+    _unexpected();
+  }
+
+  @override
+  void handleEnumWithClause(Token withKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void handleErrorToken(ErrorToken token) {
+    _unsupported();
+  }
+
+  @override
+  void handleExpressionFunctionBody(Token arrowToken, Token? endToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleExpressionStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleExtensionShowHide(Token? showKeyword, int showElementCount,
+      Token? hideKeyword, int hideElementCount) {
+    _unexpected();
+  }
+
+  @override
+  void handleExtraneousExpression(Token token, Message message) {
+    _unknown();
+  }
+
+  @override
+  void handleFinallyBlock(Token finallyKeyword) {
+    _unsupported();
+  }
+
+  @override
+  void handleForInLoopParts(Token? awaitToken, Token forToken,
+      Token leftParenthesis, Token inKeyword) {
+    _unsupported();
+  }
+
+  @override
+  void handleForInitializerEmptyStatement(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleForInitializerExpressionStatement(Token token, bool forIn) {
+    _unsupported();
+  }
+
+  @override
+  void handleForInitializerLocalVariableDeclaration(Token token, bool forIn) {
+    _unsupported();
+  }
+
+  @override
+  void handleForLoopParts(Token forKeyword, Token leftParen,
+      Token leftSeparator, int updateExpressionCount) {
+    _unsupported();
+  }
+
+  @override
+  void handleFormalParameterWithoutValue(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleFunctionBodySkipped(Token token, bool isExpressionBody) {
+    _unsupported();
+  }
+
+  @override
+  void handleIdentifierList(int count) {
+    _unknown();
+  }
+
+  @override
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
+    _unexpected();
+  }
+
+  @override
+  void handleImportPrefix(Token? deferredKeyword, Token? asKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void handleIndexedExpression(
+      Token? question, Token openSquareBracket, Token closeSquareBracket) {
+    _unsupported();
+  }
+
+  @override
+  void handleInterpolationExpression(Token leftBracket, Token? rightBracket) {
+    _unhandled();
+  }
+
+  @override
+  void handleInvalidExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleInvalidFunctionBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleInvalidMember(Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void handleInvalidOperatorName(Token operatorKeyword, Token token) {
+    _unexpected();
+  }
+
+  @override
+  void handleInvalidStatement(Token token, Message message) {
+    _unsupported();
+  }
+
+  @override
+  void handleInvalidTopLevelBlock(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void handleInvalidTopLevelDeclaration(Token endToken) {
+    _unexpected();
+  }
+
+  @override
+  void handleInvalidTypeArguments(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleInvalidTypeReference(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleIsOperator(Token isOperator, Token? not) {
+    _unhandled();
+  }
+
+  @override
+  void handleLabel(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleLiteralBool(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void handleLiteralDouble(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void handleLiteralInt(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void handleLiteralList(
+      int count, Token leftBracket, Token? constKeyword, Token rightBracket) {
+    _unhandled();
+  }
+
+  @override
+  void handleLiteralMapEntry(Token colon, Token endToken) {
+    _unhandled();
+  }
+
+  @override
+  void handleLiteralNull(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void handleLiteralSetOrMap(int count, Token leftBrace, Token? constKeyword,
+      Token rightBrace, bool hasSetEntry) {
+    _unhandled();
+  }
+
+  @override
+  void handleMixinHeader(Token mixinKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void handleMixinOn(Token? onKeyword, int typeCount) {
+    _unexpected();
+  }
+
+  @override
+  void handleNamedArgument(Token colon) {
+    _unhandled();
+  }
+
+  @override
+  void handleNamedMixinApplicationWithClause(Token withKeyword) {
+    _unexpected();
+  }
+
+  @override
+  void handleNativeClause(Token nativeToken, bool hasName) {
+    _unexpected();
+  }
+
+  @override
+  void handleNativeFunctionBody(Token nativeToken, Token semicolon) {
+    _unexpected();
+  }
+
+  @override
+  void handleNativeFunctionBodyIgnored(Token nativeToken, Token semicolon) {
+    _unexpected();
+  }
+
+  @override
+  void handleNativeFunctionBodySkipped(Token nativeToken, Token semicolon) {
+    _unexpected();
+  }
+
+  @override
+  void handleNewAsIdentifier(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void handleNoCommentReference() {
+    _ignored();
+  }
+
+  @override
+  void handleNoConstructorReferenceContinuationAfterTypeArguments(Token token) {
+    _unknown();
+  }
+
+  @override
+  void handleNoFieldInitializer(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void handleNoFormalParameters(Token token, MemberKind kind) {
+    _unsupported();
+  }
+
+  @override
+  void handleNoFunctionBody(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleNoInitializers() {
+    _unexpected();
+  }
+
+  @override
+  void handleNoName(Token token) {
+    _unknown();
+  }
+
+  @override
+  void handleNoType(Token lastConsumed) {
+    _unknown();
+  }
+
+  @override
+  void handleNoTypeNameInConstructorReference(Token token) {
+    _unknown();
+  }
+
+  @override
+  void handleNoTypeVariables(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleNoVariableInitializer(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleNonNullAssertExpression(Token bang) {
+    _unsupported();
+  }
+
+  @override
+  void handleOperator(Token token) {
+    _unknown();
+  }
+
+  @override
+  void handleOperatorName(Token operatorKeyword, Token token) {
+    _unexpected();
+  }
+
+  @override
+  void handleParenthesizedCondition(Token token) {
+    _unknown();
+  }
+
+  @override
+  void handleParenthesizedExpression(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void handleRecoverClassHeader() {
+    _unexpected();
+  }
+
+  @override
+  void handleRecoverImport(Token? semicolon) {
+    _unexpected();
+  }
+
+  @override
+  void handleRecoverMixinHeader() {
+    _unexpected();
+  }
+
+  @override
+  void handleRecoverableError(
+      Message message, Token startToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleScript(Token token) {
+    _unexpected();
+  }
+
+  @override
+  void handleSend(Token beginToken, Token endToken) {
+    _unhandled();
+  }
+
+  @override
+  void handleShowHideIdentifier(Token? modifier, Token identifier) {
+    _unexpected();
+  }
+
+  @override
+  void handleSpreadExpression(Token spreadToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleStringJuxtaposition(Token startToken, int literalCount) {
+    _unhandled();
+  }
+
+  @override
+  void handleStringPart(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void handleSuperExpression(Token token, IdentifierContext context) {
+    _unsupported();
+  }
+
+  @override
+  void handleSymbolVoid(Token token) {
+    _unhandled();
+  }
+
+  @override
+  void handleThenControlFlow(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleThisExpression(Token token, IdentifierContext context) {
+    _unsupported();
+  }
+
+  @override
+  void handleThrowExpression(Token throwToken, Token endToken) {
+    _unsupported();
+  }
+
+  @override
+  void handleType(Token beginToken, Token? questionMark) {
+    _unknown();
+  }
+
+  @override
+  void handleTypeArgumentApplication(Token openAngleBracket) {
+    _unhandled();
+  }
+
+  @override
+  void handleTypeVariablesDefined(Token token, int count) {
+    _unsupported();
+  }
+
+  @override
+  void handleUnaryPostfixAssignmentExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleUnaryPrefixAssignmentExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleUnaryPrefixExpression(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleUnescapeError(
+      Message message, covariant Token location, int stringOffset, int length) {
+    _unsupported();
+  }
+
+  @override
+  void handleValuedFormalParameter(Token equals, Token token) {
+    _unsupported();
+  }
+
+  @override
+  void handleVoidKeyword(Token token) {
+    _unknown();
+  }
+
+  @override
+  void handleVoidKeywordWithTypeArguments(Token token) {
+    _unsupported();
+  }
+
+  @override
+  void logEvent(String name) {}
+
+  @override
+  void reportVarianceModifierNotEnabled(Token? variance) {
+    _unsupported();
+  }
+}
diff --git a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
index 03de64a..701382f 100644
--- a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
@@ -2554,7 +2554,7 @@
           .lookupGetterReference(constructorTearOffName(
               constructorName, _currentClassReferencesFromIndexed!.library));
     }
-    ConstructorBuilder constructorBuilder = new SourceConstructorBuilder(
+    SourceConstructorBuilder constructorBuilder = new SourceConstructorBuilder(
         metadata,
         modifiers & ~abstractMask,
         returnType,
diff --git a/pkg/front_end/lib/src/fasta/source/source_loader.dart b/pkg/front_end/lib/src/fasta/source/source_loader.dart
index e0779c4..6c12705 100644
--- a/pkg/front_end/lib/src/fasta/source/source_loader.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_loader.dart
@@ -35,6 +35,7 @@
 import '../../base/common.dart';
 import '../../base/instrumentation.dart' show Instrumentation;
 import '../../base/nnbd_mode.dart';
+import '../builder/metadata_builder.dart';
 import '../dill/dill_library_builder.dart';
 import '../builder_graph.dart';
 import '../builder/builder.dart';
@@ -67,6 +68,7 @@
     show SynthesizedFunctionNode, TypeDependency;
 import '../kernel/kernel_target.dart' show KernelTarget;
 import '../kernel/macro.dart';
+import '../kernel/macro_annotation_parser.dart';
 import '../kernel/transform_collections.dart' show CollectionTransformer;
 import '../kernel/transform_set_literals.dart' show SetLiteralTransformer;
 import '../kernel/type_builder_computer.dart' show TypeBuilderComputer;
@@ -908,7 +910,7 @@
   }
 
   void registerConstructorToBeInferred(
-      Constructor constructor, ConstructorBuilder builder) {
+      Constructor constructor, SourceConstructorBuilder builder) {
     _typeInferenceEngine!.toBeInferred[constructor] = builder;
   }
 
@@ -1381,65 +1383,108 @@
 
   void computeMacroApplications() {
     if (!enableMacros || _macroClassBuilder == null) return;
-    Class macroClass = _macroClassBuilder!.cls;
 
-    Class? computeApplication(Expression expression) {
-      if (expression is ConstructorInvocation) {
-        Class cls = expression.target.enclosingClass;
-        if (hierarchy.isSubtypeOf(cls, macroClass)) {
-          return cls;
-        }
-      }
-      return null;
-    }
-
-    MacroApplications? computeApplications(List<Expression> annotations) {
-      List<Class> macros = [];
-      for (Expression annotation in annotations) {
-        Class? cls = computeApplication(annotation);
-        if (cls != null) {
-          macros.add(cls);
-        }
-      }
-      return macros.isNotEmpty ? new MacroApplications(macros) : null;
+    MacroApplications? computeApplications(
+        SourceLibraryBuilder enclosingLibrary,
+        Scope scope,
+        Uri fileUri,
+        List<MetadataBuilder>? annotations) {
+      List<MacroApplication>? result = prebuildAnnotations(
+          enclosingLibrary: enclosingLibrary,
+          metadataBuilders: annotations,
+          fileUri: fileUri,
+          scope: scope);
+      return result != null ? new MacroApplications(result) : null;
     }
 
     for (SourceLibraryBuilder libraryBuilder in sourceLibraryBuilders) {
       // TODO(johnniwinther): Handle patch libraries.
       LibraryMacroApplicationData libraryMacroApplicationData =
           new LibraryMacroApplicationData();
-      Library library = libraryBuilder.library;
-      for (Class cls in library.classes) {
-        ClassMacroApplicationData classMacroApplicationData =
-            new ClassMacroApplicationData();
-        classMacroApplicationData.classApplications =
-            computeApplications(cls.annotations);
-        for (Member member in cls.members) {
-          MacroApplications? macroApplications =
-              computeApplications(member.annotations);
+      Iterator<Builder> iterator = libraryBuilder.iterator;
+      while (iterator.moveNext()) {
+        Builder builder = iterator.current;
+        if (builder is SourceClassBuilder) {
+          SourceClassBuilder classBuilder = builder;
+          ClassMacroApplicationData classMacroApplicationData =
+              new ClassMacroApplicationData();
+          classMacroApplicationData.classApplications = computeApplications(
+              libraryBuilder,
+              classBuilder.scope,
+              classBuilder.fileUri,
+              classBuilder.metadata);
+          builder.forEach((String name, Builder memberBuilder) {
+            if (memberBuilder is SourceProcedureBuilder) {
+              MacroApplications? macroApplications = computeApplications(
+                  libraryBuilder,
+                  classBuilder.scope,
+                  memberBuilder.fileUri,
+                  memberBuilder.metadata);
+              if (macroApplications != null) {
+                classMacroApplicationData
+                        .memberApplications[memberBuilder.procedure] =
+                    macroApplications;
+              }
+            } else if (memberBuilder is SourceFieldBuilder) {
+              MacroApplications? macroApplications = computeApplications(
+                  libraryBuilder,
+                  classBuilder.scope,
+                  memberBuilder.fileUri,
+                  memberBuilder.metadata);
+              if (macroApplications != null) {
+                classMacroApplicationData
+                        .memberApplications[memberBuilder.field] =
+                    macroApplications;
+              }
+            }
+          });
+          classBuilder.forEachConstructor((String name, Builder memberBuilder) {
+            if (memberBuilder is SourceConstructorBuilder) {
+              MacroApplications? macroApplications = computeApplications(
+                  libraryBuilder,
+                  classBuilder.scope,
+                  memberBuilder.fileUri,
+                  memberBuilder.metadata);
+              if (macroApplications != null) {
+                classMacroApplicationData
+                        .memberApplications[memberBuilder.constructor] =
+                    macroApplications;
+              }
+            }
+          });
+
+          if (classMacroApplicationData.classApplications != null ||
+              classMacroApplicationData.memberApplications.isNotEmpty) {
+            libraryMacroApplicationData.classData[builder.cls] =
+                classMacroApplicationData;
+          }
+        } else if (builder is SourceProcedureBuilder) {
+          MacroApplications? macroApplications = computeApplications(
+              libraryBuilder,
+              libraryBuilder.scope,
+              builder.fileUri,
+              builder.metadata);
           if (macroApplications != null) {
-            classMacroApplicationData.memberApplications[member] =
+            libraryMacroApplicationData.memberApplications[builder.procedure] =
                 macroApplications;
           }
-        }
-        if (classMacroApplicationData.classApplications != null ||
-            classMacroApplicationData.memberApplications.isNotEmpty) {
-          libraryMacroApplicationData.classData[cls] =
-              classMacroApplicationData;
-        }
-      }
-      for (Member member in library.members) {
-        MacroApplications? macroApplications =
-            computeApplications(member.annotations);
-        if (macroApplications != null) {
-          libraryMacroApplicationData.memberApplications[member] =
-              macroApplications;
+        } else if (builder is SourceFieldBuilder) {
+          MacroApplications? macroApplications = computeApplications(
+              libraryBuilder,
+              libraryBuilder.scope,
+              builder.fileUri,
+              builder.metadata);
+          if (macroApplications != null) {
+            libraryMacroApplicationData.memberApplications[builder.field] =
+                macroApplications;
+          }
         }
       }
       if (libraryMacroApplicationData.classData.isNotEmpty ||
           libraryMacroApplicationData.memberApplications.isNotEmpty) {
         if (retainDataForTesting) {
-          dataForTesting!.macroApplicationData.libraryData[library] =
+          dataForTesting!
+                  .macroApplicationData.libraryData[libraryBuilder.library] =
               libraryMacroApplicationData;
         }
       }
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
index b14927c..34aa46b 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
@@ -122,14 +122,14 @@
   /// This is represented as a map from a constructor to its library
   /// builder because the builder is used to report errors due to cyclic
   /// inference dependencies.
-  final Map<Constructor, ConstructorBuilder> toBeInferred = {};
+  final Map<Constructor, SourceConstructorBuilder> toBeInferred = {};
 
   /// A map containing constructors in the process of being inferred.
   ///
   /// This is used to detect cyclic inference dependencies.  It is represented
   /// as a map from a constructor to its library builder because the builder
   /// is used to report errors.
-  final Map<Constructor, ConstructorBuilder> beingInferred = {};
+  final Map<Constructor, SourceConstructorBuilder> beingInferred = {};
 
   final Map<Member, TypeDependency> typeDependencies = {};
 
@@ -153,7 +153,7 @@
   void finishTopLevelInitializingFormals() {
     // Field types have all been inferred so we don't need to guard against
     // cyclic dependency.
-    for (ConstructorBuilder builder in toBeInferred.values) {
+    for (SourceConstructorBuilder builder in toBeInferred.values) {
       builder.inferFormalTypes();
     }
     toBeInferred.clear();
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
index 5dc515a..ad23808 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
@@ -376,7 +376,7 @@
 
   @override
   void inferConstructorParameterTypes(Constructor target) {
-    ConstructorBuilder? constructor = engine.beingInferred[target];
+    SourceConstructorBuilder? constructor = engine.beingInferred[target];
     if (constructor != null) {
       // There is a cyclic dependency where inferring the types of the
       // initializing formals of a constructor required us to infer the
diff --git a/pkg/front_end/messages.status b/pkg/front_end/messages.status
index 10ad152..0fed875 100644
--- a/pkg/front_end/messages.status
+++ b/pkg/front_end/messages.status
@@ -111,6 +111,7 @@
 ConstEvalExternalFactory/example: Fail
 ConstEvalFailedAssertion/example: Fail
 ConstEvalFailedAssertionWithMessage/example: Fail
+ConstEvalFailedAssertionWithNonStringMessage/example: Fail
 ConstEvalFreeTypeParameter/analyzerCode: Fail
 ConstEvalFreeTypeParameter/example: Fail
 ConstEvalGetterNotFound/analyzerCode: Fail
diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index 6632763..9819804 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -189,6 +189,10 @@
   problemMessage: "This assertion failed with message: #stringOKEmpty"
   analyzerCode: CONST_EVAL_THROWS_EXCEPTION
 
+ConstEvalFailedAssertionWithNonStringMessage:
+  problemMessage: "This assertion failed with a non-String message."
+  analyzerCode: CONST_EVAL_THROWS_EXCEPTION
+
 ConstEvalNonConstantVariableGet:
   problemMessage: "The variable '#nameOKEmpty' is not a constant, only constant expressions are allowed."
   analyzerCode: NON_CONSTANT_VALUE_IN_INITIALIZER
diff --git a/pkg/front_end/test/macros/data/pkgs/macro/lib/macro.dart b/pkg/front_end/test/macros/data/pkgs/macro/lib/macro.dart
index d7bf92d..c7fc7d5 100644
--- a/pkg/front_end/test/macros/data/pkgs/macro/lib/macro.dart
+++ b/pkg/front_end/test/macros/data/pkgs/macro/lib/macro.dart
@@ -6,14 +6,20 @@
 
 macro class Macro1 implements Macro {
   const Macro1();
+
+  const Macro1.named();
 }
 
 macro class Macro2 implements Macro {
   const Macro2();
+
+  const Macro2.named();
 }
 
-macro class Macro3 implements Macro {
+macro class Macro3<T> implements Macro {
   const Macro3();
+
+  const Macro3.named();
 }
 
 class NonMacro {
diff --git a/pkg/front_end/test/macros/data/tests/applications.dart b/pkg/front_end/test/macros/data/tests/applications.dart
new file mode 100644
index 0000000..804253c
--- /dev/null
+++ b/pkg/front_end/test/macros/data/tests/applications.dart
@@ -0,0 +1,58 @@
+// 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: 
+ compilationSequence=[
+  package:_fe_analyzer_shared/src/macros/api.dart,
+  package:macro/macro.dart,
+  main.dart],
+ macrosAreApplied,
+ macrosAreAvailable
+*/
+
+import 'package:macro/macro.dart';
+import 'package:macro/macro.dart' as prefix;
+
+/*class: Class:
+ appliedMacros=[
+  Macro1.new,
+  Macro2.named,
+  Macro2.new,
+  Macro3.named],
+ macrosAreApplied
+*/
+@Macro2.named()
+@prefix.Macro2()
+@prefix.Macro3.named()
+@Macro1()
+class Class {
+  /*member: Class.:appliedMacros=[
+    Macro1.named,
+    Macro1.new,
+    Macro2.named,
+    Macro3.new]*/
+  @Macro1.named()
+  @prefix.Macro1()
+  @prefix.Macro2.named()
+  @Macro3()
+  Class();
+
+  /*member: Class.method:appliedMacros=[Macro3.named]*/
+  @Macro3.named()
+  void method() {}
+
+  /*member: Class.field:appliedMacros=[Macro3.new]*/
+  @prefix.Macro3()
+  var field;
+}
+
+/*member: method:appliedMacros=[Macro2.named]*/
+@Macro2.named()
+void method() {}
+
+@Macro3()
+/*member: field:appliedMacros=[Macro3.new]*/
+var field;
+
+main() {}
diff --git a/pkg/front_end/test/macros/data/tests/declare_vs_apply/apply_lib.dart b/pkg/front_end/test/macros/data/tests/declare_vs_apply/apply_lib.dart
index f4e6484..fc6ae56 100644
--- a/pkg/front_end/test/macros/data/tests/declare_vs_apply/apply_lib.dart
+++ b/pkg/front_end/test/macros/data/tests/declare_vs_apply/apply_lib.dart
@@ -10,9 +10,9 @@
 import 'macro_lib.dart';
 import 'apply_lib_dep.dart';
 
-@Macro1()
 /*class: Class:
- appliedMacros=[Macro1],
+ appliedMacros=[Macro1.new],
  macrosAreApplied
 */
+@Macro1()
 class Class extends Super {}
diff --git a/pkg/front_end/test/macros/data/tests/multiple_macros/macro_lib2b.dart b/pkg/front_end/test/macros/data/tests/multiple_macros/macro_lib2b.dart
index 1c2e947..3aa757c 100644
--- a/pkg/front_end/test/macros/data/tests/multiple_macros/macro_lib2b.dart
+++ b/pkg/front_end/test/macros/data/tests/multiple_macros/macro_lib2b.dart
@@ -11,11 +11,11 @@
 import 'package:_fe_analyzer_shared/src/macros/api.dart';
 import 'macro_lib2a.dart';
 
-@Macro2a()
 /*class: Macro2b:
- appliedMacros=[Macro2a],
+ appliedMacros=[Macro2a.new],
  macrosAreApplied
 */
+@Macro2a()
 macro class Macro2b implements Macro {
   const Macro2b();
 }
diff --git a/pkg/front_end/test/macros/data/tests/multiple_macros/main.dart b/pkg/front_end/test/macros/data/tests/multiple_macros/main.dart
index 9a3839e..455b1b1 100644
--- a/pkg/front_end/test/macros/data/tests/multiple_macros/main.dart
+++ b/pkg/front_end/test/macros/data/tests/multiple_macros/main.dart
@@ -16,11 +16,11 @@
 import 'macro_lib2a.dart';
 import 'macro_lib2b.dart';
 
+/*member: main:appliedMacros=[
+  Macro1.new,
+  Macro2a.new,
+  Macro2b.new]*/
 @Macro1()
 @Macro2a()
 @Macro2b()
-/*member: main:appliedMacros=[
-  Macro1,
-  Macro2a,
-  Macro2b]*/
 void main() {}
diff --git a/pkg/front_end/test/macros/data/tests/use_macro_package.dart b/pkg/front_end/test/macros/data/tests/use_macro_package.dart
index a830bb3..241eda8 100644
--- a/pkg/front_end/test/macros/data/tests/use_macro_package.dart
+++ b/pkg/front_end/test/macros/data/tests/use_macro_package.dart
@@ -14,25 +14,25 @@
 
 import 'package:macro/macro.dart';
 
+/*member: main:appliedMacros=[Macro1.new]*/
 @Macro1()
-/*member: main:appliedMacros=[Macro1]*/
 void main() {}
 
-@Macro2()
 /*class: Class1:
- appliedMacros=[Macro2],
+ appliedMacros=[Macro2.new],
  macrosAreApplied
 */
+@Macro2()
 class Class1 {
+  /*member: Class1.:appliedMacros=[Macro3.new]*/
   @Macro3()
-  /*member: Class1.:appliedMacros=[Macro3]*/
   Class1();
 
+  /*member: Class1.method:appliedMacros=[
+    Macro1.new,
+    Macro2.new]*/
   @Macro1()
   @Macro2()
-  /*member: Class1.method:appliedMacros=[
-    Macro1,
-    Macro2]*/
   void method() {}
 }
 
@@ -41,8 +41,8 @@
 
 /*class: Class3:macrosAreApplied*/
 class Class3 {
+  /*member: Class3.field:appliedMacros=[Macro3.new]*/
   @Macro3()
-  /*member: Class3.field:appliedMacros=[Macro3]*/
   var field;
 }
 
@@ -51,20 +51,20 @@
   var field;
 }
 
+/*member: field:appliedMacros=[Macro1.new]*/
 @Macro1()
-/*member: field:appliedMacros=[Macro1]*/
 var field;
 
 extension Extension on int {
+  /*member: Extension|field:*/
   @Macro1()
-  /*member: Extension|field:appliedMacros=[Macro1]*/
   static var field;
 
+  /*member: Extension|method:*/
   @Macro2()
-  /*member: Extension|method:appliedMacros=[Macro2]*/
   void method() {}
 
+  /*member: Extension|staticMethod:*/
   @Macro3()
-  /*member: Extension|staticMethod:appliedMacros=[Macro3]*/
   static void staticMethod() {}
 }
diff --git a/pkg/front_end/test/macros/data/tests/use_macro_source/main.dart b/pkg/front_end/test/macros/data/tests/use_macro_source/main.dart
index 7c78a01..026aeb3 100644
--- a/pkg/front_end/test/macros/data/tests/use_macro_source/main.dart
+++ b/pkg/front_end/test/macros/data/tests/use_macro_source/main.dart
@@ -13,21 +13,21 @@
 
 import 'macro_lib.dart';
 
+/*member: main:appliedMacros=[Macro1.new]*/
 @Macro1()
-/*member: main:appliedMacros=[Macro1]*/
 void main() {}
 
-@Macro2()
 /*class: Class1:
- appliedMacros=[Macro2],
+ appliedMacros=[Macro2.new],
  macrosAreApplied
 */
+@Macro2()
 class Class1 {
+  /*member: Class1.method:appliedMacros=[
+    Macro1.new,
+    Macro2.new]*/
   @Macro1()
   @Macro2()
-  /*member: Class1.method:appliedMacros=[
-    Macro1,
-    Macro2]*/
   void method() {}
 }
 
@@ -36,8 +36,8 @@
 
 /*class: Class3:macrosAreApplied*/
 class Class3 {
+  /*member: Class3.field:appliedMacros=[Macro1.new]*/
   @Macro1()
-  /*member: Class3.field:appliedMacros=[Macro1]*/
   var field;
 }
 
diff --git a/pkg/front_end/test/macros/macro_test.dart b/pkg/front_end/test/macros/macro_test.dart
index 6042432..ee92293 100644
--- a/pkg/front_end/test/macros/macro_test.dart
+++ b/pkg/front_end/test/macros/macro_test.dart
@@ -139,8 +139,13 @@
   void registerMacroApplications(
       Features features, MacroApplications? macroApplications) {
     if (macroApplications != null) {
-      for (Class cls in macroApplications.macros) {
-        features.addElement(Tags.appliedMacros, cls.name);
+      for (MacroApplication application in macroApplications.macros) {
+        String className = application.cls.name;
+        String constructorName = application.constructorName == ''
+            ? 'new'
+            : application.constructorName;
+        features.addElement(
+            Tags.appliedMacros, '${className}.${constructorName}');
       }
     }
   }
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index 81e6368..dd3fd3e 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -766,6 +766,7 @@
 masking
 masks
 master
+mature
 mb
 mc
 md
@@ -964,6 +965,7 @@
 pow
 pragma
 pre
+prebuild
 prebuilt
 preexisted
 preexisting
diff --git a/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.expect b/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.expect
index be365f6..a0f8836 100644
--- a/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.expect
+++ b/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.expect
@@ -34,7 +34,7 @@
 // pkg/front_end/testcases/general/constants/const_asserts.dart:34:24: Error: Constant evaluation error:
 // const Foo foo4 = const Foo.withInvalidMessage(42);
 //                        ^
-// pkg/front_end/testcases/general/constants/const_asserts.dart:16:56: Context: Expected constant '42' to be of type 'String', but was of type 'int'.
+// pkg/front_end/testcases/general/constants/const_asserts.dart:16:56: Context: This assertion failed with a non-String message.
 //   const Foo.withInvalidMessage(this.x) : assert(x < 0, x);
 //                                                        ^
 // pkg/front_end/testcases/general/constants/const_asserts.dart:34:11: Context: While analyzing:
@@ -182,7 +182,7 @@
 static const field self::Foo* foo1 = #C4;
 static const field self::Foo* foo2 = invalid-expression "This assertion failed with message: x is not positive";
 static const field self::Foo* foo3 = invalid-expression "This assertion failed with message: btw foo was false";
-static const field self::Foo* foo4 = invalid-expression "Expected constant '42' to be of type 'String', but was of type 'int'.";
+static const field self::Foo* foo4 = invalid-expression "This assertion failed with a non-String message.";
 static const field self::Foo* foo5 = invalid-expression "pkg/front_end/testcases/general/constants/const_asserts.dart:17:51: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   const Foo.withInvalidCondition(this.x) : assert(x);
                                                   ^";
diff --git a/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.modular.expect b/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.modular.expect
index be365f6..a0f8836 100644
--- a/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.modular.expect
@@ -34,7 +34,7 @@
 // pkg/front_end/testcases/general/constants/const_asserts.dart:34:24: Error: Constant evaluation error:
 // const Foo foo4 = const Foo.withInvalidMessage(42);
 //                        ^
-// pkg/front_end/testcases/general/constants/const_asserts.dart:16:56: Context: Expected constant '42' to be of type 'String', but was of type 'int'.
+// pkg/front_end/testcases/general/constants/const_asserts.dart:16:56: Context: This assertion failed with a non-String message.
 //   const Foo.withInvalidMessage(this.x) : assert(x < 0, x);
 //                                                        ^
 // pkg/front_end/testcases/general/constants/const_asserts.dart:34:11: Context: While analyzing:
@@ -182,7 +182,7 @@
 static const field self::Foo* foo1 = #C4;
 static const field self::Foo* foo2 = invalid-expression "This assertion failed with message: x is not positive";
 static const field self::Foo* foo3 = invalid-expression "This assertion failed with message: btw foo was false";
-static const field self::Foo* foo4 = invalid-expression "Expected constant '42' to be of type 'String', but was of type 'int'.";
+static const field self::Foo* foo4 = invalid-expression "This assertion failed with a non-String message.";
 static const field self::Foo* foo5 = invalid-expression "pkg/front_end/testcases/general/constants/const_asserts.dart:17:51: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   const Foo.withInvalidCondition(this.x) : assert(x);
                                                   ^";
diff --git a/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.transformed.expect b/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.transformed.expect
index 8d10eb2..c635add 100644
--- a/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/constants/const_asserts.dart.weak.transformed.expect
@@ -34,7 +34,7 @@
 // pkg/front_end/testcases/general/constants/const_asserts.dart:34:24: Error: Constant evaluation error:
 // const Foo foo4 = const Foo.withInvalidMessage(42);
 //                        ^
-// pkg/front_end/testcases/general/constants/const_asserts.dart:16:56: Context: Expected constant '42' to be of type 'String', but was of type 'int'.
+// pkg/front_end/testcases/general/constants/const_asserts.dart:16:56: Context: This assertion failed with a non-String message.
 //   const Foo.withInvalidMessage(this.x) : assert(x < 0, x);
 //                                                        ^
 // pkg/front_end/testcases/general/constants/const_asserts.dart:34:11: Context: While analyzing:
@@ -182,7 +182,7 @@
 static const field self::Foo* foo1 = #C4;
 static const field self::Foo* foo2 = invalid-expression "This assertion failed with message: x is not positive";
 static const field self::Foo* foo3 = invalid-expression "This assertion failed with message: btw foo was false";
-static const field self::Foo* foo4 = invalid-expression "Expected constant '42' to be of type 'String', but was of type 'int'.";
+static const field self::Foo* foo4 = invalid-expression "This assertion failed with a non-String message.";
 static const field self::Foo* foo5 = invalid-expression "pkg/front_end/testcases/general/constants/const_asserts.dart:17:51: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   const Foo.withInvalidCondition(this.x) : assert(x);
                                                   ^";
diff --git a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.expect b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.expect
index 9f6cb29..9106d0c 100644
--- a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.expect
+++ b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.expect
@@ -19,7 +19,7 @@
 // pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:28:24: Error: Constant evaluation error:
 // const Foo foo4 = const Foo.withInvalidMessage(42);
 //                        ^
-// pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:15:56: Context: Expected constant '42' to be of type 'String', but was of type 'int'.
+// pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:15:56: Context: This assertion failed with a non-String message.
 //   const Foo.withInvalidMessage(this.x) : assert(x < 0, x);
 //                                                        ^
 // pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:28:11: Context: While analyzing:
@@ -98,7 +98,7 @@
 static const field self::Foo foo1 = #C9;
 static const field self::Foo foo2 = invalid-expression "This assertion failed with message: x is not positive";
 static const field self::Foo foo3 = #C12;
-static const field self::Foo foo4 = invalid-expression "Expected constant '42' to be of type 'String', but was of type 'int'.";
+static const field self::Foo foo4 = invalid-expression "This assertion failed with a non-String message.";
 static const field self::Foo foo5 = invalid-expression "pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:16:51: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   const Foo.withInvalidCondition(this.x) : assert(x);
                                                   ^";
diff --git a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.modular.expect b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.modular.expect
index 9f6cb29..9106d0c 100644
--- a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.modular.expect
@@ -19,7 +19,7 @@
 // pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:28:24: Error: Constant evaluation error:
 // const Foo foo4 = const Foo.withInvalidMessage(42);
 //                        ^
-// pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:15:56: Context: Expected constant '42' to be of type 'String', but was of type 'int'.
+// pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:15:56: Context: This assertion failed with a non-String message.
 //   const Foo.withInvalidMessage(this.x) : assert(x < 0, x);
 //                                                        ^
 // pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:28:11: Context: While analyzing:
@@ -98,7 +98,7 @@
 static const field self::Foo foo1 = #C9;
 static const field self::Foo foo2 = invalid-expression "This assertion failed with message: x is not positive";
 static const field self::Foo foo3 = #C12;
-static const field self::Foo foo4 = invalid-expression "Expected constant '42' to be of type 'String', but was of type 'int'.";
+static const field self::Foo foo4 = invalid-expression "This assertion failed with a non-String message.";
 static const field self::Foo foo5 = invalid-expression "pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:16:51: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   const Foo.withInvalidCondition(this.x) : assert(x);
                                                   ^";
diff --git a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.transformed.expect b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.transformed.expect
index 0bcf7671..d6b50e0 100644
--- a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart.weak.transformed.expect
@@ -19,7 +19,7 @@
 // pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:28:24: Error: Constant evaluation error:
 // const Foo foo4 = const Foo.withInvalidMessage(42);
 //                        ^
-// pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:15:56: Context: Expected constant '42' to be of type 'String', but was of type 'int'.
+// pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:15:56: Context: This assertion failed with a non-String message.
 //   const Foo.withInvalidMessage(this.x) : assert(x < 0, x);
 //                                                        ^
 // pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:28:11: Context: While analyzing:
@@ -98,7 +98,7 @@
 static const field self::Foo foo1 = #C9;
 static const field self::Foo foo2 = invalid-expression "This assertion failed with message: x is not positive";
 static const field self::Foo foo3 = #C12;
-static const field self::Foo foo4 = invalid-expression "Expected constant '42' to be of type 'String', but was of type 'int'.";
+static const field self::Foo foo4 = invalid-expression "This assertion failed with a non-String message.";
 static const field self::Foo foo5 = invalid-expression "pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/const_asserts.dart:16:51: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   const Foo.withInvalidCondition(this.x) : assert(x);
                                                   ^";
diff --git a/pkg/front_end/testcases/general/issue47994a.dart b/pkg/front_end/testcases/general/issue47994a.dart
new file mode 100644
index 0000000..a669064
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994a.dart
@@ -0,0 +1,22 @@
+// 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.
+
+class Const {
+  const Const();
+}
+
+class BuildAssert {
+  const BuildAssert(bool condition, [Object? message])
+      : assert(condition, message);
+}
+
+const _assert1 = BuildAssert(false);
+const _assert2 = BuildAssert(false, null);
+const _assert3 = BuildAssert(false, 'foo');
+const _assert4 = BuildAssert(false, 0);
+const _assert5 = BuildAssert(false, const {});
+const _assert6 = BuildAssert(false, #_symbol);
+const _assert7 = BuildAssert(false, const Const());
+
+void main() {}
diff --git a/pkg/front_end/testcases/general/issue47994a.dart.textual_outline.expect b/pkg/front_end/testcases/general/issue47994a.dart.textual_outline.expect
new file mode 100644
index 0000000..11ad895
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994a.dart.textual_outline.expect
@@ -0,0 +1,17 @@
+class Const {
+  const Const();
+}
+
+class BuildAssert {
+  const BuildAssert(bool condition, [Object? message])
+      : assert(condition, message);
+}
+
+const _assert1 = BuildAssert(false);
+const _assert2 = BuildAssert(false, null);
+const _assert3 = BuildAssert(false, 'foo');
+const _assert4 = BuildAssert(false, 0);
+const _assert5 = BuildAssert(false, const {});
+const _assert6 = BuildAssert(false, #_symbol);
+const _assert7 = BuildAssert(false, const Const());
+void main() {}
diff --git a/pkg/front_end/testcases/general/issue47994a.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/issue47994a.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..96343a0
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994a.dart.textual_outline_modelled.expect
@@ -0,0 +1,17 @@
+class BuildAssert {
+  const BuildAssert(bool condition, [Object? message])
+      : assert(condition, message);
+}
+
+class Const {
+  const Const();
+}
+
+const _assert1 = BuildAssert(false);
+const _assert2 = BuildAssert(false, null);
+const _assert3 = BuildAssert(false, 'foo');
+const _assert4 = BuildAssert(false, 0);
+const _assert5 = BuildAssert(false, const {});
+const _assert6 = BuildAssert(false, #_symbol);
+const _assert7 = BuildAssert(false, const Const());
+void main() {}
diff --git a/pkg/front_end/testcases/general/issue47994a.dart.weak.expect b/pkg/front_end/testcases/general/issue47994a.dart.weak.expect
new file mode 100644
index 0000000..af71fb3
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994a.dart.weak.expect
@@ -0,0 +1,106 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/issue47994a.dart:14:18: Error: Constant evaluation error:
+// const _assert1 = BuildAssert(false);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed.
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:14:7: Context: While analyzing:
+// const _assert1 = BuildAssert(false);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:15:18: Error: Constant evaluation error:
+// const _assert2 = BuildAssert(false, null);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed.
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:15:7: Context: While analyzing:
+// const _assert2 = BuildAssert(false, null);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:16:18: Error: Constant evaluation error:
+// const _assert3 = BuildAssert(false, 'foo');
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed with message: foo
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:16:7: Context: While analyzing:
+// const _assert3 = BuildAssert(false, 'foo');
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:17:18: Error: Constant evaluation error:
+// const _assert4 = BuildAssert(false, 0);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:17:7: Context: While analyzing:
+// const _assert4 = BuildAssert(false, 0);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:18:18: Error: Constant evaluation error:
+// const _assert5 = BuildAssert(false, const {});
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:18:7: Context: While analyzing:
+// const _assert5 = BuildAssert(false, const {});
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:19:18: Error: Constant evaluation error:
+// const _assert6 = BuildAssert(false, #_symbol);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:19:7: Context: While analyzing:
+// const _assert6 = BuildAssert(false, #_symbol);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:20:18: Error: Constant evaluation error:
+// const _assert7 = BuildAssert(false, const Const());
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:20:7: Context: While analyzing:
+// const _assert7 = BuildAssert(false, const Const());
+//       ^
+//
+import self as self;
+import "dart:core" as core;
+
+class Const extends core::Object /*hasConstConstructor*/  {
+  const constructor •() → self::Const
+    : super core::Object::•()
+    ;
+}
+class BuildAssert extends core::Object /*hasConstConstructor*/  {
+  const constructor •(core::bool condition, [core::Object? message = #C1]) → self::BuildAssert
+    : assert(condition, message), super core::Object::•()
+    ;
+}
+static const field self::BuildAssert _assert1 = invalid-expression "This assertion failed.";
+static const field self::BuildAssert _assert2 = invalid-expression "This assertion failed.";
+static const field self::BuildAssert _assert3 = invalid-expression "This assertion failed with message: foo";
+static const field self::BuildAssert _assert4 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert5 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert6 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert7 = invalid-expression "This assertion failed with a non-String message.";
+static method main() → void {}
+
+constants  {
+  #C1 = null
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue47994a.dart:
+- BuildAssert. (from org-dartlang-testcase:///issue47994a.dart:10:9)
+- Const. (from org-dartlang-testcase:///issue47994a.dart:6:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/general/issue47994a.dart.weak.modular.expect b/pkg/front_end/testcases/general/issue47994a.dart.weak.modular.expect
new file mode 100644
index 0000000..af71fb3
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994a.dart.weak.modular.expect
@@ -0,0 +1,106 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/issue47994a.dart:14:18: Error: Constant evaluation error:
+// const _assert1 = BuildAssert(false);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed.
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:14:7: Context: While analyzing:
+// const _assert1 = BuildAssert(false);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:15:18: Error: Constant evaluation error:
+// const _assert2 = BuildAssert(false, null);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed.
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:15:7: Context: While analyzing:
+// const _assert2 = BuildAssert(false, null);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:16:18: Error: Constant evaluation error:
+// const _assert3 = BuildAssert(false, 'foo');
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed with message: foo
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:16:7: Context: While analyzing:
+// const _assert3 = BuildAssert(false, 'foo');
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:17:18: Error: Constant evaluation error:
+// const _assert4 = BuildAssert(false, 0);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:17:7: Context: While analyzing:
+// const _assert4 = BuildAssert(false, 0);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:18:18: Error: Constant evaluation error:
+// const _assert5 = BuildAssert(false, const {});
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:18:7: Context: While analyzing:
+// const _assert5 = BuildAssert(false, const {});
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:19:18: Error: Constant evaluation error:
+// const _assert6 = BuildAssert(false, #_symbol);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:19:7: Context: While analyzing:
+// const _assert6 = BuildAssert(false, #_symbol);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:20:18: Error: Constant evaluation error:
+// const _assert7 = BuildAssert(false, const Const());
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:20:7: Context: While analyzing:
+// const _assert7 = BuildAssert(false, const Const());
+//       ^
+//
+import self as self;
+import "dart:core" as core;
+
+class Const extends core::Object /*hasConstConstructor*/  {
+  const constructor •() → self::Const
+    : super core::Object::•()
+    ;
+}
+class BuildAssert extends core::Object /*hasConstConstructor*/  {
+  const constructor •(core::bool condition, [core::Object? message = #C1]) → self::BuildAssert
+    : assert(condition, message), super core::Object::•()
+    ;
+}
+static const field self::BuildAssert _assert1 = invalid-expression "This assertion failed.";
+static const field self::BuildAssert _assert2 = invalid-expression "This assertion failed.";
+static const field self::BuildAssert _assert3 = invalid-expression "This assertion failed with message: foo";
+static const field self::BuildAssert _assert4 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert5 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert6 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert7 = invalid-expression "This assertion failed with a non-String message.";
+static method main() → void {}
+
+constants  {
+  #C1 = null
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue47994a.dart:
+- BuildAssert. (from org-dartlang-testcase:///issue47994a.dart:10:9)
+- Const. (from org-dartlang-testcase:///issue47994a.dart:6:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/general/issue47994a.dart.weak.outline.expect b/pkg/front_end/testcases/general/issue47994a.dart.weak.outline.expect
new file mode 100644
index 0000000..0347e2e
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994a.dart.weak.outline.expect
@@ -0,0 +1,30 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class Const extends core::Object /*hasConstConstructor*/  {
+  const constructor •() → self::Const
+    : super core::Object::•()
+    ;
+}
+class BuildAssert extends core::Object /*hasConstConstructor*/  {
+  const constructor •(core::bool condition, [core::Object? message]) → self::BuildAssert
+    : assert(condition, message), super core::Object::•()
+    ;
+}
+static const field self::BuildAssert _assert1 = const self::BuildAssert::•(false);
+static const field self::BuildAssert _assert2 = const self::BuildAssert::•(false, null);
+static const field self::BuildAssert _assert3 = const self::BuildAssert::•(false, "foo");
+static const field self::BuildAssert _assert4 = const self::BuildAssert::•(false, 0);
+static const field self::BuildAssert _assert5 = const self::BuildAssert::•(false, const <dynamic, dynamic>{});
+static const field self::BuildAssert _assert6 = const self::BuildAssert::•(false, #_symbol);
+static const field self::BuildAssert _assert7 = const self::BuildAssert::•(false, const self::Const::•());
+static method main() → void
+  ;
+
+
+Extra constant evaluation status:
+Evaluated: MapLiteral @ org-dartlang-testcase:///issue47994a.dart:18:37 -> MapConstant(const <dynamic, dynamic>{})
+Evaluated: SymbolLiteral @ org-dartlang-testcase:///issue47994a.dart:19:37 -> SymbolConstant(#_symbol)
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///issue47994a.dart:20:43 -> InstanceConstant(const Const{})
+Extra constant evaluation: evaluated: 12, effectively constant: 3
diff --git a/pkg/front_end/testcases/general/issue47994a.dart.weak.transformed.expect b/pkg/front_end/testcases/general/issue47994a.dart.weak.transformed.expect
new file mode 100644
index 0000000..af71fb3
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994a.dart.weak.transformed.expect
@@ -0,0 +1,106 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/issue47994a.dart:14:18: Error: Constant evaluation error:
+// const _assert1 = BuildAssert(false);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed.
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:14:7: Context: While analyzing:
+// const _assert1 = BuildAssert(false);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:15:18: Error: Constant evaluation error:
+// const _assert2 = BuildAssert(false, null);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed.
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:15:7: Context: While analyzing:
+// const _assert2 = BuildAssert(false, null);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:16:18: Error: Constant evaluation error:
+// const _assert3 = BuildAssert(false, 'foo');
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:16: Context: This assertion failed with message: foo
+//       : assert(condition, message);
+//                ^
+// pkg/front_end/testcases/general/issue47994a.dart:16:7: Context: While analyzing:
+// const _assert3 = BuildAssert(false, 'foo');
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:17:18: Error: Constant evaluation error:
+// const _assert4 = BuildAssert(false, 0);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:17:7: Context: While analyzing:
+// const _assert4 = BuildAssert(false, 0);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:18:18: Error: Constant evaluation error:
+// const _assert5 = BuildAssert(false, const {});
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:18:7: Context: While analyzing:
+// const _assert5 = BuildAssert(false, const {});
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:19:18: Error: Constant evaluation error:
+// const _assert6 = BuildAssert(false, #_symbol);
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:19:7: Context: While analyzing:
+// const _assert6 = BuildAssert(false, #_symbol);
+//       ^
+//
+// pkg/front_end/testcases/general/issue47994a.dart:20:18: Error: Constant evaluation error:
+// const _assert7 = BuildAssert(false, const Const());
+//                  ^
+// pkg/front_end/testcases/general/issue47994a.dart:11:27: Context: This assertion failed with a non-String message.
+//       : assert(condition, message);
+//                           ^
+// pkg/front_end/testcases/general/issue47994a.dart:20:7: Context: While analyzing:
+// const _assert7 = BuildAssert(false, const Const());
+//       ^
+//
+import self as self;
+import "dart:core" as core;
+
+class Const extends core::Object /*hasConstConstructor*/  {
+  const constructor •() → self::Const
+    : super core::Object::•()
+    ;
+}
+class BuildAssert extends core::Object /*hasConstConstructor*/  {
+  const constructor •(core::bool condition, [core::Object? message = #C1]) → self::BuildAssert
+    : assert(condition, message), super core::Object::•()
+    ;
+}
+static const field self::BuildAssert _assert1 = invalid-expression "This assertion failed.";
+static const field self::BuildAssert _assert2 = invalid-expression "This assertion failed.";
+static const field self::BuildAssert _assert3 = invalid-expression "This assertion failed with message: foo";
+static const field self::BuildAssert _assert4 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert5 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert6 = invalid-expression "This assertion failed with a non-String message.";
+static const field self::BuildAssert _assert7 = invalid-expression "This assertion failed with a non-String message.";
+static method main() → void {}
+
+constants  {
+  #C1 = null
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue47994a.dart:
+- BuildAssert. (from org-dartlang-testcase:///issue47994a.dart:10:9)
+- Const. (from org-dartlang-testcase:///issue47994a.dart:6:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/general/issue47994b.dart b/pkg/front_end/testcases/general/issue47994b.dart
new file mode 100644
index 0000000..1fbaf90
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994b.dart
@@ -0,0 +1,70 @@
+// 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.
+
+class Const {
+  const Const();
+}
+
+class Class {
+  const Class(Object? message) : assert(false, message);
+}
+
+main() {
+  expect(null, test(() {
+    assert(false);
+  }));
+  expect(null, test(() {
+    assert(false, null);
+  }));
+  expect('foo', test(() {
+    assert(false, 'foo');
+  }));
+  expect(0, test(() {
+    assert(false, 0);
+  }));
+  expect(const {}, test(() {
+    assert(false, const {});
+  }));
+  expect(#_symbol, test(() {
+    assert(false, #_symbol);
+  }));
+  expect(const Const(), test(() {
+    assert(false, const Const());
+  }));
+
+  expect(null, test(() {
+    Class(null);
+  }));
+  expect('foo', test(() {
+    Class('foo');
+  }));
+  expect(0, test(() {
+    Class(0);
+  }));
+  expect(const {}, test(() {
+    Class(const {});
+  }));
+  expect(#_symbol, test(() {
+    Class(#_symbol);
+  }));
+  expect(const Const(), test(() {
+    Class(const Const());
+  }));
+}
+
+expect(expected, actual) {
+  if (expected != actual) throw 'Expected $expected, actual $actual';
+}
+
+Object? test(void Function() f) {
+  try {
+    f();
+  } on AssertionError catch (e) {
+    print(e);
+    return e.message;
+  } catch (e) {
+    throw 'Unexpected exception $e (${e.runtimeType}';
+  }
+  throw 'Missing exception';
+}
diff --git a/pkg/front_end/testcases/general/issue47994b.dart.textual_outline.expect b/pkg/front_end/testcases/general/issue47994b.dart.textual_outline.expect
new file mode 100644
index 0000000..e522fca
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994b.dart.textual_outline.expect
@@ -0,0 +1,11 @@
+class Const {
+  const Const();
+}
+
+class Class {
+  const Class(Object? message) : assert(false, message);
+}
+
+main() {}
+expect(expected, actual) {}
+Object? test(void Function() f) {}
diff --git a/pkg/front_end/testcases/general/issue47994b.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/issue47994b.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..84a681d
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994b.dart.textual_outline_modelled.expect
@@ -0,0 +1,12 @@
+Object? test(void Function() f) {}
+
+class Class {
+  const Class(Object? message) : assert(false, message);
+}
+
+class Const {
+  const Const();
+}
+
+expect(expected, actual) {}
+main() {}
diff --git a/pkg/front_end/testcases/general/issue47994b.dart.weak.expect b/pkg/front_end/testcases/general/issue47994b.dart.weak.expect
new file mode 100644
index 0000000..94d8be3
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994b.dart.weak.expect
@@ -0,0 +1,84 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class Const extends core::Object /*hasConstConstructor*/  {
+  const constructor •() → self::Const
+    : super core::Object::•()
+    ;
+}
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •(core::Object? message) → self::Class
+    : assert(false, message), super core::Object::•()
+    ;
+}
+static method main() → dynamic {
+  self::expect(null, self::test(() → void {
+    assert(false);
+  }));
+  self::expect(null, self::test(() → void {
+    assert(false, null);
+  }));
+  self::expect("foo", self::test(() → void {
+    assert(false, "foo");
+  }));
+  self::expect(0, self::test(() → void {
+    assert(false, 0);
+  }));
+  self::expect(#C1, self::test(() → void {
+    assert(false, #C1);
+  }));
+  self::expect(#C2, self::test(() → void {
+    assert(false, #C2);
+  }));
+  self::expect(#C3, self::test(() → void {
+    assert(false, #C3);
+  }));
+  self::expect(null, self::test(() → void {
+    new self::Class::•(null);
+  }));
+  self::expect("foo", self::test(() → void {
+    new self::Class::•("foo");
+  }));
+  self::expect(0, self::test(() → void {
+    new self::Class::•(0);
+  }));
+  self::expect(#C1, self::test(() → void {
+    new self::Class::•(#C1);
+  }));
+  self::expect(#C2, self::test(() → void {
+    new self::Class::•(#C2);
+  }));
+  self::expect(#C3, self::test(() → void {
+    new self::Class::•(#C3);
+  }));
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+static method test(() → void f) → core::Object? {
+  try {
+    f(){() → void};
+  }
+  on core::AssertionError catch(final core::AssertionError e) {
+    core::print(e);
+    return e.{core::AssertionError::message}{core::Object?};
+  }
+  on core::Object catch(final core::Object e) {
+    throw "Unexpected exception ${e} (${e.{core::Object::runtimeType}{core::Type}}";
+  }
+  throw "Missing exception";
+}
+
+constants  {
+  #C1 = <dynamic, dynamic>{)
+  #C2 = #org-dartlang-testcase:///issue47994b.dart::_symbol
+  #C3 = self::Const {}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue47994b.dart:
+- Const. (from org-dartlang-testcase:///issue47994b.dart:6:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/general/issue47994b.dart.weak.modular.expect b/pkg/front_end/testcases/general/issue47994b.dart.weak.modular.expect
new file mode 100644
index 0000000..94d8be3
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994b.dart.weak.modular.expect
@@ -0,0 +1,84 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class Const extends core::Object /*hasConstConstructor*/  {
+  const constructor •() → self::Const
+    : super core::Object::•()
+    ;
+}
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •(core::Object? message) → self::Class
+    : assert(false, message), super core::Object::•()
+    ;
+}
+static method main() → dynamic {
+  self::expect(null, self::test(() → void {
+    assert(false);
+  }));
+  self::expect(null, self::test(() → void {
+    assert(false, null);
+  }));
+  self::expect("foo", self::test(() → void {
+    assert(false, "foo");
+  }));
+  self::expect(0, self::test(() → void {
+    assert(false, 0);
+  }));
+  self::expect(#C1, self::test(() → void {
+    assert(false, #C1);
+  }));
+  self::expect(#C2, self::test(() → void {
+    assert(false, #C2);
+  }));
+  self::expect(#C3, self::test(() → void {
+    assert(false, #C3);
+  }));
+  self::expect(null, self::test(() → void {
+    new self::Class::•(null);
+  }));
+  self::expect("foo", self::test(() → void {
+    new self::Class::•("foo");
+  }));
+  self::expect(0, self::test(() → void {
+    new self::Class::•(0);
+  }));
+  self::expect(#C1, self::test(() → void {
+    new self::Class::•(#C1);
+  }));
+  self::expect(#C2, self::test(() → void {
+    new self::Class::•(#C2);
+  }));
+  self::expect(#C3, self::test(() → void {
+    new self::Class::•(#C3);
+  }));
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+static method test(() → void f) → core::Object? {
+  try {
+    f(){() → void};
+  }
+  on core::AssertionError catch(final core::AssertionError e) {
+    core::print(e);
+    return e.{core::AssertionError::message}{core::Object?};
+  }
+  on core::Object catch(final core::Object e) {
+    throw "Unexpected exception ${e} (${e.{core::Object::runtimeType}{core::Type}}";
+  }
+  throw "Missing exception";
+}
+
+constants  {
+  #C1 = <dynamic, dynamic>{)
+  #C2 = #org-dartlang-testcase:///issue47994b.dart::_symbol
+  #C3 = self::Const {}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue47994b.dart:
+- Const. (from org-dartlang-testcase:///issue47994b.dart:6:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/general/issue47994b.dart.weak.outline.expect b/pkg/front_end/testcases/general/issue47994b.dart.weak.outline.expect
new file mode 100644
index 0000000..ebe1a07
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994b.dart.weak.outline.expect
@@ -0,0 +1,20 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class Const extends core::Object /*hasConstConstructor*/  {
+  const constructor •() → self::Const
+    : super core::Object::•()
+    ;
+}
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •(core::Object? message) → self::Class
+    : assert(false, message), super core::Object::•()
+    ;
+}
+static method main() → dynamic
+  ;
+static method expect(dynamic expected, dynamic actual) → dynamic
+  ;
+static method test(() → void f) → core::Object?
+  ;
diff --git a/pkg/front_end/testcases/general/issue47994b.dart.weak.transformed.expect b/pkg/front_end/testcases/general/issue47994b.dart.weak.transformed.expect
new file mode 100644
index 0000000..94d8be3
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue47994b.dart.weak.transformed.expect
@@ -0,0 +1,84 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class Const extends core::Object /*hasConstConstructor*/  {
+  const constructor •() → self::Const
+    : super core::Object::•()
+    ;
+}
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •(core::Object? message) → self::Class
+    : assert(false, message), super core::Object::•()
+    ;
+}
+static method main() → dynamic {
+  self::expect(null, self::test(() → void {
+    assert(false);
+  }));
+  self::expect(null, self::test(() → void {
+    assert(false, null);
+  }));
+  self::expect("foo", self::test(() → void {
+    assert(false, "foo");
+  }));
+  self::expect(0, self::test(() → void {
+    assert(false, 0);
+  }));
+  self::expect(#C1, self::test(() → void {
+    assert(false, #C1);
+  }));
+  self::expect(#C2, self::test(() → void {
+    assert(false, #C2);
+  }));
+  self::expect(#C3, self::test(() → void {
+    assert(false, #C3);
+  }));
+  self::expect(null, self::test(() → void {
+    new self::Class::•(null);
+  }));
+  self::expect("foo", self::test(() → void {
+    new self::Class::•("foo");
+  }));
+  self::expect(0, self::test(() → void {
+    new self::Class::•(0);
+  }));
+  self::expect(#C1, self::test(() → void {
+    new self::Class::•(#C1);
+  }));
+  self::expect(#C2, self::test(() → void {
+    new self::Class::•(#C2);
+  }));
+  self::expect(#C3, self::test(() → void {
+    new self::Class::•(#C3);
+  }));
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+static method test(() → void f) → core::Object? {
+  try {
+    f(){() → void};
+  }
+  on core::AssertionError catch(final core::AssertionError e) {
+    core::print(e);
+    return e.{core::AssertionError::message}{core::Object?};
+  }
+  on core::Object catch(final core::Object e) {
+    throw "Unexpected exception ${e} (${e.{core::Object::runtimeType}{core::Type}}";
+  }
+  throw "Missing exception";
+}
+
+constants  {
+  #C1 = <dynamic, dynamic>{)
+  #C2 = #org-dartlang-testcase:///issue47994b.dart::_symbol
+  #C3 = self::Const {}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue47994b.dart:
+- Const. (from org-dartlang-testcase:///issue47994b.dart:6:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/text_serialization.status b/pkg/front_end/testcases/text_serialization.status
index 8d551bb..577ee4a 100644
--- a/pkg/front_end/testcases/text_serialization.status
+++ b/pkg/front_end/testcases/text_serialization.status
@@ -90,6 +90,7 @@
 general/issue41210b/issue41210.no_link: TypeCheckError
 general/issue41210b/issue41210: TypeCheckError
 general/issue44733: TypeCheckError
+general/issue47994b: RuntimeError # Assertions are not enabled
 general/issue_46886: RuntimeError
 general/micro: RuntimeError
 general/mixin_application_override: TypeCheckError
diff --git a/pkg/front_end/testcases/weak.status b/pkg/front_end/testcases/weak.status
index ae8b870..699bd29 100644
--- a/pkg/front_end/testcases/weak.status
+++ b/pkg/front_end/testcases/weak.status
@@ -104,6 +104,7 @@
 general/issue41210b/issue41210.no_link: TypeCheckError
 general/issue41210b/issue41210: TypeCheckError
 general/issue44733: TypeCheckError
+general/issue47994b: RuntimeError # Assertions are not enabled
 general/issue_46886: RuntimeError
 general/micro: RuntimeError
 general/mixin_application_override: ExpectationFileMismatch # Too many errors.
diff --git a/tools/VERSION b/tools/VERSION
index bc4419c..52d9513 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 16
 PATCH 0
-PRERELEASE 136
+PRERELEASE 137
 PRERELEASE_PATCH 0
\ No newline at end of file