Merge CoreTypes and CoreClasses into 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';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Identifiers, Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
-import '../core_types.dart' show CoreClasses;
+import '../core_types.dart' show CommonElements;
 import '../dart_types.dart';
 import '../diagnostics/messages.dart' show Message, MessageTemplate;
 import '../dump_info.dart' show InfoReporter;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart' show ConstructorBodyElementX;
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
@@ skipping 193 matching lines @@
     loopHandler = new SsaLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
   }
 
   BackendHelpers get helpers => backend.helpers;
 
   RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
-  CoreClasses get coreClasses => compiler.coreClasses;
+  CommonElements get commonElements => closedWorld.commonElements;
 
   Element get targetElement => target;
 
   /// Reference to resolved elements in [target]'s AST.
   TreeElements get elements => resolvedAst.elements;
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   @override
@@ skipping 203 matching lines @@
         if (!selector.applies(function)) return false;
         if (mask != null && !mask.canHit(function, selector, closedWorld)) {
           return false;
         }
       }
 
       if (backend.isJsInterop(element)) return false;
 
       // Don't inline operator== methods if the parameter can be null.
       if (element.name == '==') {
-        if (element.enclosingClass != coreClasses.objectClass &&
+        if (element.enclosingClass != commonElements.objectClass &&
             providedArguments[1].canBeNull()) {
           return false;
         }
       }
 
       // Generative constructors of native classes should not be called directly
       // and have an extra argument that causes problems with inlining.
       if (element.isGenerativeConstructor &&
           backend.isNativeOrExtendsNative(element.enclosingClass)) {
         return false;
@@ skipping 1084 matching lines @@
   }
 
   /// Pops the most recent instruction from the stack and 'boolifies' it.
   ///
   /// Boolification is checking if the value is '=== true'.
   @override
   HInstruction popBoolified() {
     HInstruction value = pop();
     if (typeBuilder.checkOrTrustTypes) {
       return typeBuilder.potentiallyCheckOrTrustType(
-          value, compiler.coreTypes.boolType,
+          value, compiler.commonElements.boolType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, commonMasks.boolType);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, ast.Node node) {
     if (node != null) {
       target.sourceInformation = sourceInformationBuilder.buildGeneric(node);
@@ skipping 1469 matching lines @@
         targetCanThrow: false)..sourceInformation = sourceInformation);
   }
 
   generateSuperNoSuchMethodSend(
       ast.Send node, Selector selector, List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
-      element = coreClasses.objectClass.lookupMember(Identifiers.noSuchMethod_);
+      element =
+          commonElements.objectClass.lookupMember(Identifiers.noSuchMethod_);
     }
     if (backend.hasInvokeOnSupport && !element.enclosingClass.isObject) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object], in
       // case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       // TODO(johnniwinther): Register this more precisely.
       registry?.registerDynamicUse(new DynamicUse(selector, null));
     }
     String publicName = name;
@@ skipping 435 matching lines @@
       // Overwrite the element type, in case the allocation site has
       // been inlined.
       newInstance.instructionType = elementType;
       graph.allocatedFixedLists?.add(newInstance);
     }
 
     // The List constructor forwards to a Dart static method that does
     // not know about the type argument. Therefore we special case
     // this constructor to have the setRuntimeTypeInfo called where
     // the 'new' is done.
-    if (backend.classNeedsRti(coreClasses.listClass) &&
+    if (backend.classNeedsRti(commonElements.listClass) &&
         (isFixedListConstructorCall ||
             isGrowableListConstructorCall ||
             isJSArrayTypedConstructor)) {
       newInstance = handleListConstructor(type, send, pop());
       stack.add(newInstance);
     }
 
     // Finally, if we called a redirecting factory constructor, check the type.
     if (isRedirected) {
       HInstruction checked =
@@ skipping 1630 matching lines @@
     assert(isBuildingAsyncFunction);
     // TODO(sigurdm): In an internal library a function could be declared:
     //
     // _FutureImpl foo async => 1;
     //
     // This should be valid (because the actual value returned from an async
     // function is a `_FutureImpl`), but currently false is returned in this
     // case.
     return type.isDynamic ||
         type.isObject ||
-        (type is InterfaceType && type.element == coreClasses.futureClass);
+        (type is InterfaceType && type.element == commonElements.futureClass);
   }
 
   visitReturn(ast.Return node) {
     if (identical(node.beginToken.stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(closedWorld);
@@ skipping 31 matching lines @@
   visitYield(ast.Yield node) {
     visit(node.expression);
     HInstruction yielded = pop();
     add(new HYield(yielded, node.hasStar));
   }
 
   visitAwait(ast.Await node) {
     visit(node.expression);
     HInstruction awaited = pop();
     // TODO(herhut): Improve this type.
-    push(new HAwait(
-        awaited, new TypeMask.subclass(coreClasses.objectClass, closedWorld)));
+    push(new HAwait(awaited,
+        new TypeMask.subclass(commonElements.objectClass, closedWorld)));
   }
 
   visitTypeAnnotation(ast.TypeAnnotation node) {
     reporter.internalError(node, 'Visiting type annotation in SSA builder.');
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isReachable);
     for (Link<ast.Node> link = node.definitions.nodes;
         !link.isEmpty;
@@ skipping 143 matching lines @@
         [expression, graph.addConstantNull(closedWorld)]);
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
       Selector selector = Selectors.moveNext;
       TypeMask mask = elementInferenceResults.typeOfIteratorMoveNext(node);
       pushInvokeDynamic(node, selector, mask, [streamIterator]);
       HInstruction future = pop();
-      push(new HAwait(
-          future, new TypeMask.subclass(coreClasses.objectClass, closedWorld)));
+      push(new HAwait(future,
+          new TypeMask.subclass(commonElements.objectClass, closedWorld)));
       return popBoolified();
     }
 
     void buildBody() {
       Selector call = Selectors.current;
       TypeMask callMask = elementInferenceResults.typeOfIteratorCurrent(node);
       pushInvokeDynamic(node, call, callMask, [streamIterator]);
 
       ast.Node identifier = node.declaredIdentifier;
       Element variable = elements.getForInVariable(node);
@@ skipping 14 matching lines @@
       visit(node.body);
     }
 
     void buildUpdate() {}
 
     buildProtectedByFinally(() {
       loopHandler.handleLoop(
           node, buildInitializer, buildCondition, buildUpdate, buildBody);
     }, () {
       pushInvokeDynamic(node, Selectors.cancel, null, [streamIterator]);
-      push(new HAwait(
-          pop(), new TypeMask.subclass(coreClasses.objectClass, closedWorld)));
+      push(new HAwait(pop(),
+          new TypeMask.subclass(commonElements.objectClass, closedWorld)));
       pop();
     });
   }
 
   visitSyncForIn(ast.SyncForIn node) {
     // The 'get iterator' selector for this node has the inferred receiver type.
     // If the receiver supports JavaScript indexing we generate an indexing loop
     // instead of allocating an iterator object.
 
     // This scheme recognizes for-in on direct lists.  It does not recognize all
@@ skipping 1330 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }