Access ConstantSystem through 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 561 matching lines @@
             new HFieldGet(null, providedArguments[0], commonMasks.dynamicType,
                 isAssignable: false),
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
       enterInlinedMethod(function, functionResolvedAst, compiledArguments,
           instanceType: instanceType);
       inlinedFrom(functionResolvedAst, () {
         if (!isReachable) {
-          emitReturn(graph.addConstantNull(compiler), null);
+          emitReturn(graph.addConstantNull(closedWorld), null);
         } else {
           doInline(functionResolvedAst);
         }
       });
       leaveInlinedMethod();
     }
 
     if (meetsHardConstraints() && heuristicSayGoodToGo()) {
       doInlining();
       infoReporter?.reportInlined(element,
@@ skipping 40 matching lines @@
    * from interop methods to match JavaScript semantics for omitted arguments.
    */
   HInstruction handleConstantForOptionalParameterJsInterop(Element parameter) =>
       null;
 
   HInstruction handleConstantForOptionalParameter(ParameterElement parameter) {
     ConstantValue constantValue =
         backend.constants.getConstantValue(parameter.constant);
     assert(invariant(parameter, constantValue != null,
         message: 'No constant computed for $parameter'));
-    return graph.addConstant(constantValue, compiler);
+    return graph.addConstant(constantValue, closedWorld);
   }
 
   ClassElement get currentNonClosureClass {
     ClassElement cls = sourceElement.enclosingClass;
     if (cls != null && cls.isClosure) {
       var closureClass = cls;
       return closureClass.methodElement.enclosingClass;
     } else {
       return cls;
     }
@@ skipping 16 matching lines @@
 
   ConstantValue getConstantForNode(ast.Node node) {
     ConstantValue constantValue =
         backend.constants.getConstantValueForNode(node, elements);
     assert(invariant(node, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
   HInstruction addConstant(ast.Node node) {
-    return graph.addConstant(getConstantForNode(node), compiler);
+    return graph.addConstant(getConstantForNode(node), closedWorld);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     graph.calledInLoop = closedWorld.isCalledInLoop(functionElement);
@@ skipping 14 matching lines @@
 
     // If [functionElement] is `operator==` we explicitly add a null check at
     // the beginning of the method. This is to avoid having call sites do the
     // null check.
     if (name == '==') {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
         handleIf(
             node: function,
             visitCondition: () {
               HParameterValue parameter = parameters.values.first;
-              push(new HIdentity(parameter, graph.addConstantNull(compiler),
+              push(new HIdentity(parameter, graph.addConstantNull(closedWorld),
                   null, commonMasks.boolType));
             },
             visitThen: () {
               closeAndGotoExit(new HReturn(
-                  graph.addConstantBool(false, compiler),
+                  graph.addConstantBool(false, closedWorld),
                   sourceInformationBuilder
                       .buildImplicitReturn(functionElement)));
             },
             visitElse: null,
             sourceInformation: sourceInformationBuilder.buildIf(function.body));
       }
     }
     if (const bool.fromEnvironment('unreachable-throw')) {
       var emptyParameters =
           parameters.values.where((p) => p.instructionType.isEmpty);
@@ skipping 124 matching lines @@
    */
   void setupStateForInlining(
       FunctionElement function, List<HInstruction> compiledArguments,
       {InterfaceType instanceType}) {
     ResolvedAst resolvedAst = function.resolvedAst;
     assert(resolvedAst != null);
     localsHandler = new LocalsHandler(this, function, instanceType, compiler);
     localsHandler.closureData =
         compiler.closureToClassMapper.getClosureToClassMapping(resolvedAst);
     returnLocal = new SyntheticLocal("result", function);
-    localsHandler.updateLocal(returnLocal, graph.addConstantNull(compiler));
+    localsHandler.updateLocal(returnLocal, graph.addConstantNull(closedWorld));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
     if (function.isInstanceMember) {
       localsHandler.updateLocal(localsHandler.closureData.thisLocal,
           compiledArguments[argumentIndex++]);
     }
 
     FunctionSignature signature = function.functionSignature;
@@ skipping 104 matching lines @@
             localsHandler.updateLocal(
                 localsHandler.getTypeVariableAsLocal(typeVariable),
                 typeBuilder.analyzeTypeArgument(argument, sourceElement));
           });
         } else {
           // If the supertype is a raw type, we need to set to null the
           // type variables.
           for (TypeVariableType variable in typeVariables) {
             localsHandler.updateLocal(
                 localsHandler.getTypeVariableAsLocal(variable),
-                graph.addConstantNull(compiler));
+                graph.addConstantNull(closedWorld));
           }
         }
       }
 
       // For redirecting constructors, the fields will be initialized later
       // by the effective target.
       if (!callee.isRedirectingGenerative) {
         inlinedFrom(constructorResolvedAst, () {
           buildFieldInitializers(
               callee.enclosingClass.implementation, fieldValues);
@@ skipping 182 matching lines @@
         (ClassElement enclosingClass, FieldElement member) {
       if (compiler.elementHasCompileTimeError(member)) return;
       reporter.withCurrentElement(member, () {
         ResolvedAst fieldResolvedAst = member.resolvedAst;
         ast.Node node = fieldResolvedAst.node;
         ast.Expression initializer = fieldResolvedAst.body;
         if (initializer == null) {
           // Unassigned fields of native classes are not initialized to
           // prevent overwriting pre-initialized native properties.
           if (!backend.isNativeOrExtendsNative(classElement)) {
-            fieldValues[member] = graph.addConstantNull(compiler);
+            fieldValues[member] = graph.addConstantNull(closedWorld);
           }
         } else {
           ast.Node right = initializer;
           ResolvedAst savedResolvedAst = resolvedAst;
           resolvedAst = fieldResolvedAst;
           final oldElementInferenceResults = elementInferenceResults;
           elementInferenceResults = inferenceResults.resultOf(member);
           // In case the field initializer uses closures, run the
           // closure to class mapper.
           compiler.closureToClassMapper.getClosureToClassMapping(resolvedAst);
@@ skipping 143 matching lines @@
     for (int index = constructorResolvedAsts.length - 1; index >= 0; index--) {
       ResolvedAst constructorResolvedAst = constructorResolvedAsts[index];
       ConstructorBodyElement body = getConstructorBody(constructorResolvedAst);
       if (body == null) continue;
 
       List bodyCallInputs = <HInstruction>[];
       if (isNativeUpgradeFactory) {
         if (interceptor == null) {
           ConstantValue constant =
               new InterceptorConstantValue(classElement.thisType);
-          interceptor = graph.addConstant(constant, compiler);
+          interceptor = graph.addConstant(constant, closedWorld);
         }
         bodyCallInputs.add(interceptor);
       }
       bodyCallInputs.add(newObject);
       ast.Node node = constructorResolvedAst.node;
       ClosureClassMap parameterClosureData = compiler.closureToClassMapper
           .getClosureToClassMapping(constructorResolvedAst);
 
       FunctionSignature functionSignature = body.functionSignature;
       // Provide the parameters to the generative constructor body.
@@ skipping 136 matching lines @@
       HConstant nameConstant = addConstantString(name);
       add(new HInvokeStatic(backend.helpers.traceHelper,
           <HInstruction>[nameConstant], commonMasks.dynamicType));
     }
   }
 
   insertCoverageCall(Element element) {
     if (JavaScriptBackend.TRACE_METHOD == 'post') {
       if (element == backend.helpers.traceHelper) return;
       // TODO(sigmund): create a better uuid for elements.
-      HConstant idConstant = graph.addConstantInt(element.hashCode, compiler);
+      HConstant idConstant =
+          graph.addConstantInt(element.hashCode, closedWorld);
       HConstant nameConstant = addConstantString(element.name);
       add(new HInvokeStatic(backend.helpers.traceHelper,
           <HInstruction>[idConstant, nameConstant], commonMasks.dynamicType));
     }
   }
 
   void assertIsSubtype(
       ast.Node node, DartType subtype, DartType supertype, String message) {
     HInstruction subtypeInstruction = typeBuilder.analyzeTypeArgument(
         localsHandler.substInContext(subtype), sourceElement);
     HInstruction supertypeInstruction = typeBuilder.analyzeTypeArgument(
         localsHandler.substInContext(supertype), sourceElement);
-    HInstruction messageInstruction =
-        graph.addConstantString(new ast.DartString.literal(message), compiler);
+    HInstruction messageInstruction = graph.addConstantString(
+        new ast.DartString.literal(message), closedWorld);
     MethodElement element = helpers.assertIsSubtype;
     var inputs = <HInstruction>[
       subtypeInstruction,
       supertypeInstruction,
       messageInstruction
     ];
     HInstruction assertIsSubtype =
         new HInvokeStatic(element, inputs, subtypeInstruction.instructionType);
     registry?.registerTypeVariableBoundsSubtypeCheck(subtype, supertype);
     add(assertIsSubtype);
@@ skipping 131 matching lines @@
       ast.Node initializer = node.initializer;
       if (initializer == null) return;
       visit(initializer);
       if (initializer.asExpression() != null) {
         pop();
       }
     }
 
     HInstruction buildCondition() {
       if (node.condition == null) {
-        return graph.addConstantBool(true, compiler);
+        return graph.addConstantBool(true, closedWorld);
       }
       visit(node.condition);
       return popBoolified();
     }
 
     void buildUpdate() {
       for (ast.Expression expression in node.update) {
         visit(expression);
         assert(!isAborted());
         // The result of the update instruction isn't used, and can just
@@ skipping 295 matching lines @@
       ast.Send node, UnaryOperator operator, ast.Node expression, _) {
     assert(node.argumentsNode is ast.Prefix);
     HInstruction operand = visitAndPop(expression);
 
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
       UnaryOperation operation = constantSystem.lookupUnary(operator);
       HConstant constant = operand;
       ConstantValue folded = operation.fold(constant.constant);
       if (folded != null) {
-        stack.add(graph.addConstant(folded, compiler));
+        stack.add(graph.addConstant(folded, closedWorld));
         return;
       }
     }
 
     pushInvokeDynamic(node, elements.getSelector(node),
         elementInferenceResults.typeOfSend(node), [operand],
         sourceInformation: sourceInformationBuilder.buildGeneric(node));
   }
 
   @override
@@ skipping 100 matching lines @@
   /// Generate read access of an unresolved static or top level entity.
   void generateStaticUnresolvedGet(ast.Send node, Element element) {
     if (element is ErroneousElement) {
       // An erroneous element indicates an unresolved static getter.
       handleInvalidStaticGet(node, element);
     } else {
       // This happens when [element] has parse errors.
       assert(invariant(node, element == null || element.isMalformed));
       // TODO(ahe): Do something like the above, that is, emit a runtime
       // error.
-      stack.add(graph.addConstantNull(compiler));
+      stack.add(graph.addConstantNull(closedWorld));
     }
   }
 
   /// Read a static or top level [field] of constant value.
   void generateStaticConstGet(ast.Send node, FieldElement field,
       ConstantExpression constant, SourceInformation sourceInformation) {
     ConstantValue value = backend.constants.getConstantValue(constant);
     HConstant instruction;
     // Constants that are referred via a deferred prefix should be referred
     // by reference.
     PrefixElement prefix =
         compiler.deferredLoadTask.deferredPrefixElement(node, elements);
     if (prefix != null) {
-      instruction =
-          graph.addDeferredConstant(value, prefix, sourceInformation, compiler);
+      instruction = graph.addDeferredConstant(
+          value, prefix, sourceInformation, compiler, closedWorld);
     } else {
-      instruction = graph.addConstant(value, compiler,
+      instruction = graph.addConstant(value, closedWorld,
           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, globalInferenceResults);
     if (!type.containsAll(closedWorld) && !instruction.isConstantNull()) {
       // TODO(13429): The inferrer should know that an element
@@ skipping 206 matching lines @@
       } else {
         FieldElement field = element;
         value = typeBuilder.potentiallyCheckOrTrustType(value, field.type);
         addWithPosition(new HStaticStore(field, value), location);
       }
       stack.add(value);
     } else if (Elements.isError(element)) {
       generateNoSuchSetter(location, element, send == null ? null : value);
     } else if (Elements.isMalformed(element)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
-      stack.add(graph.addConstantNull(compiler));
+      stack.add(graph.addConstantNull(closedWorld));
     } else {
       stack.add(value);
       LocalElement local = element;
       // If the value does not already have a name, give it here.
       if (value.sourceElement == null) {
         value.sourceElement = local;
       }
       HInstruction checkedOrTrusted =
           typeBuilder.potentiallyCheckOrTrustType(value, local.type);
       if (!identical(checkedOrTrusted, value)) {
@@ skipping 89 matching lines @@
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
       Element helper = helpers.checkSubtype;
       HInstruction representations =
           typeBuilder.buildTypeArgumentRepresentations(type, sourceElement);
       add(representations);
       js.Name operator = backend.namer.operatorIs(element);
       HInstruction isFieldName = addConstantStringFromName(operator);
       HInstruction asFieldName = closedWorld.hasAnyStrictSubtype(element)
           ? addConstantStringFromName(backend.namer.substitutionName(element))
-          : graph.addConstantNull(compiler);
+          : graph.addConstantNull(closedWorld);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
       pushInvokeStatic(node, helper, inputs, typeMask: commonMasks.boolType);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, commonMasks.boolType);
     } else {
@@ skipping 181 matching lines @@
         message: "No NativeBehavior for $node"));
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     if (nativeBehavior.codeTemplate.positionalArgumentCount != inputs.length) {
       reporter.reportErrorMessage(node, 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)) {
       reporter.reportErrorMessage(node, MessageKind.JS_PLACEHOLDER_CAPTURE);
     }
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
 
@@ skipping 75 matching lines @@
       case 'MUST_RETAIN_METADATA':
         value = backend.mustRetainMetadata;
         break;
       case 'USE_CONTENT_SECURITY_POLICY':
         value = compiler.options.useContentSecurityPolicy;
         break;
       default:
         reporter.reportErrorMessage(node, MessageKind.GENERIC,
             {'text': 'Error: Unknown internal flag "$name".'});
     }
-    stack.add(graph.addConstantBool(value, compiler));
+    stack.add(graph.addConstantBool(value, closedWorld));
   }
 
   void handleForeignJsGetName(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
     switch (arguments.length) {
       case 0:
         reporter.reportErrorMessage(node, MessageKind.GENERIC,
             {'text': 'Error: Expected one argument to JS_GET_NAME.'});
         return;
@@ skipping 107 matching lines @@
     // InterceptorConstant.
     if (!node.arguments.isEmpty && node.arguments.tail.isEmpty) {
       ast.Node argument = node.arguments.head;
       visit(argument);
       HInstruction argumentInstruction = pop();
       if (argumentInstruction is HConstant) {
         ConstantValue argumentConstant = argumentInstruction.constant;
         if (argumentConstant is TypeConstantValue) {
           ConstantValue constant =
               new InterceptorConstantValue(argumentConstant.representedType);
-          HInstruction instruction = graph.addConstant(constant, compiler);
+          HInstruction instruction = graph.addConstant(constant, closedWorld);
           stack.add(instruction);
           return;
         }
       }
     }
     reporter.reportErrorMessage(
         node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
-    stack.add(graph.addConstantNull(compiler));
+    stack.add(graph.addConstantNull(closedWorld));
   }
 
   void handleForeignJsCallInIsolate(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     if (!backend.hasIsolateSupport) {
       // If the isolate library is not used, we just invoke the
       // closure.
       visit(link.tail.head);
       push(new HInvokeClosure(new Selector.callClosure(0),
           <HInstruction>[pop()], commonMasks.dynamicType));
@@ skipping 91 matching lines @@
       handleForeignJsGetStaticState(node);
     } else if (name == 'JS_GET_NAME') {
       handleForeignJsGetName(node);
     } else if (name == BackendHelpers.JS_EMBEDDED_GLOBAL) {
       handleForeignJsEmbeddedGlobal(node);
     } else if (name == BackendHelpers.JS_BUILTIN) {
       handleForeignJsBuiltin(node);
     } else if (name == 'JS_GET_FLAG') {
       handleForeignJsGetFlag(node);
     } else if (name == 'JS_EFFECT') {
-      stack.add(graph.addConstantNull(compiler));
+      stack.add(graph.addConstantNull(closedWorld));
     } else if (name == BackendHelpers.JS_INTERCEPTOR_CONSTANT) {
       handleJsInterceptorConstant(node);
     } else if (name == 'JS_STRING_CONCAT') {
       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);
     FunctionEntity loadFunction = helpers.loadLibraryWrapper;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
     String loadId =
         compiler.deferredLoadTask.getImportDeferName(node, prefixElement);
     var inputs = [
-      graph.addConstantString(new ast.DartString.literal(loadId), compiler)
+      graph.addConstantString(new ast.DartString.literal(loadId), closedWorld)
     ];
     push(new HInvokeStatic(loadFunction, inputs, commonMasks.nonNullType,
         targetCanThrow: false)..sourceInformation = sourceInformation);
   }
 
   generateSuperNoSuchMethodSend(
       ast.Send node, Selector selector, List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
@@ skipping 18 matching lines @@
     js.Name internalName = backend.namer.invocationName(selector);
 
     Element createInvocationMirror = helpers.createInvocationMirror;
     var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
       ConstantValue argumentNameConstant =
           constantSystem.createString(new ast.DartString.literal(argumentName));
-      argumentNames.add(graph.addConstant(argumentNameConstant, compiler));
+      argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
     }
     var argumentNamesInstruction = buildLiteralList(argumentNames);
     add(argumentNamesInstruction);
 
     ConstantValue kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     pushInvokeStatic(
         null,
         createInvocationMirror,
         [
-          graph.addConstant(nameConstant, compiler),
-          graph.addConstantStringFromName(internalName, compiler),
-          graph.addConstant(kindConstant, compiler),
+          graph.addConstant(nameConstant, closedWorld),
+          graph.addConstantStringFromName(internalName, closedWorld),
+          graph.addConstant(kindConstant, closedWorld),
           argumentsInstruction,
           argumentNamesInstruction
         ],
         typeMask: commonMasks.dynamicType);
 
     var inputs = <HInstruction>[pop()];
     push(buildInvokeSuper(Selectors.noSuchMethod_, element, inputs));
   }
 
   /// Generate a call to a super method or constructor.
@@ skipping 292 matching lines @@
         target = target.immediateRedirectionTarget;
       }
     }
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType =
         constructorDeclaration.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     if (compiler.elementHasCompileTimeError(constructor)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
-      stack.add(graph.addConstantNull(compiler));
+      stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     if (checkTypeVariableBounds(node, type)) return;
 
     // Abstract class instantiation error takes precedence over argument
     // mismatch.
     ClassElement cls = constructor.enclosingClass;
     if (cls.isAbstract && constructor.isGenerativeConstructor) {
       // However, we need to ensure that all arguments are evaluated before we
@@ skipping 14 matching lines @@
             .signatureApplies(constructorImplementation.functionSignature)) {
       generateWrongArgumentCountError(send, constructor, send.arguments);
       return;
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor &&
         backend.isNativeOrExtendsNative(constructor.enclosingClass) &&
         !backend.isJsInterop(constructor)) {
       // Native class generative constructors take a pre-constructed object.
-      inputs.add(graph.addConstantNull(compiler));
+      inputs.add(graph.addConstantNull(closedWorld));
     }
     inputs.addAll(makeStaticArgumentList(
         callStructure, send.arguments, constructorImplementation));
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(closedWorld)) {
         HTypeConversion conversion = new HTypeConversion(
             null,
             HTypeConversion.ARGUMENT_TYPE_CHECK,
@@ skipping 269 matching lines @@
 
   @override
   void visitUnresolvedInvoke(ast.Send node, Element element,
       ast.NodeList arguments, Selector selector, _) {
     if (element is ErroneousElement) {
       // An erroneous element indicates that the function could not be
       // resolved (a warning has been issued).
       handleInvalidStaticInvoke(node, element);
     } else {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
-      stack.add(graph.addConstantNull(compiler));
+      stack.add(graph.addConstantNull(closedWorld));
     }
     return;
   }
 
   HConstant addConstantString(String string) {
     ast.DartString dartString = new ast.DartString.literal(string);
-    return graph.addConstantString(dartString, compiler);
+    return graph.addConstantString(dartString, closedWorld);
   }
 
   HConstant addConstantStringFromName(js.Name name) {
-    return graph.addConstantStringFromName(name, compiler);
+    return graph.addConstantStringFromName(name, closedWorld);
   }
 
   visitClassTypeLiteralGet(ast.Send node, ConstantExpression constant, _) {
     generateConstantTypeLiteral(node);
   }
 
   visitClassTypeLiteralInvoke(ast.Send node, ConstantExpression constant,
       ast.NodeList arguments, CallStructure callStructure, _) {
     generateConstantTypeLiteral(node);
     generateTypeLiteralCall(node);
@@ skipping 109 matching lines @@
   }
 
   void generateThrowNoSuchMethod(ast.Node diagnosticNode, String methodName,
       {Link<ast.Node> argumentNodes,
       List<HInstruction> argumentValues,
       List<String> existingArguments,
       SourceInformation sourceInformation}) {
     Element helper = helpers.throwNoSuchMethod;
     ConstantValue receiverConstant =
         constantSystem.createString(new ast.DartString.empty());
-    HInstruction receiver = graph.addConstant(receiverConstant, compiler);
+    HInstruction receiver = graph.addConstant(receiverConstant, closedWorld);
     ast.DartString dartString = new ast.DartString.literal(methodName);
     ConstantValue nameConstant = constantSystem.createString(dartString);
-    HInstruction name = graph.addConstant(nameConstant, compiler);
+    HInstruction name = graph.addConstant(nameConstant, closedWorld);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
         HInstruction value = pop();
         argumentValues.add(value);
       });
     }
     HInstruction arguments = buildLiteralList(argumentValues);
     add(arguments);
     HInstruction existingNamesList;
     if (existingArguments != null) {
       List<HInstruction> existingNames = <HInstruction>[];
       for (String name in existingArguments) {
-        HInstruction nameConstant =
-            graph.addConstantString(new ast.DartString.literal(name), compiler);
+        HInstruction nameConstant = graph.addConstantString(
+            new ast.DartString.literal(name), closedWorld);
         existingNames.add(nameConstant);
       }
       existingNamesList = buildLiteralList(existingNames);
       add(existingNamesList);
     } else {
-      existingNamesList = graph.addConstantNull(compiler);
+      existingNamesList = graph.addConstantNull(closedWorld);
     }
     pushInvokeStatic(
         diagnosticNode, helper, [receiver, name, arguments, existingNamesList],
         sourceInformation: sourceInformation);
   }
 
   /**
    * Generate code to throw a [NoSuchMethodError] exception for calling a
    * method with a wrong number of arguments or mismatching named optional
    * arguments.
@@ skipping 30 matching lines @@
         generateThrowNoSuchMethod(
             node.send, noSuchMethodTargetSymbolString(error, 'constructor'),
             argumentNodes: node.send.arguments);
       } else {
         MessageTemplate template = MessageTemplate.TEMPLATES[error.messageKind];
         Message message = template.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
     } else if (Elements.isMalformed(element)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
-      stack.add(graph.addConstantNull(compiler));
+      stack.add(graph.addConstantNull(closedWorld));
     } else if (node.isConst) {
       stack.add(addConstant(node));
       if (isSymbolConstructor) {
         ConstructedConstantValue symbol = getConstantForNode(node);
         StringConstantValue stringConstant = symbol.fields.values.single;
         String nameString = stringConstant.toDartString().slowToString();
         registry?.registerConstSymbol(nameString);
       }
     } else {
       handleNewSend(node);
@@ skipping 247 matching lines @@
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects =
         closedWorld.getSideEffectsOfSelector(selector, null);
     return instruction;
   }
 
   void handleComplexOperatorSend(
       ast.SendSet node, HInstruction receiver, Link<ast.Node> arguments) {
     HInstruction rhs;
     if (node.isPrefix || node.isPostfix) {
-      rhs = graph.addConstantInt(1, compiler);
+      rhs = graph.addConstantInt(1, closedWorld);
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
     visitBinarySend(
         receiver,
         rhs,
         elements.getOperatorSelectorInComplexSendSet(node),
         elementInferenceResults.typeOfOperator(node),
@@ skipping 739 matching lines @@
   }
 
   @override
   visitTypeVariableTypeLiteralSetIfNull(
       ast.Send node, TypeVariableElement element, ast.Node rhs, arg) {
     // The type variable is never `null`.
     generateTypeVariableLiteral(node, element.type);
   }
 
   void visitLiteralInt(ast.LiteralInt node) {
-    stack.add(graph.addConstantInt(node.value, compiler));
+    stack.add(graph.addConstantInt(node.value, closedWorld));
   }
 
   void visitLiteralDouble(ast.LiteralDouble node) {
-    stack.add(graph.addConstantDouble(node.value, compiler));
+    stack.add(graph.addConstantDouble(node.value, closedWorld));
   }
 
   void visitLiteralBool(ast.LiteralBool node) {
-    stack.add(graph.addConstantBool(node.value, compiler));
+    stack.add(graph.addConstantBool(node.value, closedWorld));
   }
 
   void visitLiteralString(ast.LiteralString node) {
-    stack.add(graph.addConstantString(node.dartString, compiler));
+    stack.add(graph.addConstantString(node.dartString, closedWorld));
   }
 
   void visitLiteralSymbol(ast.LiteralSymbol node) {
     stack.add(addConstant(node));
     registry?.registerConstSymbol(node.slowNameString);
   }
 
   void visitStringJuxtaposition(ast.StringJuxtaposition node) {
     if (!node.isInterpolation) {
       // This is a simple string with no interpolations.
-      stack.add(graph.addConstantString(node.dartString, compiler));
+      stack.add(graph.addConstantString(node.dartString, closedWorld));
       return;
     }
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
   void visitLiteralNull(ast.LiteralNull node) {
-    stack.add(graph.addConstantNull(compiler));
+    stack.add(graph.addConstantNull(closedWorld));
   }
 
   visitNodeList(ast.NodeList node) {
     for (Link<ast.Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       if (isAborted()) {
         reporter.reportHintMessage(
             link.head, MessageKind.GENERIC, {'text': 'dead code'});
       } else {
         visit(link.head);
       }
@@ skipping 25 matching lines @@
     if (!inTryStatement) return;
     HBasicBlock block = close(new HExitTry());
     HBasicBlock newBlock = graph.addNewBlock();
     block.addSuccessor(newBlock);
     open(newBlock);
   }
 
   visitRethrow(ast.Rethrow node) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
-      exception = graph.addConstantNull(compiler);
+      exception = graph.addConstantNull(closedWorld);
       reporter.internalError(node, 'rethrowableException should not be null.');
     }
     handleInTryStatement();
     closeAndGotoExit(new HThrow(
         exception, sourceInformationBuilder.buildThrow(node),
         isRethrow: true));
   }
 
   visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
     ConstructorElement targetConstructor =
@@ skipping 24 matching lines @@
     void loadPosition(int position, ParameterElement optionalParameter) {
       if (position < redirectingRequireds.length) {
         loadLocal(redirectingRequireds[position]);
       } else if (position < redirectingSignature.parameterCount &&
           !redirectingSignature.optionalParametersAreNamed) {
         loadLocal(redirectingOptionals[position - redirectingRequireds.length]);
       } else if (optionalParameter != null) {
         inputs.add(handleConstantForOptionalParameter(optionalParameter));
       } else {
         // Wrong.
-        inputs.add(graph.addConstantNull(compiler));
+        inputs.add(graph.addConstantNull(closedWorld));
       }
     }
 
     int position = 0;
 
     for (ParameterElement _ in targetRequireds) {
       loadPosition(position++, null);
     }
 
     if (targetOptionals.isNotEmpty) {
@@ skipping 50 matching lines @@
         (type is InterfaceType && type.element == coreClasses.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(compiler);
+      value = graph.addConstantNull(closedWorld);
     } else {
       visit(node.expression);
       value = pop();
       if (isBuildingAsyncFunction) {
         if (compiler.options.enableTypeAssertions &&
             !isValidAsyncReturnType(returnType)) {
           String message = "Async function returned a Future, "
               "was declared to return a $returnType.";
           generateTypeError(node, message);
           pop();
@@ skipping 37 matching lines @@
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isReachable);
     for (Link<ast.Node> link = node.definitions.nodes;
         !link.isEmpty;
         link = link.tail) {
       ast.Node definition = link.head;
       LocalElement local = elements[definition];
       if (definition is ast.Identifier) {
-        HInstruction initialValue = graph.addConstantNull(compiler);
+        HInstruction initialValue = graph.addConstantNull(closedWorld);
         localsHandler.updateLocal(local, initialValue);
       } else {
         ast.SendSet node = definition;
         generateNonInstanceSetter(
             node, local, visitAndPop(node.arguments.first));
         pop(); // Discard value.
       }
     }
   }
 
@@ skipping 118 matching lines @@
     return new JumpHandler(this, element);
   }
 
   visitAsyncForIn(ast.AsyncForIn node) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
 
     visit(node.expression);
     HInstruction expression = pop();
     pushInvokeStatic(node, helpers.streamIteratorConstructor,
-        [expression, graph.addConstantNull(compiler)]);
+        [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(
@@ skipping 157 matching lines @@
       pushInvokeStatic(
           node, helpers.checkConcurrentModificationError, [pop(), array]);
       pop();
     }
 
     void buildInitializer() {
       visit(node.expression);
       array = pop();
       isFixed = 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, boolType);
       add(compare);
       return compare;
     }
@@ skipping 23 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(
         node, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
@@ skipping 248 matching lines @@
     //   l: while (true) {
     //    switch (target) {
     //       case 1: s_1; break l;
     //       case 2: s_2; target = i; continue l;
     //       ...
     //       case n: s_n; target = j; continue l;
     //     }
     //   }
 
     JumpTarget switchTarget = elements.getTargetDefinition(node);
-    HInstruction initialValue = graph.addConstantNull(compiler);
+    HInstruction initialValue = graph.addConstantNull(closedWorld);
     localsHandler.updateLocal(switchTarget, initialValue);
 
     JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
     var switchCases = node.cases;
     if (!hasDefault) {
       // Use [:null:] as the marker for a synthetic default clause.
       // The synthetic default is added because otherwise, there would be no
       // good place to give a default value to the local.
       switchCases = node.cases.nodes.toList()..add(null);
     }
@@ skipping 15 matching lines @@
     }
 
     bool isDefaultCase(ast.SwitchCase switchCase) {
       return switchCase == null || switchCase.isDefaultCase;
     }
 
     void buildSwitchCase(ast.SwitchCase switchCase) {
       if (switchCase != null) {
         // Generate 'target = i; break;' for switch case i.
         int index = caseIndex[switchCase];
-        HInstruction value = graph.addConstantInt(index, compiler);
+        HInstruction value = graph.addConstantInt(index, closedWorld);
         localsHandler.updateLocal(switchTarget, value);
       } else {
         // Generate synthetic default case 'target = null; break;'.
-        HInstruction value = graph.addConstantNull(compiler);
+        HInstruction value = graph.addConstantNull(closedWorld);
         localsHandler.updateLocal(switchTarget, value);
       }
       jumpTargets[switchTarget].generateBreak();
     }
 
     handleSwitch(node, jumpHandler, buildExpression, switchCases, getConstants,
         isDefaultCase, buildSwitchCase);
     jumpHandler.close();
 
-    HInstruction buildCondition() => graph.addConstantBool(true, compiler);
+    HInstruction buildCondition() => graph.addConstantBool(true, closedWorld);
 
     void buildSwitch() {
       HInstruction buildExpression() {
         return localsHandler.readLocal(switchTarget);
       }
 
       Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
         return <ConstantValue>[constantSystem.createInt(caseIndex[switchCase])];
       }
 
@@ skipping 74 matching lines @@
     LocalsHandler savedLocals = localsHandler;
 
     List<HStatementInformation> statements = <HStatementInformation>[];
     bool hasDefault = false;
     HasNextIterator<ast.Node> caseIterator =
         new HasNextIterator<ast.Node>(switchCases.iterator);
     while (caseIterator.hasNext) {
       ast.SwitchCase switchCase = caseIterator.next();
       HBasicBlock block = graph.addNewBlock();
       for (ConstantValue constant in getConstants(switchCase)) {
-        HConstant hConstant = graph.addConstant(constant, compiler);
+        HConstant hConstant = graph.addConstant(constant, closedWorld);
         switchInstruction.inputs.add(hConstant);
         hConstant.usedBy.add(switchInstruction);
         expressionEnd.addSuccessor(block);
       }
 
       if (isDefaultCase(switchCase)) {
         // An HSwitch has n inputs and n+1 successors, the last being the
         // default case.
         expressionEnd.addSuccessor(block);
         hasDefault = true;
@@ skipping 234 matching lines @@
           if (type == null) {
             reporter.internalError(catchBlock.type, 'On with no type.');
           }
           HInstruction condition =
               buildIsNode(catchBlock.type, type, unwrappedException);
           push(condition);
         } else {
           ast.VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
-            condition = graph.addConstantBool(true, compiler);
+            condition = graph.addConstantBool(true, closedWorld);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
             // condition.
             DartType type = elements.getType(declaration.type);
             if (type == null) {
               reporter.internalError(catchBlock, 'Catch with unresolved type.');
             }
@@ skipping 486 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }