Retain elements a finer granularity than library.

dart/sdk/lib/_internal/compiler/implementation/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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 956 matching lines @@
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   error(Node node, MessageKind kind, [arguments = const {}]) {
     // TODO(ahe): Make non-fatal.
     compiler.reportFatalError(node, kind, arguments);
   }
 }
 
+class ConstantMapper extends Visitor {
+  final Map<Constant, Node> constantToNodeMap = new Map<Constant, Node>();
+  final CompileTimeConstantEvaluator evaluator;
+
+  ConstantMapper(ConstantHandler handler,
+                 TreeElements elements,
+                 Compiler compiler)
+      : evaluator = new CompileTimeConstantEvaluator(
+          handler, elements, compiler, isConst: false);
+
+  visitNode(Node node) {
+    Constant constant = evaluator.evaluate(node);
+    if (constant != null) constantToNodeMap[constant] = node;
+    node.visitChildren(this);
+  }
+}
+
 class InitializerResolver {
   final ResolverVisitor visitor;
   final Map<Element, Node> initialized;
   Link<Node> initializers;
   bool hasSuper;
 
   InitializerResolver(this.visitor)
     : initialized = new Map<Element, Node>(), hasSuper = false;
 
   error(Node node, MessageKind kind, [arguments = const {}]) {
@@ skipping 280 matching lines @@
 
   void error(Node node, MessageKind kind, [Map arguments = const {}]) {
     compiler.reportFatalError(node, kind, arguments);
   }
 
   void dualError(Node node, DualKind kind, [Map arguments = const {}]) {
     error(node, kind.error, arguments);
   }
 
   void warning(Node node, MessageKind kind, [Map arguments = const {}]) {
-    ResolutionWarning message  = new ResolutionWarning(kind, arguments);
+    ResolutionWarning message =
+        new ResolutionWarning(kind, arguments, compiler.terseDiagnostics);
     compiler.reportWarning(node, message);
   }
 
   void dualWarning(Node node, DualKind kind, [Map arguments = const {}]) {
     warning(node, kind.warning, arguments);
   }
 
   void cancel(Node node, String message) {
     compiler.cancel(message, node: node);
   }
@@ skipping 455 matching lines @@
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
   ErroneousElement warnAndCreateErroneousElement(Node node,
                                                  SourceString name,
                                                  DualKind kind,
                                                  [Map arguments = const {}]) {
-    ResolutionWarning warning = new ResolutionWarning(kind.warning, arguments);
+    ResolutionWarning warning = new ResolutionWarning(
+        kind.warning, arguments, compiler.terseDiagnostics);
     compiler.reportWarning(node, warning);
     return new ErroneousElementX(kind.error, arguments, name, enclosingElement);
   }
 
   Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
       return null;
@@ skipping 827 matching lines @@
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     visit(node.expression);
     sendIsMemberAccess = oldSendIsMemberAccess;
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     FunctionElement constructor = resolveConstructor(node);
     final bool isSymbolConstructor = constructor == compiler.symbolConstructor;
+    final bool isMirrorsUsedConstant =
+        node.isConst() && (constructor == compiler.mirrorsUsedConstructor);
     resolveSelector(node.send, constructor);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
     Selector callSelector = mapping.getSelector(node.send);
     if (!callSelector.applies(constructor, compiler)) {
       warnArgumentMismatch(node.send, constructor);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
 
@@ skipping 32 matching lines @@
         }
       } else {
         if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
                 enclosingElement)) {
           compiler.reportHint(
               node.newToken, MessageKind.NON_CONST_BLOAT,
               {'name': compiler.symbolClass.name});
         }
         world.registerNewSymbol(mapping);
       }
+    } else if (isMirrorsUsedConstant) {
+      compiler.mirrorUsageAnalyzerTask.validate(node, mapping);
     }
 
     return null;
   }
 
   bool validateSymbol(Node node, String name) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       compiler.reportError(node, MessageKind.PRIVATE_IDENTIFIER,
                                {'value': name});
@@ skipping 1264 matching lines @@
                                Map arguments) {
     if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
       compiler.backend.registerThrowNoSuchMethod(resolver.mapping);
     } else {
       compiler.backend.registerThrowRuntimeError(resolver.mapping);
     }
     if (inConstContext) {
       error(diagnosticNode, kind.error, arguments);
     } else {
       ResolutionWarning warning  =
-          new ResolutionWarning(kind.warning, arguments);
+          new ResolutionWarning(
+              kind.warning, arguments, compiler.terseDiagnostics);
       compiler.reportWarning(diagnosticNode, warning);
       return new ErroneousElementX(
           kind.error, arguments, targetName, enclosing);
     }
   }
 
   Selector createConstructorSelector(SourceString constructorName) {
     return constructorName == const SourceString('')
         ? new Selector.callDefaultConstructor(
             resolver.enclosingElement.getLibrary())
@@ skipping 115 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }