Access ConstantSystem through ClosedWorld.

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 182 matching lines @@
 
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
       field.initializer.accept(this);
       HInstruction fieldValue = pop();
       HInstruction checkInstruction = typeBuilder.potentiallyCheckOrTrustType(
           fieldValue, astAdapter.getDartType(field.type));
       stack.add(checkInstruction);
     } else {
-      stack.add(graph.addConstantNull(compiler));
+      stack.add(graph.addConstantNull(closedWorld));
     }
     HInstruction value = pop();
     closeAndGotoExit(new HReturn(value, null));
     closeFunction();
   }
 
   /// Pops the most recent instruction from the stack and 'boolifies' it.
   ///
   /// Boolification is checking if the value is '=== true'.
   @override
@@ skipping 54 matching lines @@
     closeAndGotoExit(new HReturn(create, null));
     closeFunction();
   }
 
   /// Maps the fields of a class to their SSA values.
   Map<ir.Field, HInstruction> _collectFieldValues(ir.Class clazz) {
     final fieldValues = <ir.Field, HInstruction>{};
 
     for (var field in clazz.fields) {
       if (field.initializer == null) {
-        fieldValues[field] = graph.addConstantNull(compiler);
+        fieldValues[field] = graph.addConstantNull(closedWorld);
       } else {
         field.initializer.accept(this);
         fieldValues[field] = pop();
       }
     }
 
     return fieldValues;
   }
 
   /// Collects field initializers all the way up the inheritance chain.
@@ skipping 44 matching lines @@
     if (!signature.optionalParametersAreNamed) {
       signature.forEachOptionalParameter((ParameterElement element) {
         if (positionalIndex < arguments.positional.length) {
           arguments.positional[positionalIndex++].accept(this);
           builtArguments.add(pop());
         } else {
           var constantValue =
               backend.constants.getConstantValue(element.constant);
           assert(invariant(element, constantValue != null,
               message: 'No constant computed for $element'));
-          builtArguments.add(graph.addConstant(constantValue, compiler));
+          builtArguments.add(graph.addConstant(constantValue, closedWorld));
         }
       });
     } else {
       signature.orderedOptionalParameters.forEach((ParameterElement element) {
         var correspondingNamed = arguments.named.firstWhere(
             (named) => named.name == element.name,
             orElse: () => null);
         if (correspondingNamed != null) {
           correspondingNamed.value.accept(this);
           builtArguments.add(pop());
         } else {
           var constantValue =
               backend.constants.getConstantValue(element.constant);
           assert(invariant(element, constantValue != null,
               message: 'No constant computed for $element'));
-          builtArguments.add(graph.addConstant(constantValue, compiler));
+          builtArguments.add(graph.addConstant(constantValue, closedWorld));
         }
       });
     }
 
     return builtArguments;
   }
 
   /// Inlines the given super [constructor]'s initializers by collecting it's
   /// field values and building its constructor initializers. We visit super
   /// constructors all the way up to the [Object] constructor.
@@ skipping 59 matching lines @@
     open(block);
   }
 
   void closeFunction() {
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
   }
 
   /// Pushes a boolean checking [expression] against null.
   pushCheckNull(HInstruction expression) {
-    push(new HIdentity(expression, graph.addConstantNull(compiler), null,
+    push(new HIdentity(expression, graph.addConstantNull(closedWorld), null,
         commonMasks.boolType));
   }
 
   @override
   void defaultExpression(ir.Expression expression) {
     // TODO(het): This is only to get tests working.
     _trap('Unhandled ir.${expression.runtimeType}  $expression');
   }
 
   @override
   void defaultStatement(ir.Statement statement) {
     _trap('Unhandled ir.${statement.runtimeType}  $statement');
     pop();
   }
 
   void _trap(String message) {
-    HInstruction nullValue = graph.addConstantNull(compiler);
+    HInstruction nullValue = graph.addConstantNull(closedWorld);
     HInstruction errorMessage =
-        graph.addConstantString(new DartString.literal(message), compiler);
+        graph.addConstantString(new DartString.literal(message), closedWorld);
     HInstruction trap = new HForeignCode(js.js.parseForeignJS("#.#"),
         commonMasks.dynamicType, <HInstruction>[nullValue, errorMessage]);
     trap.sideEffects
       ..setAllSideEffects()
       ..setDependsOnSomething();
     push(trap);
   }
 
   /// Returns the current source element.
   ///
@@ skipping 39 matching lines @@
     } else {
       expression.accept(this);
       pop();
     }
   }
 
   @override
   void visitReturnStatement(ir.ReturnStatement returnStatement) {
     HInstruction value;
     if (returnStatement.expression == null) {
-      value = graph.addConstantNull(compiler);
+      value = graph.addConstantNull(closedWorld);
     } else {
       assert(_targetFunction != null && _targetFunction is ir.FunctionNode);
       returnStatement.expression.accept(this);
       value = typeBuilder.potentiallyCheckOrTrustType(
           pop(), astAdapter.getFunctionReturnType(_targetFunction));
     }
     // TODO(het): Add source information
     // TODO(het): Set a return value instead of closing the function when we
     // support inlining.
     closeAndGotoExit(new HReturn(value, null));
   }
 
   @override
   void visitForStatement(ir.ForStatement forStatement) {
     assert(isReachable);
     assert(forStatement.body != null);
     void buildInitializer() {
       for (ir.VariableDeclaration declaration in forStatement.variables) {
         declaration.accept(this);
       }
     }
 
     HInstruction buildCondition() {
       if (forStatement.condition == null) {
-        return graph.addConstantBool(true, compiler);
+        return graph.addConstantBool(true, closedWorld);
       }
       forStatement.condition.accept(this);
       return popBoolified();
     }
 
     void buildUpdate() {
       for (ir.Expression expression in forStatement.updates) {
         expression.accept(this);
         assert(!isAborted());
         // The result of the update instruction isn't used, and can just
@@ skipping 66 matching lines @@
           [pop(), array],
           astAdapter.checkConcurrentModificationErrorReturnType);
       pop();
     }
 
     void buildInitializer() {
       forInStatement.iterable.accept(this);
       array = pop();
       isFixed = astAdapter.isFixedLength(array.instructionType, closedWorld);
       localsHandler.updateLocal(
-          indexVariable, graph.addConstantInt(0, compiler));
+          indexVariable, graph.addConstantInt(0, closedWorld));
       originalLength = buildGetLength();
     }
 
     HInstruction buildCondition() {
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction length = buildGetLength();
       HInstruction compare =
           new HLess(index, length, null, commonMasks.boolType);
       add(compare);
       return compare;
@@ skipping 24 matching lines @@
 
     void buildUpdate() {
       // See buildBody as to why we check here.
       buildConcurrentModificationErrorCheck();
 
       // TODO(sra): It would be slightly shorter to generate `a[i++]` in the
       // body (and that more closely follows what an inlined iterator would do)
       // but the code is horrible as `i+1` is carried around the loop in an
       // additional variable.
       HInstruction index = localsHandler.readLocal(indexVariable);
-      HInstruction one = graph.addConstantInt(1, compiler);
+      HInstruction one = graph.addConstantInt(1, closedWorld);
       HInstruction addInstruction =
           new HAdd(index, one, null, commonMasks.positiveIntType);
       add(addInstruction);
       localsHandler.updateLocal(indexVariable, addInstruction);
     }
 
     loopHandler.handleLoop(forInStatement, buildInitializer, buildCondition,
         buildUpdate, buildBody);
   }
 
@@ skipping 98 matching lines @@
           HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expressionInstruction) {
         add(converted);
       }
       stack.add(converted);
     }
   }
 
   void generateError(ir.Node node, String message, TypeMask typeMask) {
     HInstruction errorMessage =
-        graph.addConstantString(new DartString.literal(message), compiler);
+        graph.addConstantString(new DartString.literal(message), closedWorld);
     _pushStaticInvocation(node, [errorMessage], typeMask);
   }
 
   void generateTypeError(ir.Node node, String message) {
     generateError(node, message, astAdapter.throwTypeErrorType);
   }
 
   @override
   void visitAssertStatement(ir.AssertStatement assertStatement) {
     if (!compiler.options.enableUserAssertions) return;
@@ skipping 34 matching lines @@
   @override
   void visitLogicalExpression(ir.LogicalExpression logicalExpression) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler);
     brancher.handleLogicalBinary(() => logicalExpression.left.accept(this),
         () => logicalExpression.right.accept(this),
         isAnd: logicalExpression.operator == '&&');
   }
 
   @override
   void visitIntLiteral(ir.IntLiteral intLiteral) {
-    stack.add(graph.addConstantInt(intLiteral.value, compiler));
+    stack.add(graph.addConstantInt(intLiteral.value, closedWorld));
   }
 
   @override
   void visitDoubleLiteral(ir.DoubleLiteral doubleLiteral) {
-    stack.add(graph.addConstantDouble(doubleLiteral.value, compiler));
+    stack.add(graph.addConstantDouble(doubleLiteral.value, closedWorld));
   }
 
   @override
   void visitBoolLiteral(ir.BoolLiteral boolLiteral) {
-    stack.add(graph.addConstantBool(boolLiteral.value, compiler));
+    stack.add(graph.addConstantBool(boolLiteral.value, closedWorld));
   }
 
   @override
   void visitStringLiteral(ir.StringLiteral stringLiteral) {
     stack.add(graph.addConstantString(
-        new DartString.literal(stringLiteral.value), compiler));
+        new DartString.literal(stringLiteral.value), closedWorld));
   }
 
   @override
   void visitSymbolLiteral(ir.SymbolLiteral symbolLiteral) {
     stack.add(graph.addConstant(
-        astAdapter.getConstantForSymbol(symbolLiteral), compiler));
+        astAdapter.getConstantForSymbol(symbolLiteral), closedWorld));
     registry?.registerConstSymbol(symbolLiteral.value);
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral nullLiteral) {
-    stack.add(graph.addConstantNull(compiler));
+    stack.add(graph.addConstantNull(closedWorld));
   }
 
   /// Set the runtime type information if necessary.
   HInstruction setListRuntimeTypeInfoIfNeeded(
       HInstruction object, ir.ListLiteral listLiteral) {
     InterfaceType type = localsHandler
         .substInContext(astAdapter.getDartTypeOfListLiteral(listLiteral));
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
     for (DartType argument in type.typeArguments) {
       arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
   }
 
   @override
   void visitListLiteral(ir.ListLiteral listLiteral) {
     HInstruction listInstruction;
     if (listLiteral.isConst) {
-      listInstruction =
-          graph.addConstant(astAdapter.getConstantFor(listLiteral), compiler);
+      listInstruction = graph.addConstant(
+          astAdapter.getConstantFor(listLiteral), closedWorld);
     } else {
       List<HInstruction> elements = <HInstruction>[];
       for (ir.Expression element in listLiteral.expressions) {
         element.accept(this);
         elements.add(pop());
       }
       listInstruction =
           new HLiteralList(elements, commonMasks.extendableArrayType);
       add(listInstruction);
       listInstruction =
           setListRuntimeTypeInfoIfNeeded(listInstruction, 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(
-          graph.addConstant(astAdapter.getConstantFor(mapLiteral), compiler));
+      stack.add(graph.addConstant(
+          astAdapter.getConstantFor(mapLiteral), closedWorld));
       return;
     }
 
     // The map literal constructors take the key-value pairs as a List
     List<HInstruction> constructorArgs = <HInstruction>[];
     for (ir.MapEntry mapEntry in mapLiteral.entries) {
       mapEntry.accept(this);
       constructorArgs.add(pop());
       constructorArgs.add(pop());
     }
@@ skipping 64 matching lines @@
     // stack, so when we pop them off, the key is popped first, then the value.
     mapEntry.value.accept(this);
     mapEntry.key.accept(this);
   }
 
   @override
   void visitTypeLiteral(ir.TypeLiteral typeLiteral) {
     ir.DartType type = typeLiteral.type;
     if (type is ir.InterfaceType) {
       ConstantValue constant = astAdapter.getConstantForType(type);
-      stack.add(graph.addConstant(constant, compiler));
+      stack.add(graph.addConstant(constant, closedWorld));
       return;
     }
     if (type is ir.TypeParameterType) {
       // TODO(sra): Convert the type logic here to use ir.DartType.
       DartType dartType = astAdapter.getDartType(type);
       dartType = localsHandler.substInContext(dartType);
       HInstruction value = typeBuilder.analyzeTypeArgument(
           dartType, sourceElement,
           sourceInformation: null);
       _pushStaticInvocation(astAdapter.runtimeTypeToString,
@@ skipping 11 matching lines @@
   void visitStaticGet(ir.StaticGet staticGet) {
     ir.Member staticTarget = staticGet.target;
     if (staticTarget is ir.Procedure &&
         staticTarget.kind == ir.ProcedureKind.Getter) {
       // Invoke the getter
       _pushStaticInvocation(staticTarget, const <HInstruction>[],
           astAdapter.returnTypeOf(staticTarget));
     } else if (staticTarget is ir.Field && staticTarget.isConst) {
       assert(staticTarget.initializer != null);
       stack.add(graph.addConstant(
-          astAdapter.getConstantFor(staticTarget.initializer), compiler));
+          astAdapter.getConstantFor(staticTarget.initializer), closedWorld));
     } else {
       if (_isLazyStatic(staticTarget)) {
         push(new HLazyStatic(astAdapter.getField(staticTarget),
             astAdapter.inferredTypeOf(staticTarget)));
       } else {
         push(new HStatic(astAdapter.getMember(staticTarget),
             astAdapter.inferredTypeOf(staticTarget)));
       }
     }
   }
@@ skipping 64 matching lines @@
   void visitVariableSet(ir.VariableSet variableSet) {
     variableSet.value.accept(this);
     HInstruction value = pop();
     _visitLocalSetter(variableSet.variable, value);
   }
 
   @override
   void visitVariableDeclaration(ir.VariableDeclaration declaration) {
     Local local = astAdapter.getLocal(declaration);
     if (declaration.initializer == null) {
-      HInstruction initialValue = graph.addConstantNull(compiler);
+      HInstruction initialValue = graph.addConstantNull(closedWorld);
       localsHandler.updateLocal(local, initialValue);
     } else {
       declaration.initializer.accept(this);
       HInstruction initialValue = pop();
 
       _visitLocalSetter(declaration, initialValue);
 
       // Ignore value
       pop();
     }
@@ skipping 94 matching lines @@
         namedValues.remove(parameter.name);
       }
     }
     assert(namedValues.isEmpty);
 
     return values;
   }
 
   HInstruction _defaultValueForParameter(ir.VariableDeclaration parameter) {
     ir.Expression initializer = parameter.initializer;
-    if (initializer == null) return graph.addConstantNull(compiler);
+    if (initializer == null) return graph.addConstantNull(closedWorld);
     // TODO(sra): Evaluate constant in ir.Node domain.
     ConstantValue constant =
         astAdapter.getConstantForParameterDefaultValue(initializer);
-    if (constant == null) return graph.addConstantNull(compiler);
-    return graph.addConstant(constant, compiler);
+    if (constant == null) return graph.addConstantNull(closedWorld);
+    return graph.addConstant(constant, closedWorld);
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation invocation) {
     ir.Procedure target = invocation.target;
     if (astAdapter.isInForeignLibrary(target)) {
       handleInvokeStaticForeign(invocation, target);
       return;
     }
     TypeMask typeMask = astAdapter.returnTypeOf(target);
@@ skipping 25 matching lines @@
       handleForeignJsGetStaticState(invocation);
     } else if (name == 'JS_GET_NAME') {
       handleForeignJsGetName(invocation);
     } else if (name == 'JS_EMBEDDED_GLOBAL') {
       handleForeignJsEmbeddedGlobal(invocation);
     } else if (name == 'JS_BUILTIN') {
       handleForeignJsBuiltin(invocation);
     } else if (name == 'JS_GET_FLAG') {
       handleForeignJsGetFlag(invocation);
     } else if (name == 'JS_EFFECT') {
-      stack.add(graph.addConstantNull(compiler));
+      stack.add(graph.addConstantNull(closedWorld));
     } else if (name == 'JS_INTERCEPTOR_CONSTANT') {
       handleJsInterceptorConstant(invocation);
     } else if (name == 'JS_STRING_CONCAT') {
       handleJsStringConcat(invocation);
     } else {
       compiler.reporter.internalError(
           astAdapter.getNode(invocation), "Unknown foreign: ${name}");
     }
   }
 
@@ skipping 65 matching lines @@
       return null;
     }
 
     HConstant hConstant = instruction;
     StringConstantValue stringConstant = hConstant.constant;
     return stringConstant.primitiveValue.slowToString();
   }
 
   void handleForeignJsCurrentIsolateContext(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 0, 0)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     if (!backend.hasIsolateSupport) {
       // If the isolate library is not used, we just generate code
       // to fetch the static state.
       String name = backend.namer.staticStateHolder;
       push(new HForeignCode(
           js.js.parseForeignJS(name), commonMasks.dynamicType, <HInstruction>[],
           nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
     } else {
       // Call a helper method from the isolate library. The isolate library uses
       // its own isolate structure that encapsulates the isolate structure used
       // for binding to methods.
       ir.Procedure target = astAdapter.currentIsolate;
       if (target == null) {
         compiler.reporter.internalError(astAdapter.getNode(invocation),
             'Isolate library and compiler mismatch.');
       }
       _pushStaticInvocation(target, <HInstruction>[], commonMasks.dynamicType);
     }
   }
 
   void handleForeignJsCallInIsolate(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2, 2)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     List<HInstruction> inputs = _visitPositionalArguments(invocation.arguments);
 
     if (!backend.hasIsolateSupport) {
       // If the isolate library is not used, we ignore the isolate argument and
       // just invoke the closure.
       push(new HInvokeClosure(new Selector.callClosure(0),
           <HInstruction>[inputs[1]], commonMasks.dynamicType));
@@ skipping 11 matching lines @@
   void handleForeignDartClosureToJs(
       ir.StaticInvocation invocation, String name) {
     // TODO(sra): Do we need to wrap the closure in something that saves the
     // current isolate?
     handleForeignRawFunctionRef(invocation, name);
   }
 
   void handleForeignRawFunctionRef(
       ir.StaticInvocation invocation, String name) {
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     ir.Expression closure = invocation.arguments.positional.single;
     String problem = 'requires a static method or top-level method';
     if (closure is ir.StaticGet) {
       ir.Member staticTarget = closure.target;
       if (staticTarget is ir.Procedure) {
         if (staticTarget.kind == ir.ProcedureKind.Method) {
           ir.FunctionNode function = staticTarget.function;
@@ skipping 11 matching lines @@
                 nativeBehavior: native.NativeBehavior.PURE));
             return;
           }
           problem = 'does not handle a closure with optional parameters';
         }
       }
     }
 
     compiler.reporter.reportErrorMessage(astAdapter.getNode(invocation),
         MessageKind.GENERIC, {'text': "'$name' $problem."});
-    stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+    stack.add(graph.addConstantNull(closedWorld)); // Result expected on stack.
     return;
   }
 
   void handleForeignJsSetStaticState(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     List<HInstruction> inputs = _visitPositionalArguments(invocation.arguments);
 
     String isolateName = backend.namer.staticStateHolder;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
     push(new HForeignCode(js.js.parseForeignJS("$isolateName = #"),
         commonMasks.dynamicType, inputs,
         nativeBehavior: native.NativeBehavior.CHANGES_OTHER,
         effects: sideEffects));
   }
 
   void handleForeignJsGetStaticState(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 0, 0)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     push(new HForeignCode(js.js.parseForeignJS(backend.namer.staticStateHolder),
         commonMasks.dynamicType, <HInstruction>[],
         nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
   }
 
   void handleForeignJsGetName(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     ir.Node argument = invocation.arguments.positional.first;
     argument.accept(this);
     HInstruction instruction = pop();
 
     if (instruction is HConstant) {
       js.Name name =
           astAdapter.getNameForJsGetName(argument, instruction.constant);
-      stack.add(graph.addConstantStringFromName(name, compiler));
+      stack.add(graph.addConstantStringFromName(name, closedWorld));
       return;
     }
 
     compiler.reporter.reportErrorMessage(
         astAdapter.getNode(argument),
         MessageKind.GENERIC,
         {'text': 'Error: Expected a JsGetName enum value.'});
-    stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+    // Result expected on stack.
+    stack.add(graph.addConstantNull(closedWorld));
   }
 
   void handleForeignJsEmbeddedGlobal(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2, 2)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
     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, 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.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     List<ir.Expression> arguments = invocation.arguments.positional;
     ir.Expression nameArgument = arguments[1];
 
     nameArgument.accept(this);
     HInstruction instruction = pop();
 
     js.Template template;
     if (instruction is HConstant) {
       template = astAdapter.getJsBuiltinTemplate(instruction.constant);
     }
     if (template == null) {
       compiler.reporter.reportErrorMessage(
           astAdapter.getNode(nameArgument),
           MessageKind.GENERIC,
           {'text': 'Error: Expected a JsBuiltin enum value.'});
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     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, 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.
+          // Result expected on stack.
+          graph.addConstantBool(false, closedWorld));
       return;
     }
     String name = _foreignConstantStringArgument(invocation, 0, 'JS_GET_FLAG');
     bool value = false;
     switch (name) {
       case 'MUST_RETAIN_METADATA':
         value = backend.mustRetainMetadata;
         break;
       case 'USE_CONTENT_SECURITY_POLICY':
         value = compiler.options.useContentSecurityPolicy;
         break;
       default:
         compiler.reporter.reportErrorMessage(
             astAdapter.getNode(invocation),
             MessageKind.GENERIC,
             {'text': 'Error: Unknown internal flag "$name".'});
     }
-    stack.add(graph.addConstantBool(value, compiler));
+    stack.add(graph.addConstantBool(value, closedWorld));
   }
 
   void handleJsInterceptorConstant(ir.StaticInvocation invocation) {
     // Single argument must be a TypeConstant which is converted into a
     // InterceptorConstant.
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
     ir.Expression argument = invocation.arguments.positional.single;
     argument.accept(this);
     HInstruction argumentInstruction = pop();
     if (argumentInstruction is HConstant) {
       ConstantValue argumentConstant = argumentInstruction.constant;
       if (argumentConstant is TypeConstantValue) {
         // TODO(sra): Check that type is a subclass of [Interceptor].
         ConstantValue constant =
             new InterceptorConstantValue(argumentConstant.representedType);
-        HInstruction instruction = graph.addConstant(constant, compiler);
+        HInstruction instruction = graph.addConstant(constant, closedWorld);
         stack.add(instruction);
         return;
       }
     }
 
     compiler.reporter.reportErrorMessage(astAdapter.getNode(invocation),
         MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
-    stack.add(graph.addConstantNull(compiler));
+    stack.add(graph.addConstantNull(closedWorld));
   }
 
   void handleForeignJs(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2)) {
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehaviorForJsCall(invocation);
     assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
     List<HInstruction> inputs = <HInstruction>[];
     for (ir.Expression argument in invocation.arguments.positional.skip(2)) {
       argument.accept(this);
       inputs.add(pop());
     }
 
     if (nativeBehavior.codeTemplate.positionalArgumentCount != inputs.length) {
       compiler.reporter.reportErrorMessage(
           astAdapter.getNode(invocation), MessageKind.GENERIC, {
         'text': 'Mismatch between number of placeholders'
             ' and number of arguments.'
       });
-      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     if (native.HasCapturedPlaceholders.check(nativeBehavior.codeTemplate.ast)) {
       compiler.reporter.reportErrorMessage(
           astAdapter.getNode(invocation), MessageKind.JS_PLACEHOLDER_CAPTURE);
     }
 
     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.
+      // Result expected on stack.
+      stack.add(graph.addConstantNull(closedWorld));
       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,
@@ skipping 177 matching lines @@
   }
 
   HInstruction buildIsNode(
       ir.Node node, ir.DartType dart_type, HInstruction expression) {
     // TODO(sra): Convert the type testing logic here to use ir.DartType.
     DartType type = astAdapter.getDartType(dart_type);
 
     type = localsHandler.substInContext(type).unaliased;
 
     if (type is MethodTypeVariableType) {
-      return graph.addConstantBool(true, compiler);
+      return graph.addConstantBool(true, closedWorld);
     }
 
     if (type is MalformedType) {
       ErroneousElement element = type.element;
       generateTypeError(node, element.message);
       return new HIs.compound(type, expression, pop(), commonMasks.boolType);
     }
 
     if (type.isFunctionType) {
       List arguments = <HInstruction>[buildFunctionType(type), expression];
@@ skipping 236 matching lines @@
     HInvokeStatic unwrappedException = kernelBuilder.pop();
     tryInstruction.exception = exception;
     int catchesIndex = 0;
 
     void pushCondition(ir.Catch catchBlock) {
       if (catchBlock.guard is! ir.DynamicType) {
         HInstruction condition = kernelBuilder.buildIsNode(
             catchBlock.exception, catchBlock.guard, unwrappedException);
         kernelBuilder.push(condition);
       } else {
-        kernelBuilder.stack.add(
-            kernelBuilder.graph.addConstantBool(true, kernelBuilder.compiler));
+        kernelBuilder.stack.add(kernelBuilder.graph
+            .addConstantBool(true, kernelBuilder.closedWorld));
       }
     }
 
     void visitThen() {
       ir.Catch catchBlock = tryCatch.catches[catchesIndex];
       catchesIndex++;
       if (catchBlock.exception != null) {
         LocalVariableElement exceptionVariable =
             kernelBuilder.astAdapter.getElement(catchBlock.exception);
         kernelBuilder.localsHandler
@@ skipping 58 matching lines @@
     kernelBuilder.open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 }