Pass ClosedWorld directly to codegen tasks

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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 'package:kernel/ast.dart' as ir;
 import 'package:kernel/text/ast_to_text.dart' show debugNodeToString;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
@@ skipping 35 matching lines @@
 class SsaKernelBuilderTask extends CompilerTask {
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA kernel builder';
 
   SsaKernelBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
       : backend = backend,
         super(backend.compiler.measurer);
 
-  HGraph build(CodegenWorkItem work) {
+  HGraph build(CodegenWorkItem work, ClosedWorld closedWorld) {
     return measure(() {
       AstElement element = work.element.implementation;
       Kernel kernel = backend.kernelTask.kernel;
-      KernelSsaBuilder builder = new KernelSsaBuilder(element, work.resolvedAst,
-          backend.compiler, work.registry, sourceInformationFactory, kernel);
+      KernelSsaBuilder builder = new KernelSsaBuilder(
+          element,
+          work.resolvedAst,
+          backend.compiler,
+          closedWorld,
+          work.registry,
+          sourceInformationFactory,
+          kernel);
       HGraph graph = builder.build();
 
-      if (backend.compiler.tracer.isEnabled) {
+      if (backend.tracer.isEnabled) {
         String name;
         if (element.isClassMember) {
           String className = element.enclosingClass.name;
           String memberName = element.name;
           name = "$className.$memberName";
           if (element.isGenerativeConstructorBody) {
             name = "$name (body)";
           }
         } else {
           name = "${element.name}";
         }
-        backend.compiler.tracer.traceCompilation(name);
-        backend.compiler.tracer.traceGraph('builder', graph);
+        backend.tracer.traceCompilation(name);
+        backend.tracer.traceGraph('builder', graph);
       }
 
       return graph;
     });
   }
 }
 
 class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   ir.Node target;
   final AstElement targetElement;
   final ResolvedAst resolvedAst;
+  final ClosedWorld closedWorld;
   final CodegenRegistry registry;
 
   /// Helper accessor for all kernel function-like targets (Procedure,
   /// FunctionExpression, FunctionDeclaration) of the inner FunctionNode itself.
   /// If the current target is not a function-like target, _targetFunction will
   /// be null.
   ir.FunctionNode _targetFunction;
 
   /// A stack of [DartType]s that have been seen during inlining of factory
   /// constructors.  These types are preserved in [HInvokeStatic]s and
@@ skipping 18 matching lines @@
       <ir.VariableDeclaration, HInstruction>{};
 
   /// True if we are visiting the expression of a throw statement; we assume
   /// this is a slow path.
   bool _inExpressionOfThrow = false;
 
   KernelSsaBuilder(
       this.targetElement,
       this.resolvedAst,
       Compiler compiler,
+      this.closedWorld,
       this.registry,
       SourceInformationStrategy sourceInformationFactory,
       Kernel kernel) {
     this.compiler = compiler;
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
     this.sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
@@ skipping 418 matching lines @@
   }
 
   @override
   void visitForInStatement(ir.ForInStatement forInStatement) {
     if (forInStatement.isAsync) {
       compiler.reporter.internalError(astAdapter.getNode(forInStatement),
           "Cannot compile async for-in using kernel.");
     }
     // If the expression being iterated over is a JS indexable type, we can
     // generate an optimized version of for-in that uses indexing.
-    if (astAdapter.isJsIndexableIterator(forInStatement)) {
+    if (astAdapter.isJsIndexableIterator(forInStatement, closedWorld)) {
       _buildForInIndexable(forInStatement);
     } else {
       _buildForInIterator(forInStatement);
     }
   }
 
   /// Builds the graph for a for-in node with an indexable expression.
   ///
   /// In this case we build:
   ///
@@ skipping 32 matching lines @@
       _pushStaticInvocation(
           astAdapter.checkConcurrentModificationError,
           [pop(), array],
           astAdapter.checkConcurrentModificationErrorReturnType);
       pop();
     }
 
     void buildInitializer() {
       forInStatement.iterable.accept(this);
       array = pop();
-      isFixed = astAdapter.isFixedLength(array.instructionType);
+      isFixed = astAdapter.isFixedLength(array.instructionType, closedWorld);
       localsHandler.updateLocal(
           indexVariable, graph.addConstantInt(0, compiler));
       originalLength = buildGetLength();
     }
 
     HInstruction buildCondition() {
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction length = buildGetLength();
       HInstruction compare =
           new HLess(index, length, null, commonMasks.boolType);
@@ skipping 267 matching lines @@
         element.accept(this);
         elements.add(pop());
       }
       listInstruction =
           new HLiteralList(elements, commonMasks.extendableArrayType);
       add(listInstruction);
       listInstruction =
           setListRuntimeTypeInfoIfNeeded(listInstruction, listLiteral);
     }
 
-    TypeMask type = astAdapter.typeOfListLiteral(targetElement, listLiteral);
+    TypeMask type =
+        astAdapter.typeOfListLiteral(targetElement, listLiteral, closedWorld);
     if (!type.containsAll(closedWorld)) {
       listInstruction.instructionType = type;
     }
     stack.add(listInstruction);
   }
 
   @override
   void visitMapLiteral(ir.MapLiteral mapLiteral) {
     if (mapLiteral.isConst) {
       stack.add(
@@ skipping 172 matching lines @@
     stack.add(localsHandler.readLocal(local));
   }
 
   @override
   void visitPropertySet(ir.PropertySet propertySet) {
     propertySet.receiver.accept(this);
     HInstruction receiver = pop();
     propertySet.value.accept(this);
     HInstruction value = pop();
 
-    _pushDynamicInvocation(propertySet, astAdapter.typeOfSet(propertySet),
+    _pushDynamicInvocation(
+        propertySet,
+        astAdapter.typeOfSet(propertySet, closedWorld),
         <HInstruction>[receiver, value]);
 
     pop();
     stack.add(value);
   }
 
   @override
   void visitVariableSet(ir.VariableSet variableSet) {
     variableSet.value.accept(this);
     HInstruction value = pop();
@@ skipping 410 matching lines @@
     String globalName = _foreignConstantStringArgument(
         invocation, 1, 'JS_EMBEDDED_GLOBAL', 'second ');
     js.Template expr = js.js.expressionTemplateYielding(
         backend.emitter.generateEmbeddedGlobalAccess(globalName));
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehavior(invocation);
     assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
-    TypeMask ssaType = astAdapter.typeFromNativeBehavior(nativeBehavior);
+    TypeMask ssaType =
+        astAdapter.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const <HInstruction>[],
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsBuiltin(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2)) {
       stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
       return;
     }
 
@@ skipping 20 matching lines @@
     for (ir.Expression argument in arguments.skip(2)) {
       argument.accept(this);
       inputs.add(pop());
     }
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehavior(invocation);
     assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
-    TypeMask ssaType = astAdapter.typeFromNativeBehavior(nativeBehavior);
+    TypeMask ssaType =
+        astAdapter.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(template, ssaType, inputs,
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsGetFlag(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
       stack.add(
           graph.addConstantBool(false, compiler)); // Result expected on stack.
       return;
     }
@@ skipping 67 matching lines @@
       });
       stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
       return;
     }
 
     if (native.HasCapturedPlaceholders.check(nativeBehavior.codeTemplate.ast)) {
       compiler.reporter.reportErrorMessage(
           astAdapter.getNode(invocation), MessageKind.JS_PLACEHOLDER_CAPTURE);
     }
 
-    TypeMask ssaType = astAdapter.typeFromNativeBehavior(nativeBehavior);
+    TypeMask ssaType =
+        astAdapter.typeFromNativeBehavior(nativeBehavior, closedWorld);
 
     SourceInformation sourceInformation = null;
     push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
         isStatement: !nativeBehavior.codeTemplate.isExpression,
         effects: nativeBehavior.sideEffects,
         nativeBehavior: nativeBehavior)..sourceInformation = sourceInformation);
   }
 
   void handleJsStringConcat(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2, 2)) {
       stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
       return;
     }
     List<HInstruction> inputs = _visitPositionalArguments(invocation.arguments);
     push(new HStringConcat(inputs[0], inputs[1], commonMasks.stringType));
   }
 
   void _pushStaticInvocation(
       ir.Node target, List<HInstruction> arguments, TypeMask typeMask) {
     HInvokeStatic instruction = new HInvokeStatic(
         astAdapter.getMember(target), arguments, typeMask,
-        targetCanThrow: astAdapter.getCanThrow(target));
+        targetCanThrow: astAdapter.getCanThrow(target, closedWorld));
     if (currentImplicitInstantiations.isNotEmpty) {
       instruction.instantiatedTypes =
           new List<DartType>.from(currentImplicitInstantiations);
     }
-    instruction.sideEffects = astAdapter.getSideEffects(target);
+    instruction.sideEffects = astAdapter.getSideEffects(target, closedWorld);
 
     push(instruction);
   }
 
   void _pushDynamicInvocation(
       ir.Node node, TypeMask mask, List<HInstruction> arguments,
       {Selector selector}) {
     HInstruction receiver = arguments.first;
     List<HInstruction> inputs = <HInstruction>[];
 
@@ skipping 65 matching lines @@
   @override
   void visitMethodInvocation(ir.MethodInvocation invocation) {
     // Handle `x == null` specially. When these come from null-aware operators,
     // there is no mapping in the astAdapter.
     if (_handleEqualsNull(invocation)) return;
     invocation.receiver.accept(this);
     HInstruction receiver = pop();
     Selector selector = astAdapter.getSelector(invocation);
     _pushDynamicInvocation(
         invocation,
-        astAdapter.typeOfInvocation(invocation),
+        astAdapter.typeOfInvocation(invocation, closedWorld),
         <HInstruction>[receiver]
           ..addAll(
               _visitArgumentsForDynamicTarget(selector, invocation.arguments)));
   }
 
   bool _handleEqualsNull(ir.MethodInvocation invocation) {
     if (invocation.name.name == '==') {
       ir.Arguments arguments = invocation.arguments;
       if (arguments.types.isEmpty &&
           arguments.positional.length == 1 &&
@@ skipping 151 matching lines @@
     push(new HNot(popBoolified(), commonMasks.boolType));
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation stringConcat) {
     KernelStringBuilder stringBuilder = new KernelStringBuilder(this);
     stringConcat.accept(stringBuilder);
     stack.add(stringBuilder.result);
   }
 }