Even less reliance on Compiler.closedWorld

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 2117 matching lines @@
       instruction =
           graph.addDeferredConstant(value, prefix, sourceInformation, compiler);
     } else {
       instruction = graph.addConstant(value, compiler,
           sourceInformation: sourceInformation);
     }
     stack.add(instruction);
     // The inferrer may have found a better type than the constant
     // handler in the case of lists, because the constant handler
     // does not look at elements in the list.
-    TypeMask type = TypeMaskFactory.inferredTypeForElement(field, compiler);
+    TypeMask type =
+        TypeMaskFactory.inferredTypeForElement(field, globalInferenceResults);
     if (!type.containsAll(closedWorld) && !instruction.isConstantNull()) {
       // TODO(13429): The inferrer should know that an element
       // cannot be null.
       instruction.instructionType = type.nonNullable();
     }
   }
 
   @override
   void previsitDeferredAccess(ast.Send node, PrefixElement prefix, _) {
     generateIsDeferredLoadedCheckIfNeeded(prefix, node);
   }
 
   /// Read a static or top level [field].
   void generateStaticFieldGet(ast.Send node, FieldElement field) {
     ConstantExpression constant = field.constant;
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     if (constant != null) {
       if (!field.isAssignable) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         generateStaticConstGet(node, field, constant, sourceInformation);
       } else {
         // TODO(5346): Try to avoid the need for calling [declaration] before
         // creating an [HStatic].
         HInstruction instruction = new HStatic(
-            field, TypeMaskFactory.inferredTypeForElement(field, compiler))
+            field,
+            TypeMaskFactory.inferredTypeForElement(
+                field, globalInferenceResults))
           ..sourceInformation = sourceInformation;
         push(instruction);
       }
     } else {
-      HInstruction instruction = new HLazyStatic(
-          field, TypeMaskFactory.inferredTypeForElement(field, compiler))
+      HInstruction instruction = new HLazyStatic(field,
+          TypeMaskFactory.inferredTypeForElement(field, globalInferenceResults))
         ..sourceInformation = sourceInformation;
       push(instruction);
     }
   }
 
   /// Generate a getter invocation of the static or top level [getter].
   void generateStaticGetterGet(ast.Send node, MethodElement getter) {
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     if (getter.isDeferredLoaderGetter) {
@@ skipping 484 matching lines @@
       });
       stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
       return;
     }
 
     if (native.HasCapturedPlaceholders.check(nativeBehavior.codeTemplate.ast)) {
       reporter.reportErrorMessage(node, MessageKind.JS_PLACEHOLDER_CAPTURE);
     }
 
     TypeMask ssaType =
-        TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
+        TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
 
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildCall(node, node.argumentsNode);
     if (nativeBehavior.codeTemplate.isExpression) {
       push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
           effects: nativeBehavior.sideEffects, nativeBehavior: nativeBehavior)
         ..sourceInformation = sourceInformation);
     } else {
       push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
           isStatement: true,
@@ skipping 132 matching lines @@
     for (int i = 2; i < arguments.length; i++) {
       visit(arguments[i]);
       compiledArguments.add(pop());
     }
 
     native.NativeBehavior nativeBehavior = elements.getNativeData(node);
     assert(invariant(node, nativeBehavior != null,
         message: "No NativeBehavior for $node"));
 
     TypeMask ssaType =
-        TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
+        TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
 
     push(new HForeignCode(template, ssaType, compiledArguments,
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsEmbeddedGlobal(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node globalNameNode;
     switch (arguments.length) {
       case 0:
@@ skipping 24 matching lines @@
     }
     HConstant hConstant = globalNameHNode;
     StringConstantValue constant = hConstant.constant;
     String globalName = constant.primitiveValue.slowToString();
     js.Template expr = js.js.expressionTemplateYielding(
         backend.emitter.generateEmbeddedGlobalAccess(globalName));
     native.NativeBehavior nativeBehavior = elements.getNativeData(node);
     assert(invariant(node, nativeBehavior != null,
         message: "No NativeBehavior for $node"));
     TypeMask ssaType =
-        TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
+        TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const [],
         nativeBehavior: nativeBehavior));
   }
 
   void handleJsInterceptorConstant(ast.Send node) {
     // Single argument must be a TypeConstant which is converted into a
     // InterceptorConstant.
     if (!node.arguments.isEmpty && node.arguments.tail.isEmpty) {
       ast.Node argument = node.arguments.head;
       visit(argument);
@@ skipping 418 matching lines @@
             "State: typeInfo=$typeInfo, stack=$stack."));
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   void handleNewSend(ast.NewExpression node) {
     ast.Send send = node.send;
     generateIsDeferredLoadedCheckOfSend(send);
 
     bool isFixedList = false;
-    bool isFixedListConstructorCall =
-        Elements.isFixedListConstructorCall(elements[send], send, compiler);
-    bool isGrowableListConstructorCall =
-        Elements.isGrowableListConstructorCall(elements[send], send, compiler);
+    bool isFixedListConstructorCall = Elements.isFixedListConstructorCall(
+        elements[send], send, closedWorld.commonElements);
+    bool isGrowableListConstructorCall = Elements.isGrowableListConstructorCall(
+        elements[send], send, closedWorld.commonElements);
 
     TypeMask computeType(element) {
       Element originalElement = elements[send];
       if (isFixedListConstructorCall ||
           Elements.isFilledListConstructorCall(
-              originalElement, send, compiler)) {
+              originalElement, send, closedWorld.commonElements)) {
         isFixedList = true;
         TypeMask inferred = _inferredTypeOfNewList(send);
         return inferred.containsAll(closedWorld)
             ? commonMasks.fixedArrayType
             : inferred;
       } else if (isGrowableListConstructorCall) {
         TypeMask inferred = _inferredTypeOfNewList(send);
         return inferred.containsAll(closedWorld)
             ? commonMasks.extendableArrayType
             : inferred;
       } else if (Elements.isConstructorOfTypedArraySubclass(
-          originalElement, compiler)) {
+          originalElement, closedWorld)) {
         isFixedList = true;
         TypeMask inferred = _inferredTypeOfNewList(send);
         ClassElement cls = element.enclosingClass;
         assert(backend.isNative(cls.thisType.element));
         return inferred.containsAll(closedWorld)
             ? new TypeMask.nonNullExact(cls.thisType.element, closedWorld)
             : inferred;
       } else if (element.isGenerativeConstructor) {
         ClassElement cls = element.enclosingClass;
         if (cls.isAbstract) {
           // An error will be thrown.
           return new TypeMask.nonNullEmpty();
         } else {
           return new TypeMask.nonNullExact(cls.thisType.element, closedWorld);
         }
       } else {
         return TypeMaskFactory.inferredReturnTypeForElement(
-            originalElement, compiler);
+            originalElement, globalInferenceResults);
       }
     }
 
     Element constructor = elements[send];
     CallStructure callStructure = elements.getSelector(send).callStructure;
     ConstructorElement constructorDeclaration = constructor;
     ConstructorElement constructorImplementation = constructor.implementation;
     constructor = constructorImplementation.effectiveTarget;
 
     final bool isSymbolConstructor =
-        compiler.commonElements.isSymbolConstructor(constructorDeclaration);
+        closedWorld.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 633 matching lines @@
       }
     }
 
     HInstruction receiver = arguments[0];
     List<HInstruction> inputs = <HInstruction>[];
     bool isIntercepted = backend.isInterceptedSelector(selector);
     if (isIntercepted) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.addAll(arguments);
-    TypeMask type =
-        TypeMaskFactory.inferredTypeForSelector(selector, mask, compiler);
+    TypeMask type = TypeMaskFactory.inferredTypeForSelector(
+        selector, mask, globalInferenceResults);
     if (selector.isGetter) {
       push(new HInvokeDynamicGetter(selector, mask, null, inputs, type)
         ..sourceInformation = sourceInformation);
     } else if (selector.isSetter) {
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type)
         ..sourceInformation = sourceInformation);
     } else {
       push(new HInvokeDynamicMethod(selector, mask, inputs, type, isIntercepted)
         ..sourceInformation = sourceInformation);
     }
@@ skipping 105 matching lines @@
       InterfaceType instanceType,
       SourceInformation sourceInformation}) {
     assert(element.isDeclaration);
     // TODO(johnniwinther): Use [sourceInformation] instead of [location].
     if (tryInlineMethod(element, null, null, arguments, location,
         instanceType: instanceType)) {
       return;
     }
 
     if (typeMask == null) {
-      typeMask =
-          TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
+      typeMask = TypeMaskFactory.inferredReturnTypeForElement(
+          element, globalInferenceResults);
     }
     bool targetCanThrow = !closedWorld.getCannotThrow(element);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     var instruction;
     if (backend.isJsInterop(element)) {
       instruction =
           invokeJsInteropFunction(element, arguments, sourceInformation);
     } else {
       // creating an [HInvokeStatic].
       instruction = new HInvokeStatic(element, arguments, typeMask,
@@ skipping 22 matching lines @@
     if (backend.isInterceptedSelector(selector) &&
         // Fields don't need an interceptor; consider generating HFieldGet/Set
         // instead.
         element.kind != ElementKind.FIELD) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
     TypeMask type;
     if (!element.isGetter && selector.isGetter) {
-      type = TypeMaskFactory.inferredTypeForElement(element, compiler);
+      type = TypeMaskFactory.inferredTypeForElement(
+          element, globalInferenceResults);
     } else {
-      type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
+      type = TypeMaskFactory.inferredReturnTypeForElement(
+          element, globalInferenceResults);
     }
     HInstruction instruction = new HInvokeSuper(element, currentNonClosureClass,
         selector, inputs, type, sourceInformation,
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects =
         closedWorld.getSideEffectsOfSelector(selector, null);
     return instruction;
   }
 
   void handleComplexOperatorSend(
@@ skipping 1347 matching lines @@
       // condition.  It is not necessary on the first iteration since there is
       // no code between calls to `get iterator` and `moveNext`, so the test is
       // moved to the loop update.
 
       // Find a type for the element. Use the element type of the indexer of the
       // array, as this is stronger than the iterator's `get current` type, for
       // example, `get current` includes null.
       // TODO(sra): The element type of a container type mask might be better.
       Selector selector = new Selector.index();
       TypeMask type = TypeMaskFactory.inferredTypeForSelector(
-          selector, arrayType, compiler);
+          selector, arrayType, globalInferenceResults);
 
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction value = new HIndex(array, index, null, type);
       add(value);
 
       buildAssignLoopVariable(node, value);
       visit(node.body);
     }
 
     void buildUpdate() {
@@ skipping 123 matching lines @@
     // If rti is needed and the map literal has no type parameters,
     // 'constructor' is a static function that forwards the call to the factory
     // constructor without type parameters.
     assert(constructor is ConstructorElement || constructor is FunctionElement);
 
     // The instruction type will always be a subtype of the mapLiteralClass, but
     // type inference might discover a more specific type, or find nothing (in
     // dart2js unit tests).
     TypeMask mapType =
         new TypeMask.nonNullSubtype(helpers.mapLiteralClass, closedWorld);
-    TypeMask returnTypeMask =
-        TypeMaskFactory.inferredReturnTypeForElement(constructor, compiler);
+    TypeMask returnTypeMask = TypeMaskFactory.inferredReturnTypeForElement(
+        constructor, globalInferenceResults);
     TypeMask instructionType =
         mapType.intersection(returnTypeMask, closedWorld);
 
     addInlinedInstantiation(expectedType);
     pushInvokeStatic(node, constructor, inputs,
         typeMask: instructionType, instanceType: expectedType);
     removeInlinedInstantiation(expectedType);
   }
 
   visitLiteralMapEntry(ast.LiteralMapEntry node) {
@@ skipping 818 matching lines @@
     //      fast-path code for most primitives.
     if (expression.canBePrimitive(builder.closedWorld)) {
       append(stringify(node, expression));
       return;
     }
 
     // If the `toString` method is guaranteed to return a string we can call it
     // directly.
     Selector selector = Selectors.toString_;
     TypeMask type = TypeMaskFactory.inferredTypeForSelector(
-        selector, expression.instructionType, compiler);
+        selector, expression.instructionType, builder.globalInferenceResults);
     if (type.containsOnlyString(builder.closedWorld)) {
       builder.pushInvokeDynamic(node, selector, expression.instructionType,
           <HInstruction>[expression]);
       append(builder.pop());
       return;
     }
 
     append(stringify(node, expression));
   }
 
@@ skipping 190 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }