Introduce "CommonElements"

pkg/compiler/lib/src/ssa/builder.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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 188 matching lines @@
   /// might not be in scope or from the current instance.
   ///
   final InterfaceType instanceType;
 
   SourceInformationBuilder get sourceInformationBuilder {
     return builder.sourceInformationBuilder;
   }
 
   LocalsHandler(
       this.builder, this.executableContext, InterfaceType instanceType)
-      : this.instanceType =
-            instanceType == null || instanceType.containsTypeVariables
-                ? null
-                : instanceType;
+      : this.instanceType = instanceType == null ||
+            instanceType.containsTypeVariables ? null : instanceType;
 
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   DartType substInContext(DartType type) {
     if (contextClass != null) {
       ClassElement typeContext = Types.getClassContext(type);
       if (typeContext != null) {
         type = type.substByContext(contextClass.asInstanceOf(typeContext));
       }
     }
@@ skipping 4227 matching lines @@
       handleJsStringConcat(node);
     } else {
       reporter.internalError(node, "Unknown foreign: ${element}");
     }
   }
 
   generateDeferredLoaderGet(ast.Send node, FunctionElement deferredLoader,
       SourceInformation sourceInformation) {
     // Until now we only handle these as getters.
     invariant(node, deferredLoader.isDeferredLoaderGetter);
-    Element loadFunction = compiler.loadLibraryFunction;
+    Element loadFunction = helpers.loadLibraryWrapper;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
     String loadId =
         compiler.deferredLoadTask.getImportDeferName(node, prefixElement);
     var inputs = [
       graph.addConstantString(new ast.DartString.literal(loadId), compiler)
     ];
     push(new HInvokeStatic(loadFunction, inputs, backend.nonNullType,
         targetCanThrow: false)..sourceInformation = sourceInformation);
   }
 
@@ skipping 444 matching lines @@
       }
     }
 
     Element constructor = elements[send];
     CallStructure callStructure = elements.getSelector(send).callStructure;
     ConstructorElement constructorDeclaration = constructor;
     ConstructorElement constructorImplementation = constructor.implementation;
     constructor = constructorImplementation.effectiveTarget;
 
     final bool isSymbolConstructor =
-        constructorDeclaration == compiler.symbolConstructor;
+        compiler.commonElements.isSymbolConstructor(constructorDeclaration);
     final bool isJSArrayTypedConstructor =
         constructorDeclaration == helpers.jsArrayTypedConstructor;
 
     if (isSymbolConstructor) {
       constructor = helpers.symbolValidatedConstructor;
       assert(invariant(send, constructor != null,
           message: 'Constructor Symbol.validated is missing'));
       callStructure = helpers.symbolValidatedConstructorSelector.callStructure;
       assert(invariant(send, callStructure != null,
           message: 'Constructor Symbol.validated is missing'));
@@ skipping 212 matching lines @@
   visitStaticSend(ast.Send node) {
     internalError(node, "Unexpected visitStaticSend");
   }
 
   /// Generate an invocation to the static or top level [function].
   void generateStaticFunctionInvoke(
       ast.Send node, FunctionElement function, CallStructure callStructure) {
     List<HInstruction> inputs = makeStaticArgumentList(
         callStructure, node.arguments, function.implementation);
 
-    if (function == compiler.identicalFunction) {
+    if (function == compiler.commonElements.identicalFunction) {
       pushWithPosition(
           new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
       return;
     } else {
       pushInvokeStatic(node, function, inputs,
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 
@@ skipping 303 matching lines @@
   }
 
   @override
   void bulkHandleNode(ast.Node node, String message, _) {
     internalError(node, "Unexpected bulk handled node: $node");
   }
 
   @override
   void bulkHandleNew(ast.NewExpression node, [_]) {
     Element element = elements[node.send];
-    final bool isSymbolConstructor = element == compiler.symbolConstructor;
+    final bool isSymbolConstructor =
+        element == compiler.commonElements.symbolConstructor;
     if (!Elements.isMalformed(element)) {
       ConstructorElement function = element;
       element = function.effectiveTarget;
     }
     if (Elements.isError(element)) {
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR ||
           error.messageKind == MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR) {
         generateThrowNoSuchMethod(
             node.send, noSuchMethodTargetSymbolString(error, 'constructor'),
@@ skipping 155 matching lines @@
 
     var nativeBehavior = new native.NativeBehavior()
       ..sideEffects.setAllSideEffects();
 
     DartType type = element.isConstructor
         ? element.enclosingClass.thisType
         : element.type.returnType;
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
-    nativeBehavior.typesReturned.add(
-        compiler.options.trustJSInteropTypeAnnotations
-            ? type
-            : const DynamicType());
+    nativeBehavior.typesReturned.add(compiler
+        .options.trustJSInteropTypeAnnotations ? type : const DynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
     if (type.element != null && backend.isNative(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
     if (!compiler.options.trustJSInteropTypeAnnotations ||
@@ skipping 2968 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }