Reduce use of 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 423 matching lines @@
       if (compiler.options.disableInlining) return false;
 
       assert(invariant(
           currentNode != null ? currentNode : element,
           selector != null ||
               Elements.isStaticOrTopLevel(element) ||
               element.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $element."));
       if (selector != null) {
         if (!selector.applies(function)) return false;
-        if (mask != null &&
-            !mask.canHit(function, selector, compiler.closedWorld)) {
+        if (mask != null && !mask.canHit(function, selector, closedWorld)) {
           return false;
         }
       }
 
       if (backend.isJsInterop(element)) return false;
 
       // Don't inline operator== methods if the parameter can be null.
       if (element.name == '==') {
         if (element.enclosingClass != coreClasses.objectClass &&
             providedArguments[1].canBeNull()) {
@@ skipping 104 matching lines @@
     }
 
     void doInlining() {
       // Add an explicit null check on the receiver before doing the
       // inlining. We use [element] to get the same name in the
       // NoSuchMethodError message as if we had called it.
       if (element.isInstanceMember &&
           !element.isGenerativeConstructorBody &&
           (mask == null || mask.isNullable)) {
         addWithPosition(
-            new HFieldGet(null, providedArguments[0], backend.dynamicType,
+            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);
@@ skipping 97 matching lines @@
     return graph.addConstant(getConstantForNode(node), compiler);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
-    graph.calledInLoop = compiler.closedWorld.isCalledInLoop(functionElement);
+    graph.calledInLoop = closedWorld.isCalledInLoop(functionElement);
     ast.FunctionExpression function = resolvedAst.node;
     assert(function != null);
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     if (backend.isJsInterop(functionElement)) {
       push(invokeJsInteropFunction(functionElement, parameters.values.toList(),
           sourceInformationBuilder.buildGeneric(function)));
       var value = pop();
       closeAndGotoExit(new HReturn(
           value, sourceInformationBuilder.buildReturn(functionElement.node)));
       return closeFunction();
     }
     assert(invariant(functionElement, !function.modifiers.isExternal));
 
     // 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),
-                  null, backend.boolType));
+                  null, commonMasks.boolType));
             },
             visitThen: () {
               closeAndGotoExit(new HReturn(
                   graph.addConstantBool(false, compiler),
                   sourceInformationBuilder
                       .buildImplicitReturn(functionElement)));
             },
             visitElse: null,
             sourceInformation: sourceInformationBuilder.buildIf(function.body));
       }
@@ skipping 12 matching lines @@
     return closeFunction();
   }
 
   /// Adds a JavaScript comment to the output. The comment will be omitted in
   /// minified mode.  Each line in [text] is preceded with `//` and indented.
   /// Use sparingly. In order for the comment to be retained it is modeled as
   /// having side effects which will inhibit code motion.
   // TODO(sra): Figure out how to keep comment anchored without effects.
   void addComment(String text) {
     add(new HForeignCode(js.js.statementTemplateYielding(new js.Comment(text)),
-        backend.dynamicType, <HInstruction>[],
+        commonMasks.dynamicType, <HInstruction>[],
         isStatement: true));
   }
 
   HGraph buildCheckedSetter(FieldElement field) {
     ResolvedAst resolvedAst = field.resolvedAst;
     openFunction(field, resolvedAst.node);
     HInstruction thisInstruction = localsHandler.readThis();
     // Use dynamic type because the type computed by the inferrer is
     // narrowed to the type annotation.
-    HInstruction parameter = new HParameterValue(field, backend.dynamicType);
+    HInstruction parameter =
+        new HParameterValue(field, commonMasks.dynamicType);
     // Add the parameter as the last instruction of the entry block.
     // If the method is intercepted, we want the actual receiver
     // to be the first parameter.
     graph.entry.addBefore(graph.entry.last, parameter);
     HInstruction value =
         typeBuilder.potentiallyCheckOrTrustType(parameter, field.type);
     add(new HFieldSet(field, thisInstruction, value));
     return closeFunction();
   }
 
@@ skipping 509 matching lines @@
             member, isNativeUpgradeFactory || compiler.compilationFailed));
       } else {
         fields.add(member);
         DartType type = localsHandler.substInContext(member.type);
         constructorArguments
             .add(typeBuilder.potentiallyCheckOrTrustType(value, type));
       }
     }, includeSuperAndInjectedMembers: true);
 
     InterfaceType type = classElement.thisType;
-    TypeMask ssaType = new TypeMask.nonNullExact(
-        classElement.declaration, compiler.closedWorld);
+    TypeMask ssaType =
+        new TypeMask.nonNullExact(classElement.declaration, closedWorld);
     List<DartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
       instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations);
     }
 
     HInstruction newObject;
     if (!isNativeUpgradeFactory) {
       // Create the runtime type information, if needed.
       bool hasRtiInput = false;
       if (backend.classNeedsRtiField(classElement)) {
         // Read the values of the type arguments and create a
         // HTypeInfoExpression to set on the newly create object.
         hasRtiInput = true;
         List<HInstruction> typeArguments = <HInstruction>[];
         classElement.typeVariables.forEach((TypeVariableType typeVariable) {
           HInstruction argument = localsHandler
               .readLocal(localsHandler.getTypeVariableAsLocal(typeVariable));
           typeArguments.add(argument);
         });
 
         HInstruction typeInfo = new HTypeInfoExpression(
             TypeInfoExpressionKind.INSTANCE,
             classElement.thisType,
             typeArguments,
-            backend.dynamicType);
+            commonMasks.dynamicType);
         add(typeInfo);
         constructorArguments.add(typeInfo);
       }
 
       newObject = new HCreate(classElement, constructorArguments, ssaType,
           instantiatedTypes: instantiatedTypes, hasRtiInput: hasRtiInput);
       if (function != null) {
         // TODO(johnniwinther): Provide source information for creation through
         // synthetic constructors.
         newObject.sourceInformation =
             sourceInformationBuilder.buildCreate(function);
       }
       add(newObject);
     } else {
       // Bulk assign to the initialized fields.
       newObject = graph.explicitReceiverParameter;
       // Null guard ensures an error if we are being called from an explicit
       // 'new' of the constructor instead of via an upgrade. It is optimized out
       // if there are field initializers.
-      add(new HFieldGet(null, newObject, backend.dynamicType,
+      add(new HFieldGet(null, newObject, commonMasks.dynamicType,
           isAssignable: false));
       for (int i = 0; i < fields.length; i++) {
         add(new HFieldSet(fields[i], newObject, constructorArguments[i]));
       }
     }
     removeInlinedInstantiation(type);
 
     // Generate calls to the constructor bodies.
     HInstruction interceptor = null;
     for (int index = constructorResolvedAsts.length - 1; index >= 0; index--) {
@@ skipping 46 matching lines @@
           bodyCallInputs.add(localsHandler
               .readLocal(localsHandler.getTypeVariableAsLocal(argument)));
         });
       }
 
       if (!isNativeUpgradeFactory && // TODO(13836): Fix inlining.
           tryInlineMethod(body, null, null, bodyCallInputs, function)) {
         pop();
       } else {
         HInvokeConstructorBody invoke = new HInvokeConstructorBody(
-            body.declaration, bodyCallInputs, backend.nonNullType);
-        invoke.sideEffects =
-            compiler.closedWorld.getSideEffectsOfElement(constructor);
+            body.declaration, bodyCallInputs, commonMasks.nonNullType);
+        invoke.sideEffects = closedWorld.getSideEffectsOfElement(constructor);
         add(invoke);
       }
     }
     if (inliningStack.isEmpty) {
       closeAndGotoExit(new HReturn(newObject,
           sourceInformationBuilder.buildImplicitReturn(functionElement)));
       return closeFunction();
     } else {
       localsHandler.updateLocal(returnLocal, newObject);
       return null;
@@ skipping 16 matching lines @@
     open(block);
 
     // Add the type parameters of the class as parameters of this method.  This
     // must be done before adding the normal parameters, because their types
     // may contain references to type variables.
     var enclosing = element.enclosingElement;
     if ((element.isConstructor || element.isGenerativeConstructorBody) &&
         backend.classNeedsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
         HParameterValue param =
-            addParameter(typeVariable.element, backend.nonNullType);
+            addParameter(typeVariable.element, commonMasks.nonNullType);
         localsHandler.directLocals[
             localsHandler.getTypeVariableAsLocal(typeVariable)] = param;
       });
     }
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature signature = functionElement.functionSignature;
 
       // Put the type checks in the first successor of the entry,
@@ skipping 43 matching lines @@
   }
 
   insertTraceCall(Element element) {
     if (JavaScriptBackend.TRACE_METHOD == 'console') {
       if (element == backend.helpers.traceHelper) return;
       n(e) => e == null ? '' : e.name;
       String name = "${n(element.library)}:${n(element.enclosingClass)}."
           "${n(element)}";
       HConstant nameConstant = addConstantString(name);
       add(new HInvokeStatic(backend.helpers.traceHelper,
-          <HInstruction>[nameConstant], backend.dynamicType));
+          <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 nameConstant = addConstantString(element.name);
       add(new HInvokeStatic(backend.helpers.traceHelper,
-          <HInstruction>[idConstant, nameConstant], backend.dynamicType));
+          <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 =
@@ skipping 25 matching lines @@
   ///
   /// Boolification is checking if the value is '=== true'.
   @override
   HInstruction popBoolified() {
     HInstruction value = pop();
     if (typeBuilder.checkOrTrustTypes) {
       return typeBuilder.potentiallyCheckOrTrustType(
           value, compiler.coreTypes.boolType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
-    HInstruction result = new HBoolify(value, backend.boolType);
+    HInstruction result = new HBoolify(value, commonMasks.boolType);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, ast.Node node) {
     if (node != null) {
       target.sourceInformation = sourceInformationBuilder.buildGeneric(node);
     }
     return target;
   }
@@ skipping 292 matching lines @@
     registry?.registerStaticUse(new StaticUse.foreignUse(callElement));
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureClassElement.closureFields.forEach((ClosureFieldElement field) {
       Local capturedLocal =
           nestedClosureData.getLocalVariableForClosureField(field);
       assert(capturedLocal != null);
       capturedVariables.add(localsHandler.readLocal(capturedLocal));
     });
 
-    TypeMask type =
-        new TypeMask.nonNullExact(closureClassElement, compiler.closedWorld);
+    TypeMask type = new TypeMask.nonNullExact(closureClassElement, closedWorld);
     push(new HCreate(closureClassElement, capturedVariables, type)
       ..sourceInformation = sourceInformationBuilder.buildCreate(node));
 
     registry?.registerInstantiatedClosure(methodElement);
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     assert(isReachable);
     visit(node.function);
     LocalFunctionElement localFunction =
@@ skipping 83 matching lines @@
     handleLogicalBinaryWithLeftNode(left, () => visit(right), branchBuilder,
         isAnd: false);
   }
 
   @override
   void visitNot(ast.Send node, ast.Node expression, _) {
     assert(node.argumentsNode is ast.Prefix);
     visit(expression);
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGeneric(node);
-    push(new HNot(popBoolified(), backend.boolType)
+    push(new HNot(popBoolified(), commonMasks.boolType)
       ..sourceInformation = sourceInformation);
   }
 
   @override
   void visitUnary(
       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.
@@ skipping 24 matching lines @@
   }
 
   @override
   void visitEquals(ast.Send node, ast.Node left, ast.Node right, _) {
     handleBinary(node, left, right);
   }
 
   @override
   void visitNotEquals(ast.Send node, ast.Node left, ast.Node right, _) {
     handleBinary(node, left, right);
-    pushWithPosition(new HNot(popBoolified(), backend.boolType), node.selector);
+    pushWithPosition(
+        new HNot(popBoolified(), commonMasks.boolType), node.selector);
   }
 
   void handleBinary(ast.Send node, ast.Node left, ast.Node right) {
     visitBinarySend(
         visitAndPop(left),
         visitAndPop(right),
         elements.getSelector(node),
         elementInferenceResults.typeOfSend(node),
         node,
         sourceInformation:
@@ skipping 95 matching lines @@
           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);
-    if (!type.containsAll(compiler.closedWorld) &&
-        !instruction.isConstantNull()) {
+    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);
   }
@@ skipping 43 matching lines @@
         elementInferenceResults.typeOfSend(node), receiver);
   }
 
   /// Generate a closurization of the static or top level [method].
   void generateStaticFunctionGet(ast.Send node, MethodElement method) {
     assert(method.isDeclaration);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
-    push(new HStatic(method, backend.nonNullType)
+    push(new HStatic(method, commonMasks.nonNullType)
       ..sourceInformation = sourceInformation);
   }
 
   /// Read a local variable, function or parameter.
   void buildLocalGet(LocalElement local, SourceInformation sourceInformation) {
     stack.add(
         localsHandler.readLocal(local, sourceInformation: sourceInformation));
   }
 
   void handleLocalGet(ast.Send node, LocalElement local) {
@@ skipping 153 matching lines @@
         stack.add(checkedOrTrusted);
       }
 
       localsHandler.updateLocal(local, checkedOrTrusted,
           sourceInformation:
               sourceInformationBuilder.buildAssignment(location));
     }
   }
 
   HInstruction invokeInterceptor(HInstruction receiver) {
-    HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType);
+    HInterceptor interceptor =
+        new HInterceptor(receiver, commonMasks.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
-    return new HLiteralList(inputs, backend.extendableArrayType);
+    return new HLiteralList(inputs, commonMasks.extendableArrayType);
   }
 
   @override
   void visitAs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     if (type.isMalformed) {
       if (type is MalformedType) {
         ErroneousElement element = type.element;
         generateTypeError(node, element.message);
       } else {
@@ skipping 14 matching lines @@
   void visitIs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     push(buildIsNode(node, type, expressionInstruction));
   }
 
   @override
   void visitIsNot(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     HInstruction instruction = buildIsNode(node, type, expressionInstruction);
     add(instruction);
-    push(new HNot(instruction, backend.boolType));
+    push(new HNot(instruction, commonMasks.boolType));
   }
 
   HInstruction buildIsNode(
       ast.Node node, DartType type, HInstruction expression) {
     type = localsHandler.substInContext(type).unaliased;
     if (type.isMalformed) {
       String message;
       if (type is MethodTypeVariableType) {
         message = "Method type variables are not reified, "
             "so they cannot be tested with an `is` expression.";
       } else {
         assert(type is MalformedType);
         ErroneousElement element = type.element;
         message = element.message;
       }
       generateTypeError(node, message);
       HInstruction call = pop();
-      return new HIs.compound(type, expression, call, backend.boolType);
+      return new HIs.compound(type, expression, call, commonMasks.boolType);
     } else if (type.isFunctionType) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
           node,
           new Selector.call(new PrivateName('_isTest', helpers.jsHelperLibrary),
               CallStructure.ONE_ARG),
           null,
           arguments);
-      return new HIs.compound(type, expression, pop(), backend.boolType);
+      return new HIs.compound(type, expression, pop(), commonMasks.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType =
           typeBuilder.addTypeVariableReference(type, sourceElement);
       Element helper = helpers.checkSubtypeOfRuntimeType;
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
-      pushInvokeStatic(null, helper, inputs, typeMask: backend.boolType);
+      pushInvokeStatic(null, helper, inputs, typeMask: commonMasks.boolType);
       HInstruction call = pop();
-      return new HIs.variable(type, expression, call, backend.boolType);
+      return new HIs.variable(type, expression, call, commonMasks.boolType);
     } 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 = compiler.closedWorld
-              .hasAnyStrictSubtype(element)
+      HInstruction asFieldName = closedWorld.hasAnyStrictSubtype(element)
           ? addConstantStringFromName(backend.namer.substitutionName(element))
           : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
-      pushInvokeStatic(node, helper, inputs, typeMask: backend.boolType);
+      pushInvokeStatic(node, helper, inputs, typeMask: commonMasks.boolType);
       HInstruction call = pop();
-      return new HIs.compound(type, expression, call, backend.boolType);
+      return new HIs.compound(type, expression, call, commonMasks.boolType);
     } else {
       if (backend.hasDirectCheckFor(type)) {
-        return new HIs.direct(type, expression, backend.boolType);
+        return new HIs.direct(type, expression, commonMasks.boolType);
       }
       // The interceptor is not always needed.  It is removed by optimization
       // when the receiver type or tested type permit.
-      return new HIs.raw(
-          type, expression, invokeInterceptor(expression), backend.boolType);
+      return new HIs.raw(type, expression, invokeInterceptor(expression),
+          commonMasks.boolType);
     }
   }
 
   void addDynamicSendArgumentsToList(ast.Send node, List<HInstruction> list) {
     CallStructure callStructure = elements.getSelector(node).callStructure;
     if (callStructure.namedArgumentCount == 0) {
       addGenericSendArgumentsToList(node.arguments, list);
     } else {
       // Visit positional arguments and add them to the list.
       Link<ast.Node> arguments = node.arguments;
@@ skipping 196 matching lines @@
         ..sourceInformation = sourceInformation);
     }
   }
 
   void handleJsStringConcat(ast.Send node) {
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(node.arguments, inputs);
     if (inputs.length != 2) {
       reporter.internalError(node.argumentsNode, 'Two arguments expected.');
     }
-    push(new HStringConcat(inputs[0], inputs[1], backend.stringType));
+    push(new HStringConcat(inputs[0], inputs[1], commonMasks.stringType));
   }
 
   void handleForeignJsCurrentIsolateContext(ast.Send node) {
     if (!node.arguments.isEmpty) {
       reporter.internalError(
           node, 'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.');
     }
 
     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), backend.dynamicType, <HInstruction>[],
+          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
       // Leg's isolate.
       Element element = helpers.currentIsolate;
       if (element == null) {
         reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
-      pushInvokeStatic(null, element, [], typeMask: backend.dynamicType);
+      pushInvokeStatic(null, element, [], typeMask: commonMasks.dynamicType);
     }
   }
 
   void handleForeignJsGetFlag(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_FLAG.'});
@@ skipping 165 matching lines @@
     stack.add(graph.addConstantNull(compiler));
   }
 
   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()], backend.dynamicType));
+          <HInstruction>[pop()], commonMasks.dynamicType));
     } else {
       // Call a helper method from the isolate library.
       Element element = helpers.callInIsolate;
       if (element == null) {
         reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
       List<HInstruction> inputs = <HInstruction>[];
       addGenericSendArgumentsToList(link, inputs);
-      pushInvokeStatic(node, element, inputs, typeMask: backend.dynamicType);
+      pushInvokeStatic(node, element, inputs,
+          typeMask: commonMasks.dynamicType);
     }
   }
 
   FunctionSignature handleForeignRawFunctionRef(ast.Send node, String name) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       reporter.internalError(
           node.argumentsNode, '"$name" requires exactly one argument.');
     }
     ast.Node closure = node.arguments.head;
     Element element = elements[closure];
     if (!Elements.isStaticOrTopLevelFunction(element)) {
       reporter.internalError(
           closure, '"$name" requires a static or top-level method.');
     }
     FunctionElement function = element;
     // TODO(johnniwinther): Try to eliminate the need to distinguish declaration
     // and implementation signatures. Currently it is need because the
     // signatures have different elements for parameters.
     FunctionElement implementation = function.implementation;
     FunctionSignature params = implementation.functionSignature;
     if (params.optionalParameterCount != 0) {
       reporter.internalError(
           closure, '"$name" does not handle closure with optional parameters.');
     }
 
     registry?.registerStaticUse(new StaticUse.foreignUse(function));
     push(new HForeignCode(
         js.js.expressionTemplateYielding(
             backend.emitter.staticFunctionAccess(function)),
-        backend.dynamicType,
+        commonMasks.dynamicType,
         <HInstruction>[],
         nativeBehavior: native.NativeBehavior.PURE));
     return params;
   }
 
   void handleForeignDartClosureToJs(ast.Send node, String name) {
     // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take
     // care to wrap the closure in another closure that saves the current
     // isolate.
     handleForeignRawFunctionRef(node, name);
   }
 
   void handleForeignJsSetStaticState(ast.Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       reporter.internalError(
           node.argumentsNode, 'Exactly one argument required.');
     }
     visit(node.arguments.head);
     String isolateName = backend.namer.staticStateHolder;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
     push(new HForeignCode(js.js.parseForeignJS("$isolateName = #"),
-        backend.dynamicType, <HInstruction>[pop()],
+        commonMasks.dynamicType, <HInstruction>[pop()],
         nativeBehavior: native.NativeBehavior.CHANGES_OTHER,
         effects: sideEffects));
   }
 
   void handleForeignJsGetStaticState(ast.Send node) {
     if (!node.arguments.isEmpty) {
       reporter.internalError(node.argumentsNode, 'Too many arguments.');
     }
     push(new HForeignCode(js.js.parseForeignJS(backend.namer.staticStateHolder),
-        backend.dynamicType, <HInstruction>[],
+        commonMasks.dynamicType, <HInstruction>[],
         nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
   }
 
   void handleForeignSend(ast.Send node, FunctionElement element) {
     String name = element.name;
     if (name == BackendHelpers.JS) {
       handleForeignJs(node);
     } else if (name == 'JS_CURRENT_ISOLATE_CONTEXT') {
       handleForeignJsCurrentIsolateContext(node);
     } else if (name == 'JS_CALL_IN_ISOLATE') {
@@ skipping 29 matching lines @@
       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)
     ];
-    push(new HInvokeStatic(loadFunction, inputs, backend.nonNullType,
+    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;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
@@ skipping 34 matching lines @@
     pushInvokeStatic(
         null,
         createInvocationMirror,
         [
           graph.addConstant(nameConstant, compiler),
           graph.addConstantStringFromName(internalName, compiler),
           graph.addConstant(kindConstant, compiler),
           argumentsInstruction,
           argumentNamesInstruction
         ],
-        typeMask: backend.dynamicType);
+        typeMask: commonMasks.dynamicType);
 
     var inputs = <HInstruction>[pop()];
     push(buildInvokeSuper(Selectors.noSuchMethod_, element, inputs));
   }
 
   /// Generate a call to a super method or constructor.
   void generateSuperInvoke(ast.Send node, MethodElement method,
       SourceInformation sourceInformation) {
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
@@ skipping 127 matching lines @@
   @override
   void visitSuperBinary(ast.Send node, MethodElement method,
       BinaryOperator operator, ast.Node argument, _) {
     handleSuperMethodInvoke(node, method);
   }
 
   @override
   void visitSuperNotEquals(
       ast.Send node, MethodElement method, ast.Node argument, _) {
     handleSuperMethodInvoke(node, method);
-    pushWithPosition(new HNot(popBoolified(), backend.boolType), node.selector);
+    pushWithPosition(
+        new HNot(popBoolified(), commonMasks.boolType), node.selector);
   }
 
   @override
   void visitSuperUnary(
       ast.Send node, UnaryOperator operator, MethodElement method, _) {
     handleSuperMethodInvoke(node, method);
   }
 
   @override
   void visitSuperMethodIncompatibleInvoke(ast.Send node, MethodElement method,
       ast.NodeList arguments, CallStructure callStructure, _) {
     handleInvalidSuperInvoke(node, arguments);
   }
 
   @override
   void visitSuperSetterInvoke(ast.Send node, SetterElement setter,
       ast.NodeList arguments, CallStructure callStructure, _) {
     handleInvalidSuperInvoke(node, arguments);
   }
 
   void handleInvalidSuperInvoke(ast.Send node, ast.NodeList arguments) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(arguments.nodes, inputs);
     generateSuperNoSuchMethodSend(node, selector, inputs);
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
-    ClosedWorld closedWorld = compiler.closedWorld;
     if (closedWorld.isUsedAsMixin(cls)) return true;
 
-    return compiler.closedWorld.anyStrictSubclassOf(cls,
-        (ClassElement subclass) {
+    return closedWorld.anyStrictSubclassOf(cls, (ClassElement subclass) {
       return !rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   HInstruction handleListConstructor(
       InterfaceType type, ast.Node currentNode, HInstruction newObject) {
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
     List<HInstruction> inputs = <HInstruction>[];
     type = localsHandler.substInContext(type);
     type.typeArguments.forEach((DartType argument) {
       inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     });
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, inputs, newObject);
   }
 
   HInstruction callSetRuntimeTypeInfo(
       HInstruction typeInfo, HInstruction newObject) {
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = helpers.setRuntimeTypeInfo;
     pushInvokeStatic(
         null, typeInfoSetterElement, <HInstruction>[newObject, typeInfo],
-        typeMask: backend.dynamicType,
+        typeMask: commonMasks.dynamicType,
         sourceInformation: newObject.sourceInformation);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
     assert(invariant(CURRENT_ELEMENT_SPANNABLE,
         stack.last is HInvokeStatic || stack.last == newObject,
         message: "Unexpected `stack.last`: Found ${stack.last}, "
             "expected ${newObject} or an HInvokeStatic. "
             "State: typeInfo=$typeInfo, stack=$stack."));
@@ skipping 11 matching lines @@
     bool isGrowableListConstructorCall =
         Elements.isGrowableListConstructorCall(elements[send], send, compiler);
 
     TypeMask computeType(element) {
       Element originalElement = elements[send];
       if (isFixedListConstructorCall ||
           Elements.isFilledListConstructorCall(
               originalElement, send, compiler)) {
         isFixedList = true;
         TypeMask inferred = _inferredTypeOfNewList(send);
-        return inferred.containsAll(compiler.closedWorld)
-            ? backend.fixedArrayType
+        return inferred.containsAll(closedWorld)
+            ? commonMasks.fixedArrayType
             : inferred;
       } else if (isGrowableListConstructorCall) {
         TypeMask inferred = _inferredTypeOfNewList(send);
-        return inferred.containsAll(compiler.closedWorld)
-            ? backend.extendableArrayType
+        return inferred.containsAll(closedWorld)
+            ? commonMasks.extendableArrayType
             : inferred;
       } else if (Elements.isConstructorOfTypedArraySubclass(
           originalElement, compiler)) {
         isFixedList = true;
         TypeMask inferred = _inferredTypeOfNewList(send);
         ClassElement cls = element.enclosingClass;
         assert(backend.isNative(cls.thisType.element));
-        return inferred.containsAll(compiler.closedWorld)
-            ? new TypeMask.nonNullExact(
-                cls.thisType.element, compiler.closedWorld)
+        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, compiler.closedWorld);
+          return new TypeMask.nonNullExact(cls.thisType.element, closedWorld);
         }
       } else {
         return TypeMaskFactory.inferredReturnTypeForElement(
             originalElement, compiler);
       }
     }
 
     Element constructor = elements[send];
     CallStructure callStructure = elements.getSelector(send).callStructure;
     ConstructorElement constructorDeclaration = constructor;
@@ skipping 57 matching lines @@
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     constructorImplementation = constructor.implementation;
     if (constructorImplementation.isMalformed ||
         !callStructure
             .signatureApplies(constructorImplementation.functionSignature)) {
       generateWrongArgumentCountError(send, constructor, send.arguments);
       return;
     }
 
-    var inputs = <HInstruction>[];
+    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.addAll(makeStaticArgumentList(
         callStructure, send.arguments, constructorImplementation));
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
-      if (!inputs[0].isNumber(compiler)) {
-        HTypeConversion conversion = new HTypeConversion(null,
-            HTypeConversion.ARGUMENT_TYPE_CHECK, backend.numType, inputs[0]);
+      if (!inputs[0].isNumber(closedWorld)) {
+        HTypeConversion conversion = new HTypeConversion(
+            null,
+            HTypeConversion.ARGUMENT_TYPE_CHECK,
+            commonMasks.numType,
+            inputs[0]);
         add(conversion);
         inputs[0] = conversion;
       }
       js.Template code = js.js.parseForeignJS('new Array(#)');
       var behavior = new native.NativeBehavior();
       behavior.typesReturned.add(expectedType);
       // The allocation can throw only if the given length is a double or
       // outside the unsigned 32 bit range.
       // TODO(sra): Array allocation should be an instruction so that canThrow
       // can depend on a length type discovered in optimization.
       bool canThrow = true;
-      if (inputs[0].isInteger(compiler) && inputs[0] is HConstant) {
+      if (inputs[0].isInteger(closedWorld) && inputs[0] is HConstant) {
         var constant = inputs[0];
         int value = constant.constant.primitiveValue;
         if (0 <= value && value < 0x100000000) canThrow = false;
       }
       HForeignCode foreign = new HForeignCode(code, elementType, inputs,
           nativeBehavior: behavior,
           throwBehavior: canThrow
               ? native.NativeThrowBehavior.MAY
               : native.NativeThrowBehavior.NEVER);
       push(foreign);
       if (inferenceResults.isFixedArrayCheckedForGrowable(send)) {
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
-        add(new HForeignCode(code, backend.nullType, [stack.last],
+        add(new HForeignCode(code, commonMasks.nullType, [stack.last],
             throwBehavior: native.NativeThrowBehavior.MAY));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
       SourceInformation sourceInformation =
           sourceInformationBuilder.buildNew(send);
       potentiallyAddTypeArguments(inputs, cls, expectedType);
       addInlinedInstantiation(expectedType);
@@ skipping 104 matching lines @@
   }
 
   /// Generate an invocation to the static or top level [function].
   void generateStaticFunctionInvoke(
       ast.Send node, FunctionElement function, CallStructure callStructure) {
     List<HInstruction> inputs = makeStaticArgumentList(
         callStructure, node.arguments, function.implementation);
 
     if (function == compiler.commonElements.identicalFunction) {
       pushWithPosition(
-          new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
+          new HIdentity(inputs[0], inputs[1], null, commonMasks.boolType),
+          node);
       return;
     } else {
       pushInvokeStatic(node, function, inputs,
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 
   /// Generate an invocation to a static or top level function with the wrong
   /// number of arguments.
@@ skipping 184 matching lines @@
     // GENERIC_METHODS: This provides thin support for method type variables
     // by treating them as malformed when evaluated as a literal. For full
     // support of generic methods this must be revised.
     if (typeVariable is MethodTypeVariableType) {
       generateTypeError(node, "Method type variables are not reified");
     } else {
       DartType type = localsHandler.substInContext(typeVariable);
       HInstruction value = typeBuilder.analyzeTypeArgument(type, sourceElement,
           sourceInformation: sourceInformationBuilder.buildGet(node));
       pushInvokeStatic(node, helpers.runtimeTypeToString, [value],
-          typeMask: backend.stringType);
+          typeMask: commonMasks.stringType);
       pushInvokeStatic(node, helpers.createRuntimeType, [pop()]);
     }
   }
 
   /// Generate a call to a type literal.
   void generateTypeLiteralCall(ast.Send node) {
     // This send is of the form 'e(...)', where e is resolved to a type
     // reference. We create a regular closure call on the result of the type
     // reference instead of creating a NoSuchMethodError to avoid pulling it
     // in if it is not used (e.g., in a try/catch).
     HInstruction target = pop();
     generateCallInvoke(node, target,
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   /// Generate a '.call' invocation on [target].
   void generateCallInvoke(
       ast.Send node, HInstruction target, SourceInformation sourceInformation) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[target];
     addDynamicSendArgumentsToList(node, inputs);
     push(new HInvokeClosure(
-        new Selector.callClosureFrom(selector), inputs, backend.dynamicType)
+        new Selector.callClosureFrom(selector), inputs, commonMasks.dynamicType)
       ..sourceInformation = sourceInformation);
   }
 
   visitGetterSend(ast.Send node) {
     internalError(node, "Unexpected visitGetterSend");
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
   internalError(Spannable node, String reason) {
     reporter.internalError(node, reason);
@@ skipping 128 matching lines @@
   void pushInvokeDynamic(ast.Node node, Selector selector, TypeMask mask,
       List<HInstruction> arguments,
       {SourceInformation sourceInformation}) {
     // We prefer to not inline certain operations on indexables,
     // because the constant folder will handle them better and turn
     // them into simpler instructions that allow further
     // optimizations.
     bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
       bool isLength = selector.isGetter && selector.name == "length";
       if (isLength || selector.isIndex) {
-        return compiler.closedWorld.isSubtypeOf(
+        return closedWorld.isSubtypeOf(
             element.enclosingClass.declaration, helpers.jsIndexableClass);
       } else if (selector.isIndexSet) {
-        return compiler.closedWorld.isSubtypeOf(
-            element.enclosingClass.declaration,
+        return closedWorld.isSubtypeOf(element.enclosingClass.declaration,
             helpers.jsMutableIndexableClass);
       } else {
         return false;
       }
     }
 
     bool isOptimizableOperation(Selector selector, Element element) {
       ClassElement cls = element.enclosingClass;
       if (isOptimizableOperationOnIndexable(selector, element)) return true;
       if (!backend.interceptedClasses.contains(cls)) return false;
       if (selector.isOperator) return true;
       if (selector.isSetter) return true;
       if (selector.isIndex) return true;
       if (selector.isIndexSet) return true;
       if (element == helpers.jsArrayAdd ||
           element == helpers.jsArrayRemoveLast ||
           element == helpers.jsStringSplit) {
         return true;
       }
       return false;
     }
 
-    Element element = compiler.closedWorld.locateSingleElement(selector, mask);
+    Element element = closedWorld.locateSingleElement(selector, mask);
     if (element != null &&
         !element.isField &&
         !(element.isGetter && selector.isCall) &&
         !(element.isFunction && selector.isGetter) &&
         !isOptimizableOperation(selector, element)) {
       if (tryInlineMethod(element, selector, mask, arguments, node)) {
         return;
       }
     }
 
@@ skipping 49 matching lines @@
       });
       var codeTemplate =
           new js.Template(null, js.objectLiteral(parameterNameMap));
 
       var nativeBehavior = new native.NativeBehavior()
         ..codeTemplate = codeTemplate;
       if (compiler.options.trustJSInteropTypeAnnotations) {
         nativeBehavior.typesReturned.add(constructor.enclosingClass.thisType);
       }
       return new HForeignCode(
-          codeTemplate, backend.dynamicType, filteredArguments,
+          codeTemplate, commonMasks.dynamicType, filteredArguments,
           nativeBehavior: nativeBehavior)
         ..sourceInformation = sourceInformation;
     }
     var target = new HForeignCode(
         js.js.parseForeignJS("${backend.namer.fixedBackendPath(element)}."
             "${backend.nativeData.getFixedBackendName(element)}"),
-        backend.dynamicType,
+        commonMasks.dynamicType,
         <HInstruction>[]);
     add(target);
     // Strip off trailing arguments that were not specified.
     // we could assert that the trailing arguments are all null.
     // TODO(jacobr): rewrite named arguments to an object literal matching
     // the factory constructor case.
     arguments = arguments.where((arg) => arg != null).toList();
     var inputs = <HInstruction>[target]..addAll(arguments);
 
     var nativeBehavior = new native.NativeBehavior()
@@ skipping 30 matching lines @@
       code = "#";
     } else if (element.isSetter) {
       code = "# = #";
     } else {
       var args = new List.filled(arguments.length, '#').join(',');
       code = element.isConstructor ? "new #($args)" : "#($args)";
     }
     js.Template codeTemplate = js.js.parseForeignJS(code);
     nativeBehavior.codeTemplate = codeTemplate;
 
-    return new HForeignCode(codeTemplate, backend.dynamicType, inputs,
+    return new HForeignCode(codeTemplate, commonMasks.dynamicType, inputs,
         nativeBehavior: nativeBehavior)..sourceInformation = sourceInformation;
   }
 
   void pushInvokeStatic(
       ast.Node location, MethodElement element, List<HInstruction> arguments,
       {TypeMask typeMask,
       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);
     }
-    bool targetCanThrow = !compiler.closedWorld.getCannotThrow(element);
+    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,
           targetCanThrow: targetCanThrow)
         ..sourceInformation = sourceInformation;
       if (currentInlinedInstantiations.isNotEmpty) {
         instruction.instantiatedTypes =
             new List<DartType>.from(currentInlinedInstantiations);
       }
-      instruction.sideEffects =
-          compiler.closedWorld.getSideEffectsOfElement(element);
+      instruction.sideEffects = closedWorld.getSideEffectsOfElement(element);
     }
     if (location == null) {
       push(instruction);
     } else {
       pushWithPosition(instruction, location);
     }
   }
 
   HInstruction buildInvokeSuper(
       Selector selector, MemberElement element, List<HInstruction> arguments,
@@ skipping 13 matching lines @@
     TypeMask type;
     if (!element.isGetter && selector.isGetter) {
       type = TypeMaskFactory.inferredTypeForElement(element, compiler);
     } else {
       type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
     HInstruction instruction = new HInvokeSuper(element, currentNonClosureClass,
         selector, inputs, type, sourceInformation,
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects =
-        compiler.closedWorld.getSideEffectsOfSelector(selector, null);
+        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);
     } else {
       visit(arguments.head);
@@ skipping 983 matching lines @@
   visitYield(ast.Yield node) {
     visit(node.expression);
     HInstruction yielded = pop();
     add(new HYield(yielded, node.hasStar));
   }
 
   visitAwait(ast.Await node) {
     visit(node.expression);
     HInstruction awaited = pop();
     // TODO(herhut): Improve this type.
-    push(new HAwait(awaited,
-        new TypeMask.subclass(coreClasses.objectClass, compiler.closedWorld)));
+    push(new HAwait(
+        awaited, new TypeMask.subclass(coreClasses.objectClass, closedWorld)));
   }
 
   visitTypeAnnotation(ast.TypeAnnotation node) {
     reporter.internalError(node, 'Visiting type annotation in SSA builder.');
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isReachable);
     for (Link<ast.Node> link = node.definitions.nodes;
         !link.isEmpty;
@@ skipping 38 matching lines @@
           link = link.tail) {
         visit(link.head);
         inputs.add(pop());
       }
       instruction = buildLiteralList(inputs);
       add(instruction);
       instruction = setRtiIfNeeded(instruction, node);
     }
 
     TypeMask type = _inferredTypeOfNewList(node);
-    if (!type.containsAll(compiler.closedWorld)) {
+    if (!type.containsAll(closedWorld)) {
       instruction.instructionType = type;
     }
     stack.add(instruction);
   }
 
   _inferredTypeOfNewList(ast.Node node) =>
-      _resultOf(sourceElement).typeOfNewList(node) ??
-      compiler.closedWorld.commonMasks.dynamicType;
+      _resultOf(sourceElement).typeOfNewList(node) ?? commonMasks.dynamicType;
 
   visitConditional(ast.Conditional node) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
     brancher.handleConditional(() => visit(node.condition),
         () => visit(node.thenExpression), () => visit(node.elseExpression));
   }
 
   visitStringInterpolation(ast.StringInterpolation node) {
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
@@ skipping 78 matching lines @@
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
       Selector selector = Selectors.moveNext;
       TypeMask mask = elementInferenceResults.typeOfIteratorMoveNext(node);
       pushInvokeDynamic(node, selector, mask, [streamIterator]);
       HInstruction future = pop();
       push(new HAwait(
-          future,
-          new TypeMask.subclass(
-              coreClasses.objectClass, compiler.closedWorld)));
+          future, new TypeMask.subclass(coreClasses.objectClass, closedWorld)));
       return popBoolified();
     }
 
     void buildBody() {
       Selector call = Selectors.current;
       TypeMask callMask = elementInferenceResults.typeOfIteratorCurrent(node);
       pushInvokeDynamic(node, call, callMask, [streamIterator]);
 
       ast.Node identifier = node.declaredIdentifier;
       Element variable = elements.getForInVariable(node);
@@ skipping 15 matching lines @@
     }
 
     void buildUpdate() {}
 
     buildProtectedByFinally(() {
       loopHandler.handleLoop(
           node, buildInitializer, buildCondition, buildUpdate, buildBody);
     }, () {
       pushInvokeDynamic(node, Selectors.cancel, null, [streamIterator]);
       push(new HAwait(
-          pop(),
-          new TypeMask.subclass(
-              coreClasses.objectClass, compiler.closedWorld)));
+          pop(), new TypeMask.subclass(coreClasses.objectClass, closedWorld)));
       pop();
     });
   }
 
   visitSyncForIn(ast.SyncForIn node) {
     // The 'get iterator' selector for this node has the inferred receiver type.
     // If the receiver supports JavaScript indexing we generate an indexing loop
     // instead of allocating an iterator object.
 
     // This scheme recognizes for-in on direct lists.  It does not recognize all
     // uses of ArrayIterator.  They still occur when the receiver is an Iterable
     // with a `get iterator` method that delegates to another Iterable and the
     // method is inlined.  We would require full scalar replacement in that
     // case.
 
     TypeMask mask = elementInferenceResults.typeOfIterator(node);
 
-    ClosedWorld closedWorld = compiler.closedWorld;
     if (mask != null &&
         mask.satisfies(helpers.jsIndexableClass, closedWorld) &&
         // String is indexable but not iterable.
         !mask.satisfies(helpers.jsStringClass, closedWorld)) {
       return buildSyncForInIndexable(node, mask);
     }
     buildSyncForInIterator(node);
   }
 
   buildSyncForInIterator(ast.SyncForIn node) {
@@ skipping 58 matching lines @@
     //
     //     int end = a.length;
     //     for (int i = 0;
     //          i < a.length;
     //          checkConcurrentModificationError(a.length == end, a), ++i) {
     //       <declaredIdentifier> = a[i];
     //       <body>
     //     }
     Element loopVariable = elements.getForInVariable(node);
     SyntheticLocal indexVariable = new SyntheticLocal('_i', loopVariable);
-    TypeMask boolType = backend.boolType;
+    TypeMask boolType = commonMasks.boolType;
 
     // These variables are shared by initializer, condition, body and update.
     HInstruction array; // Set in buildInitializer.
     bool isFixed; // Set in buildInitializer.
     HInstruction originalLength = null; // Set for growable lists.
 
     HInstruction buildGetLength() {
       MemberElement lengthElement = helpers.jsIndexableLength;
       HFieldGet result = new HFieldGet(
-          lengthElement, array, backend.positiveIntType,
+          lengthElement, array, commonMasks.positiveIntType,
           isAssignable: !isFixed);
       add(result);
       return result;
     }
 
     void buildConcurrentModificationErrorCheck() {
       if (originalLength == null) return;
       // The static call checkConcurrentModificationError() is expanded in
       // codegen to:
       //
@@ skipping 50 matching lines @@
       // 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 addInstruction =
-          new HAdd(index, one, null, backend.positiveIntType);
+          new HAdd(index, one, null, commonMasks.positiveIntType);
       add(addInstruction);
       localsHandler.updateLocal(indexVariable, addInstruction);
     }
 
     loopHandler.handleLoop(
         node, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   visitLabel(ast.Label node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitLabel.');
@@ skipping 100 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, compiler.closedWorld);
+    TypeMask mapType =
+        new TypeMask.nonNullSubtype(helpers.mapLiteralClass, closedWorld);
     TypeMask returnTypeMask =
         TypeMaskFactory.inferredReturnTypeForElement(constructor, compiler);
     TypeMask instructionType =
-        mapType.intersection(returnTypeMask, compiler.closedWorld);
+        mapType.intersection(returnTypeMask, closedWorld);
 
     addInlinedInstantiation(expectedType);
     pushInvokeStatic(node, constructor, inputs,
         typeMask: instructionType, instanceType: expectedType);
     removeInlinedInstantiation(expectedType);
   }
 
   visitLiteralMapEntry(ast.LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
@@ skipping 215 matching lines @@
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
       // a test of the target.
       void buildCondition() {
         js.Template code = js.js.parseForeignJS('#');
         push(new HForeignCode(
-            code, backend.boolType, [localsHandler.readLocal(switchTarget)],
+            code, commonMasks.boolType, [localsHandler.readLocal(switchTarget)],
             nativeBehavior: native.NativeBehavior.PURE));
       }
 
       handleIf(
           node: node,
           visitCondition: buildCondition,
           visitThen: buildLoop,
           visitElse: () => {});
     }
   }
@@ skipping 261 matching lines @@
     SubGraph catchGraph = null;
     HLocalValue exception = null;
 
     if (!node.catchBlocks.isEmpty) {
       localsHandler = new LocalsHandler.from(savedLocals);
       startCatchBlock = graph.addNewBlock();
       open(startCatchBlock);
       // Note that the name of this local is irrelevant.
       SyntheticLocal local =
           new SyntheticLocal('exception', localsHandler.executableContext);
-      exception = new HLocalValue(local, backend.nonNullType);
+      exception = new HLocalValue(local, commonMasks.nonNullType);
       add(exception);
       HInstruction oldRethrowableException = rethrowableException;
       rethrowableException = exception;
 
       pushInvokeStatic(node, helpers.exceptionUnwrapper, [exception]);
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<ast.Node> link = node.catchBlocks.nodes;
 
       void pushCondition(ast.CatchBlock catchBlock) {
@@ skipping 289 matching lines @@
   void visitExpression(ast.Node node) {
     node.accept(builder);
     HInstruction expression = builder.pop();
 
     // We want to use HStringify when:
     //   1. The value is known to be a primitive type, because it might get
     //      constant-folded and codegen has some tricks with JavaScript
     //      conversions.
     //   2. The value can be primitive, because the library stringifier has
     //      fast-path code for most primitives.
-    if (expression.canBePrimitive(compiler)) {
+    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);
-    if (type.containsOnlyString(compiler.closedWorld)) {
+    if (type.containsOnlyString(builder.closedWorld)) {
       builder.pushInvokeDynamic(node, selector, expression.instructionType,
           <HInstruction>[expression]);
       append(builder.pop());
       return;
     }
 
     append(stringify(node, expression));
   }
 
   void visitStringInterpolation(ast.StringInterpolation node) {
@@ skipping 12 matching lines @@
   void visitNodeList(ast.NodeList node) {
     node.visitChildren(this);
   }
 
   void append(HInstruction expression) {
     result = (result == null) ? expression : concat(result, expression);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
     HInstruction instruction =
-        new HStringConcat(left, right, builder.backend.stringType);
+        new HStringConcat(left, right, builder.commonMasks.stringType);
     builder.add(instruction);
     return instruction;
   }
 
   HInstruction stringify(ast.Node node, HInstruction expression) {
     HInstruction instruction =
-        new HStringify(expression, builder.backend.stringType);
+        new HStringify(expression, builder.commonMasks.stringType);
     builder.add(instruction);
     return instruction;
   }
 }
 
 /**
  * This class visits the method that is a candidate for inlining and
  * finds whether it is too difficult to inline.
  */
 // TODO(karlklose): refactor to make it possible to distinguish between
@@ skipping 149 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }