Use Feature directly in resolution.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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 dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show
     Selectors;
+import '../common/resolution.dart' show
+    Feature;
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
     RedirectingFactoryConstantConstructor;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
@@ skipping 308 matching lines @@
       var functionName = enclosingElement.name;
       if (functionName == '') {
         kind = MessageKind.CANNOT_RESOLVE_AWAIT_IN_CLOSURE;
       } else {
         kind = MessageKind.CANNOT_RESOLVE_AWAIT;
         arguments['functionName'] = functionName;
       }
     } else {
       kind = MessageKind.CANNOT_RESOLVE;
     }
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     return reportAndCreateErroneousElement(
         node, name, kind, arguments, isError: inInitializer);
   }
 
   ResolutionResult visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         reporter.reportErrorMessage(
             node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
@@ skipping 145 matching lines @@
 
   ResolutionResult visitAssert(Assert node) {
     if (!compiler.enableAssertMessage) {
       if (node.hasMessage) {
         reporter.reportErrorMessage(
             node, MessageKind.EXPERIMENTAL_ASSERT_MESSAGE);
       }
     }
     // TODO(sra): We could completely ignore the assert in production mode if we
     // didn't need it to be resolved for type checking.
-    registry.registerAssert(node.hasMessage);
+    registry.registerFeature(
+        node.hasMessage ? Feature.ASSERT_WITH_MESSAGE : Feature.ASSERT);
     visit(node.condition);
     visit(node.message);
     return const NoneResult();
   }
 
   ResolutionResult visitCascade(Cascade node) {
     visit(node.expression);
     return const NoneResult();
   }
 
@@ skipping 253 matching lines @@
   }
 
   /// Check that access to `super` is currently allowed. Returns an
   /// [AccessSemantics] in case of an error, `null` otherwise.
   AccessSemantics checkSuperAccess(Send node) {
     if (!inInstanceContext) {
       ErroneousElement error = reportAndCreateErroneousElement(
           node, 'super',
           MessageKind.NO_SUPER_IN_STATIC, {},
           isError: true);
-      registry.registerCompileTimeError(error);
+      registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       return new StaticAccess.invalid(error);
     }
     if (node.isConditional) {
       // `super?.foo` is not allowed.
       ErroneousElement error = reportAndCreateErroneousElement(
           node, 'super',
           MessageKind.INVALID_USE_OF_SUPER, {},
           isError: true);
-      registry.registerCompileTimeError(error);
+      registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       return new StaticAccess.invalid(error);
     }
     if (currentClass.supertype == null) {
       // This is just to guard against internal errors, so no need
       // for a real error message.
       ErroneousElement error = reportAndCreateErroneousElement(
           node, 'super',
           MessageKind.GENERIC,
           {'text': "Object has no superclass"},
           isError: true);
-      registry.registerCompileTimeError(error);
+      registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       return new StaticAccess.invalid(error);
     }
     registry.registerSuperUse(node);
     return null;
   }
 
   /// Check that access to `this` is currently allowed. Returns an
   /// [AccessSemantics] in case of an error, `null` otherwise.
   AccessSemantics checkThisAccess(Send node) {
     if (!inInstanceContext) {
       ErroneousElement error = reportAndCreateErroneousElement(
           node, 'this',
           MessageKind.NO_THIS_AVAILABLE, const {},
           isError: true);
-      registry.registerCompileTimeError(error);
+      registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       return new StaticAccess.invalid(error);
     }
     return null;
   }
 
   /// Compute the [AccessSemantics] corresponding to a super access of [target].
   AccessSemantics computeSuperAccessSemantics(Spannable node, Element target) {
     if (target.isMalformed) {
       return new StaticAccess.unresolvedSuper(target);
     } else if (target.isGetter) {
@@ skipping 204 matching lines @@
           node, name.text, MessageKind.NO_SUCH_SUPER_MEMBER,
           {'className': currentClass.name, 'memberName': name});
       }
       if (target == null) {
         // If a setter wasn't resolved, use the [ErroneousElement].
         target = error;
       }
       // We still need to register the invocation, because we might
       // call [:super.noSuchMethod:] which calls [JSInvocationMirror._invokeOn].
       registry.registerDynamicUse(new DynamicUse(selector, null));
-      registry.registerSuperNoSuchMethod();
+      registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
     }
     return computeSuperAccessSemantics(node, target);
   }
 
   /// Compute the [AccessSemantics] for accessing the name of [selector] on the
   /// super class.
   ///
   /// If no matching super member is found and error is reported and
   /// `noSuchMethod` on `super` is registered. Furthermore, if [alternateName]
   /// is provided, the [AccessSemantics] corresponding to the alternate name is
@@ skipping 55 matching lines @@
       registry.registerDynamicUse(
           new DynamicUse(getterSelector, null));
     }
     if (setterError) {
       // We still need to register the invocation, because we might
       // call [:super.noSuchMethod:] which calls [JSInvocationMirror._invokeOn].
       registry.registerDynamicUse(
           new DynamicUse(setterSelector, null));
     }
     if (getterError || setterError) {
-      registry.registerSuperNoSuchMethod();
+      registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
     }
     return computeCompoundSuperAccessSemantics(
         node, getter, setter, isIndex: isIndex);
   }
 
   /// Resolve [node] as a subexpression that is _not_ the prefix of a member
   /// access. For instance `a` in `a + b`, as opposed to `a` in `a.b`.
   ResolutionResult visitExpression(Node node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
@@ skipping 476 matching lines @@
           node, selector, alternateName: name.setter);
     }
     if (node.isCall) {
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.SUPER_METHOD:
           MethodElementX superMethod = semantics.element;
           superMethod.computeType(resolution);
           if (!callStructure.signatureApplies(
                   superMethod.functionSignature)) {
-            registry.registerThrowNoSuchMethod();
+            registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(
                 new DynamicUse(selector, null));
-            registry.registerSuperNoSuchMethod();
+            registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
             isIncompatibleInvoke = true;
           } else {
             registry.registerStaticUse(
                 new StaticUse.superInvoke(semantics.element, callStructure));
           }
           break;
         case AccessKind.SUPER_FIELD:
         case AccessKind.SUPER_FINAL_FIELD:
         case AccessKind.SUPER_GETTER:
           registry.registerStaticUse(
@@ skipping 113 matching lines @@
       }
     }
   }
 
   /// Handle qualified access to an unresolved static class member, like `a.b`
   /// or `a.b()` where `a` is a class and `b` is unresolved.
   ResolutionResult handleUnresolvedStaticMemberAccess(
       Send node, Name name, ClassElement receiverClass) {
     // TODO(johnniwinther): Share code with [handleStaticInstanceMemberAccess]
     // and [handlePrivateStaticMemberAccess].
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     // TODO(johnniwinther): Produce a different error if [name] is resolves to
     // a constructor.
 
     // TODO(johnniwinther): With the simplified [TreeElements] invariant,
     // try to resolve injected elements if [currentClass] is in the patch
     // library of [receiverClass].
 
     // TODO(karlklose): this should be reported by the caller of
     // [resolveSend] to select better warning messages for getters and
     // setters.
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.MEMBER_NOT_FOUND,
         {'className': receiverClass.name, 'memberName': name.text});
     // TODO(johnniwinther): Add an [AccessSemantics] for unresolved static
     // member access.
     return handleErroneousAccess(
         node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified update to an unresolved static class member, like
   /// `a.b = c` or `a.b++` where `a` is a class and `b` is unresolved.
   ResolutionResult handleUnresolvedStaticMemberUpdate(
       SendSet node, Name name, ClassElement receiverClass) {
     // TODO(johnniwinther): Share code with [handleStaticInstanceMemberUpdate]
     // and [handlePrivateStaticMemberUpdate].
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     // TODO(johnniwinther): Produce a different error if [name] is resolves to
     // a constructor.
 
     // TODO(johnniwinther): With the simplified [TreeElements] invariant,
     // try to resolve injected elements if [currentClass] is in the patch
     // library of [receiverClass].
 
     // TODO(johnniwinther): Produce a different error for complex update.
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.MEMBER_NOT_FOUND,
         {'className': receiverClass.name, 'memberName': name.text});
     // TODO(johnniwinther): Add an [AccessSemantics] for unresolved static
     // member access.
     return handleUpdate(node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified access of an instance member, like `a.b` or `a.b()` where
   /// `a` is a class and `b` is a non-static member.
   ResolutionResult handleStaticInstanceMemberAccess(
       Send node, Name name, ClassElement receiverClass, Element member) {
 
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     // TODO(johnniwinther): With the simplified [TreeElements] invariant,
     // try to resolve injected elements if [currentClass] is in the patch
     // library of [receiverClass].
 
     // TODO(karlklose): this should be reported by the caller of
     // [resolveSend] to select better warning messages for getters and
     // setters.
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.MEMBER_NOT_STATIC,
         {'className': receiverClass.name, 'memberName': name});
 
     // TODO(johnniwinther): Add an [AccessSemantics] for statically accessed
     // instance members.
     return handleErroneousAccess(
         node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified update of an instance member, like `a.b = c` or `a.b++`
   /// where `a` is a class and `b` is a non-static member.
   ResolutionResult handleStaticInstanceMemberUpdate(
       SendSet node, Name name, ClassElement receiverClass, Element member) {
 
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     // TODO(johnniwinther): With the simplified [TreeElements] invariant,
     // try to resolve injected elements if [currentClass] is in the patch
     // library of [receiverClass].
 
     // TODO(johnniwinther): Produce a different error for complex update.
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.MEMBER_NOT_STATIC,
         {'className': receiverClass.name, 'memberName': name});
 
     // TODO(johnniwinther): Add an [AccessSemantics] for statically accessed
     // instance members.
     return handleUpdate(node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified access of an inaccessible private static class member,
   /// like `a._b` or `a._b()` where `a` is class, `_b` is static member of `a`
   /// but `a` is not defined in the current library.
   ResolutionResult handlePrivateStaticMemberAccess(
       Send node, Name name, ClassElement receiverClass, Element member) {
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.PRIVATE_ACCESS,
         {'libraryName': member.library.libraryOrScriptName,
          'name': name});
     // TODO(johnniwinther): Add an [AccessSemantics] for unresolved static
     // member access.
     return handleErroneousAccess(
         node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified update of an inaccessible private static class member,
   /// like `a._b = c` or `a._b++` where `a` is class, `_b` is static member of
   /// `a` but `a` is not defined in the current library.
   ResolutionResult handlePrivateStaticMemberUpdate(
       SendSet node, Name name, ClassElement receiverClass, Element member) {
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.PRIVATE_ACCESS,
         {'libraryName': member.library.libraryOrScriptName,
          'name': name});
     // TODO(johnniwinther): Add an [AccessSemantics] for unresolved static
     // member access.
     return handleUpdate(node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified access to a static member, like `a.b` or `a.b()` where
@@ skipping 66 matching lines @@
       Name name,
       TypeVariableElement element) {
     AccessSemantics semantics;
     if (!Elements.hasAccessToTypeVariables(enclosingElement)) {
       // TODO(johnniwinther): Add another access semantics for this.
       ErroneousElement error = reportAndCreateErroneousElement(
           node, name.text,
           MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
           {'typeVariableName': name},
           isError: true);
-      registry.registerCompileTimeError(error);
+      registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       semantics = new StaticAccess.invalid(error);
       // TODO(johnniwinther): Clean up registration of elements and selectors
       // for this case.
     } else {
       semantics = new StaticAccess.typeParameterTypeLiteral(element);
     }
 
     registry.useElement(node, element);
     registry.registerTypeLiteral(node, element.type);
 
@@ skipping 21 matching lines @@
       Name name,
       TypeVariableElement element) {
     AccessSemantics semantics;
     if (!Elements.hasAccessToTypeVariables(enclosingElement)) {
       // TODO(johnniwinther): Add another access semantics for this.
       ErroneousElement error = reportAndCreateErroneousElement(
           node, name.text,
           MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
           {'typeVariableName': name},
           isError: true);
-      registry.registerCompileTimeError(error);
+      registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       semantics = new StaticAccess.invalid(error);
     } else {
       ErroneousElement error;
       if (node.isIfNullAssignment) {
         error = reportAndCreateErroneousElement(
             node.selector, name.text,
             MessageKind.IF_NULL_ASSIGNING_TYPE, const {});
         // TODO(23998): Remove these when all information goes through
         // the [SendStructure].
         registry.useElement(node.selector, element);
       } else {
         error = reportAndCreateErroneousElement(
             node.selector, name.text,
             MessageKind.ASSIGNING_TYPE, const {});
       }
 
       // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
       registry.useElement(node, error);
       // TODO(johnniwinther): Register only on read?
       registry.registerTypeLiteral(node, element.type);
-      registry.registerThrowNoSuchMethod();
+      registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
       semantics = new StaticAccess.typeParameterTypeLiteral(element);
     }
     return handleUpdate(node, name, semantics);
   }
 
   /// Handle access to a constant type literal of [type].
   // TODO(johnniwinther): Remove [name] when [Selector] is not required for the
   // the [GetStructure].
   // TODO(johnniwinther): Remove [element] when it is no longer needed for
   // evaluating constants.
@@ skipping 58 matching lines @@
     } else {
       error = reportAndCreateErroneousElement(
           node.selector, name.text,
           MessageKind.ASSIGNING_TYPE, const {});
     }
 
     // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.useElement(node, error);
     registry.registerTypeLiteral(node, type);
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
 
     return handleUpdate(node, name, semantics);
   }
 
   /// Handle access to a type literal of a typedef. Like `F` or
   /// `F()` where 'F' is typedef.
   ResolutionResult handleTypedefTypeLiteralAccess(
       Send node,
       Name name,
       TypedefElement typdef) {
@@ skipping 108 matching lines @@
   }
 
   /// Handle qualified [Send] where the receiver resolves to a [prefix],
   /// like `prefix.toplevelFunction()` or `prefix.Class.staticField` where
   /// `prefix` is a library prefix.
   ResolutionResult handleLibraryPrefixSend(
       Send node, Name name, PrefixElement prefix) {
     ResolutionResult result;
     Element member = prefix.lookupLocalMember(name.text);
     if (member == null) {
-      registry.registerThrowNoSuchMethod();
+      registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
       Element error = reportAndCreateErroneousElement(
           node, name.text, MessageKind.NO_SUCH_LIBRARY_MEMBER,
           {'libraryName': prefix.name, 'memberName': name});
       result = handleUnresolvedAccess(node, name, error);
     } else {
       result = handleResolvedSend(node, name, member);
     }
     if (result.kind == ResultKind.PREFIX) {
       // [member] is a class prefix of a static access like `prefix.Class` of
       // `prefix.Class.foo`. No need to call [handleDeferredAccess]; it will
       // called on the parent `prefix.Class.foo` node.
       result = new PrefixResult(prefix, result.element);
     } else if (prefix.isDeferred &&
                (member == null || !member.isDeferredLoaderGetter)) {
       result = handleDeferredAccess(node, prefix, result);
     }
     return result;
   }
 
   /// Handle qualified [SendSet] where the receiver resolves to a [prefix],
   /// like `prefix.toplevelField = b` or `prefix.Class.staticField++` where
   /// `prefix` is a library prefix.
   ResolutionResult handleLibraryPrefixSendSet(
       SendSet node, Name name, PrefixElement prefix) {
     ResolutionResult result;
     Element member = prefix.lookupLocalMember(name.text);
     if (member == null) {
-      registry.registerThrowNoSuchMethod();
+      registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
       Element error = reportAndCreateErroneousElement(
           node, name.text, MessageKind.NO_SUCH_LIBRARY_MEMBER,
           {'libraryName': prefix.name, 'memberName': name});
       return handleUpdate(node, name, new StaticAccess.unresolved(error));
     } else {
       result = handleResolvedSendSet(node, name, member);
     }
     if (result.kind == ResultKind.PREFIX) {
       // [member] is a class prefix of a static access like `prefix.Class` of
       // `prefix.Class.foo`. No need to call [handleDeferredAccess]; it will
@@ skipping 13 matching lines @@
       Send node,
       Name name,
       PrefixElement prefix) {
     if ((ElementCategory.PREFIX & allowedCategory) == 0) {
       ErroneousElement error = reportAndCreateErroneousElement(
           node,
           name.text,
           MessageKind.PREFIX_AS_EXPRESSION,
           {'prefix': name},
           isError: true);
-      registry.registerCompileTimeError(error);
+      registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       return handleErroneousAccess(
           node, name, new StaticAccess.invalid(error));
     }
     if (prefix.isDeferred) {
       // TODO(23998): Remove this when deferred access is detected
       // through a [SendStructure].
       registry.useElement(node.selector, prefix);
     }
     registry.useElement(node, prefix);
     return new PrefixResult(prefix, null);
@@ skipping 98 matching lines @@
     return handleUpdate(node, name, semantics);
   }
 
   /// Handle `this` as a qualified property, like `a.this`.
   ResolutionResult handleQualifiedThisAccess(Send node, Name name) {
     ErroneousElement error = reportAndCreateErroneousElement(
         node.selector,
         name.text,
         MessageKind.THIS_PROPERTY, {},
         isError: true);
-    registry.registerCompileTimeError(error);
+    registry.registerFeature(Feature.COMPILE_TIME_ERROR);
     AccessSemantics accessSemantics = new StaticAccess.invalid(error);
     return handleErroneousAccess(node, name, accessSemantics);
   }
 
   /// Handle a qualified [Send], that is where the receiver is non-null, like
   /// `a.b`, `a.b()`, `this.a()` and `super.a()`.
   ResolutionResult handleQualifiedSend(Send node) {
     Identifier selector = node.selector.asIdentifier();
     String text = selector.source;
     Name name = new Name(text, enclosingElement.library);
@@ skipping 98 matching lines @@
       Send node,
       Name name,
       AmbiguousElement element) {
 
     ErroneousElement error = reportAndCreateErroneousElement(
         node,
         name.text,
         element.messageKind,
         element.messageArguments,
         infos: element.computeInfos(enclosingElement, reporter));
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
 
     // TODO(johnniwinther): Support ambiguous access as an [AccessSemantics].
     AccessSemantics semantics = new StaticAccess.unresolved(error);
     return handleErroneousAccess(node, name, semantics);
   }
 
   /// Handle update to an ambiguous element, that is, a name imported twice.
   ResolutionResult handleAmbiguousUpdate(
       SendSet node,
       Name name,
       AmbiguousElement element) {
 
     ErroneousElement error = reportAndCreateErroneousElement(
         node,
         name.text,
         element.messageKind,
         element.messageArguments,
         infos: element.computeInfos(enclosingElement, reporter));
-    registry.registerThrowNoSuchMethod();
+    registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
 
     // TODO(johnniwinther): Support ambiguous access as an [AccessSemantics].
     AccessSemantics accessSemantics = new StaticAccess.unresolved(error);
     return handleUpdate(node, name, accessSemantics);
   }
 
   /// Report access of an instance [member] from a non-instance context.
   AccessSemantics reportStaticInstanceAccess(Send node, Name name) {
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text,
         MessageKind.NO_INSTANCE_AVAILABLE, {'name': name},
         isError: true);
     // TODO(johnniwinther): Support static instance access as an
     // [AccessSemantics].
-    registry.registerCompileTimeError(error);
+    registry.registerFeature(Feature.COMPILE_TIME_ERROR);
     return new StaticAccess.invalid(error);
   }
 
   /// Handle access of a parameter, local variable or local function.
   ResolutionResult handleLocalAccess(Send node, Name name, Element element) {
     ResolutionResult result = const NoneResult();
     AccessSemantics semantics = computeLocalAccessSemantics(node, element);
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       selector = new Selector.call(name, callStructure);
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.LOCAL_FUNCTION:
           LocalFunctionElementX function = semantics.element;
           function.computeType(resolution);
           if (!callStructure.signatureApplies(function.functionSignature)) {
-            registry.registerThrowNoSuchMethod();
+            registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(
                 new DynamicUse(selector, null));
             isIncompatibleInvoke = true;
           }
           break;
         case AccessKind.PARAMETER:
         case AccessKind.FINAL_PARAMETER:
         case AccessKind.LOCAL_VARIABLE:
         case AccessKind.FINAL_LOCAL_VARIABLE:
           selector = callStructure.callSelector;
@@ skipping 100 matching lines @@
       if (enclosingElement != element.enclosingElement) {
         registry.registerPotentialMutationInClosure(element, node);
       }
       for (Node scope in promotionScope) {
         registry.registerPotentialMutationIn(scope, element, node);
       }
     }
 
     ResolutionResult result = handleUpdate(node, name, semantics);
     if (error != null) {
-      registry.registerThrowNoSuchMethod();
+      registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
       // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
       registry.useElement(node, error);
     }
     return result;
   }
 
   /// Handle access of a static or top level [element].
   ResolutionResult handleStaticOrTopLevelAccess(
         Send node, Name name, Element element) {
@@ skipping 31 matching lines @@
       CallStructure callStructure = argumentsResult.callStructure;
       selector = new Selector.call(name, callStructure);
 
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.STATIC_METHOD:
         case AccessKind.TOPLEVEL_METHOD:
           MethodElement method = semantics.element;
           method.computeType(resolution);
           if (!callStructure.signatureApplies(method.functionSignature)) {
-            registry.registerThrowNoSuchMethod();
+            registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(
                 new DynamicUse(selector, null));
             isIncompatibleInvoke = true;
           } else {
             registry.registerStaticUse(
                 new StaticUse.staticInvoke(semantics.element, callStructure));
             handleForeignCall(node, semantics.element, callStructure);
             if (method == compiler.identicalFunction &&
                 argumentsResult.isValidAsConstant) {
               result = new ConstantResult(node,
@@ skipping 11 matching lines @@
         case AccessKind.TOPLEVEL_GETTER:
           registry.registerStaticUse(
               new StaticUse.staticGet(semantics.element));
           selector = callStructure.callSelector;
           registry.registerDynamicUse(
               new DynamicUse(selector, null));
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
-          registry.registerThrowNoSuchMethod();
+          registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           member = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
           break;
         default:
           reporter.internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
@@ skipping 13 matching lines @@
         case AccessKind.STATIC_GETTER:
         case AccessKind.TOPLEVEL_FIELD:
         case AccessKind.FINAL_TOPLEVEL_FIELD:
         case AccessKind.TOPLEVEL_GETTER:
           registry.registerStaticUse(
               new StaticUse.staticGet(semantics.element));
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
-          registry.registerThrowNoSuchMethod();
+          registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           member = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
           break;
         default:
           reporter.internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node, new GetStructure(semantics));
@@ skipping 17 matching lines @@
   /// Handle update of a static or top level [element].
   ResolutionResult handleStaticOrTopLevelUpdate(
         SendSet node, Name name, Element element) {
     AccessSemantics semantics;
     if (element.isAbstractField) {
       AbstractFieldElement abstractField = element;
       if (abstractField.setter == null) {
         ErroneousElement error = reportAndCreateErroneousElement(
             node.selector, name.text,
             MessageKind.CANNOT_RESOLVE_SETTER, const {});
-        registry.registerThrowNoSuchMethod();
+        registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
 
         if (node.isComplex) {
           // `a++` or `a += b` where `a` has no setter.
           semantics = new CompoundAccessSemantics(
               element.isTopLevel
                   ? CompoundAccessKind.UNRESOLVED_TOPLEVEL_SETTER
                   : CompoundAccessKind.UNRESOLVED_STATIC_SETTER,
               abstractField.getter,
               error);
         } else {
           // `a = b` where `a` has no setter.
           semantics = element.isTopLevel
               ? new StaticAccess.topLevelGetter(abstractField.getter)
               : new StaticAccess.staticGetter(abstractField.getter);
         }
         registry.registerStaticUse(
             new StaticUse.staticGet(abstractField.getter));
       } else if (node.isComplex) {
         if (abstractField.getter == null) {
           ErroneousElement error = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
-          registry.registerThrowNoSuchMethod();
+          registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           // `a++` or `a += b` where `a` has no getter.
           semantics = new CompoundAccessSemantics(
               element.isTopLevel
                   ? CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER
                   : CompoundAccessKind.UNRESOLVED_STATIC_GETTER,
               error,
               abstractField.setter);
           registry.registerStaticUse(
               new StaticUse.staticSet(abstractField.setter));
         } else {
@@ skipping 23 matching lines @@
       // of parse errors to make [element] erroneous. Fix this!
       member.computeType(resolution);
       if (member.isMalformed) {
         // [member] has parse errors.
         semantics = new StaticAccess.unresolved(member);
       } else if (member.isFunction) {
         // `a = b`, `a++` or `a += b` where `a` is a function.
         ErroneousElement error = reportAndCreateErroneousElement(
             node.selector, name.text,
             MessageKind.ASSIGNING_METHOD, const {});
-        registry.registerThrowNoSuchMethod();
+        registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a function.
           registry.registerStaticUse(
               new StaticUse.staticTearOff(element));
         }
         semantics = member.isTopLevel
             ? new StaticAccess.topLevelMethod(member)
             : new StaticAccess.staticMethod(member);
       } else {
         // `a = b`, `a++` or `a += b` where `a` is a field.
         assert(invariant(node, member.isField,
             message: "Unexpected element: $member."));
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a field.
           registry.registerStaticUse(new StaticUse.staticGet(member));
         }
         if (member.isFinal || member.isConst) {
           ErroneousElement error = reportAndCreateErroneousElement(
                node.selector, name.text,
                MessageKind.CANNOT_RESOLVE_SETTER, const {});
-          registry.registerThrowNoSuchMethod();
+          registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           semantics = member.isTopLevel
               ? new StaticAccess.finalTopLevelField(member)
               : new StaticAccess.finalStaticField(member);
         } else {
           registry.registerStaticUse(new StaticUse.staticSet(member));
           semantics = member.isTopLevel
               ? new StaticAccess.topLevelField(member)
               : new StaticAccess.staticField(member);
         }
       }
@@ skipping 468 matching lines @@
           switch (semantics.kind) {
             case AccessKind.SUPER_FINAL_FIELD:
               reporter.reportWarningMessage(
                   node,
                   MessageKind.ASSIGNING_FINAL_FIELD_IN_SUPER,
                   {'name': name,
                    'superclassName': semantics.setter.enclosingClass.name});
               // TODO(johnniwinther): This shouldn't be needed.
               registry.registerDynamicUse(
                   new DynamicUse(setterSelector, null));
-              registry.registerSuperNoSuchMethod();
+              registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
               break;
             case AccessKind.SUPER_METHOD:
               reporter.reportWarningMessage(
                   node, MessageKind.ASSIGNING_METHOD_IN_SUPER,
                   {'name': name,
                    'superclassName': semantics.setter.enclosingClass.name});
               // TODO(johnniwinther): This shouldn't be needed.
               registry.registerDynamicUse(
                   new DynamicUse(setterSelector, null));
-              registry.registerSuperNoSuchMethod();
+              registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
               break;
             case AccessKind.SUPER_FIELD:
             case AccessKind.SUPER_SETTER:
               registry.registerStaticUse(
                   new StaticUse.superSet(semantics.setter));
               break;
             default:
               break;
           }
         }
@@ skipping 37 matching lines @@
       registry.useElement(node, semantics.setter);
       registry.useElement(node.selector, semantics.getter);
 
       registry.registerDynamicUse(
           new DynamicUse(operatorSelector, null));
 
       SendStructure sendStructure = node.isPrefix
           ? new PrefixStructure(semantics, operator)
           : new PostfixStructure(semantics, operator);
       registry.registerSendStructure(node, sendStructure);
-      registry.registerIncDecOperation();
+      registry.registerFeature(Feature.INC_DEC_OPERATION);
     } else {
       Node rhs = node.arguments.head;
       visitExpression(rhs);
 
       AssignmentOperator operator = AssignmentOperator.parse(operatorText);
       if (operator.kind == AssignmentOperatorKind.ASSIGN) {
         // `e1 = e2`.
 
         // TODO(23998): Remove these when elements are only accessed
         // through the send structure.
@@ skipping 51 matching lines @@
     } else if (node.receiver == null) {
       // `a = c`
       return handleUnqualifiedSendSet(node);
     } else {
       // `a.b = c`
       return handleQualifiedSendSet(node);
     }
   }
 
   ConstantResult visitLiteralInt(LiteralInt node) {
-    // TODO(johnniwinther): Make this a feature instead.
-    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.intType));
     ConstantExpression constant = new IntConstantExpression(node.value);
+    registry.registerConstantLiteral(constant);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ConstantResult visitLiteralDouble(LiteralDouble node) {
-    // TODO(johnniwinther): Make this a feature instead.
-    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.doubleType));
     ConstantExpression constant = new DoubleConstantExpression(node.value);
+    registry.registerConstantLiteral(constant);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ConstantResult visitLiteralBool(LiteralBool node) {
-    // TODO(johnniwinther): Make this a feature instead.
-    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.boolType));
     ConstantExpression constant = new BoolConstantExpression(node.value);
+    registry.registerConstantLiteral(constant);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ResolutionResult visitLiteralString(LiteralString node) {
-    // TODO(johnniwinther): Make this a feature instead.
-    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.stringType));
     if (node.dartString != null) {
       // [dartString] might be null on parser errors.
       ConstantExpression constant =
           new StringConstantExpression(node.dartString.slowToString());
+      registry.registerConstantLiteral(constant);
       registry.setConstant(node, constant);
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
 
   ConstantResult visitLiteralNull(LiteralNull node) {
-    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.nullType));
     ConstantExpression constant = new NullConstantExpression();
+    registry.registerConstantLiteral(constant);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ConstantResult visitLiteralSymbol(LiteralSymbol node) {
-    // TODO(johnniwinther): Make this a feature instead.
     String name = node.slowNameString;
+    // TODO(johnniwinther): Use [registerConstantLiteral] instead.
     registry.registerConstSymbol(name);
     if (!validateSymbol(node, name, reportError: false)) {
       reporter.reportErrorMessage(
           node,
           MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
           {'value': name});
     }
     analyzeConstantDeferred(node);
     ConstantExpression constant = new SymbolConstantExpression(name);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ResolutionResult visitStringJuxtaposition(StringJuxtaposition node) {
-    // TODO(johnniwinther): Make this a feature instead.
-    registry.registerTypeUse(new TypeUse.instantiation(coreTypes.stringType));
+    registry.registerFeature(Feature.STRING_JUXTAPOSITION);
     ResolutionResult first = visit(node.first);
     ResolutionResult second = visit(node.second);
     if (first.isConstant && second.isConstant) {
       ConstantExpression constant = new ConcatenateConstantExpression(
           <ConstantExpression>[first.constant, second.constant]);
       registry.setConstant(node, constant);
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
@@ skipping 58 matching lines @@
 
     Node constructorReference = node.constructorReference;
     if (constructorReference is Send) {
       constructor.redirectionDeferredPrefix =
           compiler.deferredLoadTask.deferredPrefixElement(constructorReference,
                                                           registry.mapping);
     }
 
     registry.setRedirectingTargetConstructor(node, redirectionTarget);
     if (Elements.isUnresolved(redirectionTarget)) {
-      registry.registerThrowNoSuchMethod();
+      registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
       return const NoneResult();
     } else {
       if (isConstConstructor &&
           !redirectionTarget.isConst) {
         reporter.reportErrorMessage(
             node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
         isValidAsConstant = false;
       }
       if (redirectionTarget == constructor) {
         reporter.reportErrorMessage(
@@ skipping 22 matching lines @@
       // TODO(johnniwinther): Handle this (potentially) erroneous case.
       isValidAsConstant = false;
     }
 
     redirectionTarget.computeType(resolution);
     FunctionSignature targetSignature = redirectionTarget.functionSignature;
     constructor.computeType(resolution);
     FunctionSignature constructorSignature = constructor.functionSignature;
     if (!targetSignature.isCompatibleWith(constructorSignature)) {
       assert(!isSubtype);
-      registry.registerThrowNoSuchMethod();
+      registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
       isValidAsConstant = false;
     }
 
     // Register a post process to check for cycles in the redirection chain and
     // set the actual generative constructor at the end of the chain.
     addDeferredAction(constructor, () {
       compiler.resolver.resolveRedirectionChain(constructor, node);
     });
 
     registry.registerStaticUse(
         new StaticUse.constructorRedirect(redirectionTarget));
     // TODO(johnniwinther): Register the effective target type as part of the
     // static use instead.
     registry.registerTypeUse(new TypeUse.instantiation(
         redirectionTarget.enclosingClass.thisType
             .subst(type.typeArguments, targetClass.typeVariables)));
     if (isSymbolConstructor) {
-      registry.registerSymbolConstructor();
+      registry.registerFeature(Feature.SYMBOL_CONSTRUCTOR);
     }
     if (isValidAsConstant) {
       List<String> names = <String>[];
       List<ConstantExpression> arguments = <ConstantExpression>[];
       int index = 0;
       constructorSignature.forEachParameter((ParameterElement parameter) {
         if (parameter.isNamed) {
           String name = parameter.name;
           names.add(name);
           arguments.add(new NamedArgumentReference(name));
         } else {
           arguments.add(new PositionalArgumentReference(index));
         }
         index++;
       });
       CallStructure callStructure =
           new CallStructure(constructorSignature.parameterCount, names);
       constructor.constantConstructor =
           new RedirectingFactoryConstantConstructor(
               new ConstructedConstantExpression(
                   type,
                   redirectionTarget,
                   callStructure,
                   arguments));
     }
     return const NoneResult();
   }
 
   ResolutionResult visitThrow(Throw node) {
-    registry.registerThrowExpression();
+    registry.registerFeature(Feature.THROW_EXPRESSION);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitAwait(Await node) {
     coreClasses.futureClass.ensureResolved(resolution);
     visit(node.expression);
     return const NoneResult();
   }
 
@@ skipping 82 matching lines @@
           inConstantContext(() => resolveArguments(node.send.argumentsNode));
     } else {
       argumentsResult = resolveArguments(node.send.argumentsNode);
     }
     registry.useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) {
       return new ResolutionResult.forElement(constructor);
     }
     constructor.computeType(resolution);
     if (!callSelector.applies(constructor, compiler.world)) {
-      registry.registerThrowNoSuchMethod();
+      registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     registry.registerStaticUse(
         new StaticUse.constructorInvoke(
             constructor.declaration, callSelector.callStructure));
     ClassElement cls = constructor.enclosingClass;
     if (cls.isEnumClass && currentClass != cls) {
       reporter.reportErrorMessage(
@@ skipping 253 matching lines @@
       registry.setConstant(node, constant);
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
 
   ResolutionResult visitStringInterpolation(StringInterpolation node) {
     // TODO(johnniwinther): This should be a consequence of the registration
     // of [registerStringInterpolation].
     registry.registerTypeUse(new TypeUse.instantiation(coreTypes.stringType));
-    registry.registerStringInterpolation();
+    registry.registerFeature(Feature.STRING_INTERPOLATION);
     registerImplicitInvocation(Selectors.toString_);
 
     bool isValidAsConstant = true;
     List<ConstantExpression> parts = <ConstantExpression>[];
 
     void resolvePart(Node subnode) {
       ResolutionResult result = visit(subnode);
       if (isValidAsConstant && result.isConstant) {
         parts.add(result.constant);
       } else {
@@ skipping 74 matching lines @@
     }
     registry.registerTargetOf(node, target);
     return const NoneResult();
   }
 
   registerImplicitInvocation(Selector selector) {
     registry.registerDynamicUse(new DynamicUse(selector, null));
   }
 
   ResolutionResult visitAsyncForIn(AsyncForIn node) {
-    registry.registerAsyncForIn(node);
+    registry.registerFeature(Feature.ASYNC_FOR_IN);
     registry.registerDynamicUse(
         new DynamicUse(Selectors.current, null));
     registry.registerDynamicUse(
         new DynamicUse(Selectors.moveNext, null));
 
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
     visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
     return const NoneResult();
   }
 
   ResolutionResult visitSyncForIn(SyncForIn node) {
-    registry.registerSyncForIn(node);
+    registry.registerFeature(Feature.SYNC_FOR_IN);
     registry.registerDynamicUse(
         new DynamicUse(Selectors.iterator, null));
     registry.registerDynamicUse(
         new DynamicUse(Selectors.current, null));
     registry.registerDynamicUse(
         new DynamicUse(Selectors.moveNext, null));
 
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
@@ skipping 355 matching lines @@
     continueLabels.forEach((String key, LabelDefinition label) {
       if (!label.isContinueTarget) {
         JumpTarget targetElement = label.target;
         SwitchCase switchCase = targetElement.statement;
         registry.undefineTarget(switchCase);
         registry.undefineLabel(label.label);
       }
     });
     // TODO(15575): We should warn if we can detect a fall through
     // error.
-    registry.registerFallThroughError();
+    registry.registerFeature(Feature.FALL_THROUGH_ERROR);
     return const NoneResult();
   }
 
   ResolutionResult visitSwitchCase(SwitchCase node) {
     node.labelsAndCases.accept(this);
     visitIn(node.statements, new BlockScope(scope));
     return const NoneResult();
   }
 
   ResolutionResult visitCaseMatch(CaseMatch node) {
@@ skipping 10 matching lines @@
     if (node.catchBlocks.isEmpty && node.finallyBlock == null) {
       reporter.reportErrorMessage(
           node.getEndToken().next, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
     return const NoneResult();
   }
 
   ResolutionResult visitCatchBlock(CatchBlock node) {
-    registry.registerCatchStatement();
+    registry.registerFeature(Feature.CATCH_STATEMENT);
     // Check that if catch part is present, then
     // it has one or two formal parameters.
     VariableDefinitions exceptionDefinition;
     VariableDefinitions stackTraceDefinition;
     if (node.formals != null) {
       Link<Node> formalsToProcess = node.formals.nodes;
       if (formalsToProcess.isEmpty) {
         reporter.reportErrorMessage(
             node, MessageKind.EMPTY_CATCH_DECLARATION);
       } else {
         exceptionDefinition = formalsToProcess.head.asVariableDefinitions();
         formalsToProcess = formalsToProcess.tail;
         if (!formalsToProcess.isEmpty) {
           stackTraceDefinition = formalsToProcess.head.asVariableDefinitions();
           formalsToProcess = formalsToProcess.tail;
           if (!formalsToProcess.isEmpty) {
             for (Node extra in formalsToProcess) {
               reporter.reportErrorMessage(
                   extra, MessageKind.EXTRA_CATCH_DECLARATION);
             }
           }
-          registry.registerStackTraceInCatch();
+          registry.registerFeature(Feature.STACK_TRACE_IN_CATCH);
         }
       }
 
       // Check that the formals aren't optional and that they have no
       // modifiers or type.
       for (Link<Node> link = node.formals.nodes;
            !link.isEmpty;
            link = link.tail) {
         // If the formal parameter is a node list, it means that it is a
         // sequence of optional parameters.
@@ skipping 43 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(DiagnosticReporter reporter, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }