Introduce "CommonElements"

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 Resolution;
 import '../compile_time_constants.dart';
@@ skipping 2605 matching lines @@
       } else {
         member = abstractField.setter;
       }
     } else {
       member = element;
     }
     // TODO(johnniwinther): Needed to provoke a parsing and with it discovery
     // of parse errors to make [element] erroneous. Fix this!
     member.computeType(resolution);
 
-    if (member == resolution.mirrorSystemGetNameFunction &&
+    if (resolution.commonElements.isMirrorSystemGetNameFunction(member) &&
         !resolution.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
-      reporter
-          .reportHintMessage(node.selector, MessageKind.STATIC_FUNCTION_BLOAT, {
-        'class': resolution.mirrorSystemClass.name,
-        'name': resolution.mirrorSystemGetNameFunction.name
+      reporter.reportHintMessage(
+          node.selector, MessageKind.STATIC_FUNCTION_BLOAT, {
+        'class': resolution.commonElements.mirrorSystemClass.name,
+        'name': member.name
       });
     }
 
     Selector selector;
     AccessSemantics semantics =
         computeStaticOrTopLevelAccessSemantics(node, member);
     if (node.isCall) {
       ArgumentsResult argumentsResult = resolveArguments(node.argumentsNode);
       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.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 == resolution.identicalFunction &&
+            if (method == resolution.commonElements.identicalFunction &&
                 argumentsResult.isValidAsConstant) {
               result = new ConstantResult(
                   node,
                   new IdenticalConstantExpression(
                       argumentsResult.argumentResults[0].constant,
                       argumentsResult.argumentResults[1].constant));
             }
           }
           break;
         case AccessKind.STATIC_FIELD:
@@ skipping 1002 matching lines @@
       isValidAsConstant = false;
     }
 
     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 (enclosingElement == resolution.symbolConstructor) {
+    if (resolution.commonElements.isSymbolConstructor(enclosingElement)) {
       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);
@@ skipping 189 matching lines @@
           constructor.declaration, callStructure));
       // TODO(johniwinther): Avoid registration of `type` in face of redirecting
       // factory constructors.
       registry.registerTypeUse(new TypeUse.instantiation(type));
     }
 
     ResolutionResult resolutionResult = const NoneResult();
     if (node.isConst) {
       bool isValidAsConstant = !isInvalid && constructor.isConst;
 
-      if (constructor == resolution.symbolConstructor) {
+      CommonElements commonElements = resolution.commonElements;
+      if (commonElements.isSymbolConstructor(constructor)) {
         Node argumentNode = node.send.arguments.head;
         ConstantExpression constant = resolver.constantCompiler
             .compileNode(argumentNode, registry.mapping);
         ConstantValue name = resolution.constants.getConstantValue(constant);
         if (!name.isString) {
           DartType type = name.getType(coreTypes);
           reporter.reportErrorMessage(
               argumentNode, MessageKind.STRING_EXPECTED, {'type': type});
         } else {
           StringConstantValue stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
         }
-      } else if (constructor == resolution.mirrorsUsedConstructor) {
+      } else if (commonElements.isMirrorsUsedConstructor(constructor)) {
         resolution.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
       }
 
       analyzeConstantDeferred(node);
 
       if (type.containsTypeVariables) {
         reporter.reportErrorMessage(
             node.send.selector, MessageKind.TYPE_VARIABLE_IN_CONSTANT);
         isValidAsConstant = false;
         isInvalid = true;
@@ skipping 39 matching lines @@
         // [LateConstInvokeStructure]; it might not be necessary.
         registry.registerNewStructure(node, structure);
         onAnalyzed = () {
           registry.registerNewStructure(node, structure.resolve(node));
         };
       }
 
       analyzeConstantDeferred(node, onAnalyzed: onAnalyzed);
     } else {
       // Not constant.
-      if (constructor == resolution.symbolConstructor &&
+      if (resolution.commonElements.isSymbolConstructor(constructor) &&
           !resolution.mirrorUsageAnalyzerTask
               .hasMirrorUsage(enclosingElement)) {
         reporter.reportHintMessage(node.newToken, MessageKind.NON_CONST_BLOAT,
             {'name': coreClasses.symbolClass.name});
       }
       registry.registerNewStructure(
           node,
           new NewInvokeStructure(
               new ConstructorAccessSemantics(kind, constructor, type),
               selector));
@@ skipping 742 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);
 }