Remove most direct uses of 'backend' and 'compiler' in GraphBuilder.

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

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 132 matching lines @@
     this.compiler = compiler;
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
     this.sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(
-        this, targetElement, null, backend.nativeData, backend.interceptorData);
+        this, targetElement, null, nativeData, interceptorData);
     this.astAdapter = new KernelAstAdapter(kernel, compiler.backend,
         resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
     target = astAdapter.getInitialKernelNode(targetElement);
     if (targetElement is ConstructorBodyElement) {
       _targetIsConstructorBody = true;
     }
   }
 
   HGraph build() {
     // TODO(het): no reason to do this here...
@@ skipping 49 matching lines @@
       return typeBuilder.potentiallyCheckOrTrustType(value, type,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, commonMasks.boolType);
     add(result);
     return result;
   }
 
   void _addClassTypeVariablesIfNeeded(ir.Member constructor) {
     var enclosing = constructor.enclosingClass;
-    if (backend.rtiNeed.classNeedsRti(astAdapter.getElement(enclosing))) {
+    if (rtiNeed.classNeedsRti(astAdapter.getElement(enclosing))) {
       enclosing.typeParameters.forEach((ir.TypeParameter typeParameter) {
         var typeParamElement = astAdapter.getElement(typeParameter);
         HParameterValue param =
             addParameter(typeParamElement, commonMasks.nonNullType);
         // This is a little bit wacky (and n^2) until we make the localsHandler
         // take Kernel DartTypes instead of just the AST DartTypes.
         var typeVariableType = astAdapter
             .getClass(enclosing)
             .typeVariables
             .firstWhere(
@@ skipping 164 matching lines @@
     signature.forEachRequiredParameter((_) {
       arguments.positional[positionalIndex++].accept(this);
       builtArguments.add(pop());
     });
     if (!signature.optionalParametersAreNamed) {
       signature.forEachOptionalParameter((ParameterElement element) {
         if (positionalIndex < arguments.positional.length) {
           arguments.positional[positionalIndex++].accept(this);
           builtArguments.add(pop());
         } else {
-          var constantValue =
-              backend.constants.getConstantValue(element.constant);
+          var constantValue = constants.getConstantValue(element.constant);
           assert(invariant(element, constantValue != null,
               message: 'No constant computed for $element'));
           builtArguments.add(graph.addConstant(constantValue, closedWorld));
         }
       });
     } else {
       signature.orderedOptionalParameters.forEach((ParameterElement element) {
         var correspondingNamed = arguments.named.firstWhere(
             (named) => named.name == element.name,
             orElse: () => null);
         if (correspondingNamed != null) {
           correspondingNamed.value.accept(this);
           builtArguments.add(pop());
         } else {
-          var constantValue =
-              backend.constants.getConstantValue(element.constant);
+          var constantValue = constants.getConstantValue(element.constant);
           assert(invariant(element, constantValue != null,
               message: 'No constant computed for $element'));
           builtArguments.add(graph.addConstant(constantValue, closedWorld));
         }
       });
     }
 
     return builtArguments;
   }
 
@@ skipping 142 matching lines @@
         new DartString.literal(prefixElement.deferredImport.uri.toString()),
         closedWorld);
     _pushStaticInvocation(astAdapter.checkDeferredIsLoaded,
         [prefixConstant, uriConstant], astAdapter.checkDeferredIsLoadedType);
   }
 
   @override
   void visitLoadLibrary(ir.LoadLibrary loadLibrary) {
     // TODO(efortuna): Source information!
     push(new HInvokeStatic(
-        backend.helpers.loadLibraryWrapper,
+        helpers.loadLibraryWrapper,
         [
           graph.addConstantString(
               new DartString.literal(loadLibrary.import.name), closedWorld)
         ],
         commonMasks.nonNullType,
         targetCanThrow: false));
   }
 
   @override
   void visitBlock(ir.Block block) {
@@ skipping 854 matching lines @@
 
     HInstruction buildCondition() => graph.addConstantBool(true, closedWorld);
 
     void buildSwitch() {
       HInstruction buildExpression(ir.SwitchStatement notUsed) {
         return localsHandler.readLocal(switchTarget);
       }
 
       List<ConstantValue> getConstants(
           ir.SwitchStatement parentSwitch, ir.SwitchCase switchCase) {
-        return <ConstantValue>[
-          backend.constantSystem.createInt(caseIndex[switchCase])
-        ];
+        return <ConstantValue>[constantSystem.createInt(caseIndex[switchCase])];
       }
 
       void buildSwitchCase(ir.SwitchCase switchCase) {
         switchCase.body.accept(this);
         if (!isAborted()) {
           // Ensure that we break the loop if the case falls through. (This
           // is only possible for the last case.)
           jumpTargets[switchTarget].generateBreak();
         }
       }
@@ skipping 194 matching lines @@
   @override
   void visitNullLiteral(ir.NullLiteral nullLiteral) {
     stack.add(graph.addConstantNull(closedWorld));
   }
 
   /// Set the runtime type information if necessary.
   HInstruction setListRuntimeTypeInfoIfNeeded(
       HInstruction object, ir.ListLiteral listLiteral) {
     ResolutionInterfaceType type = localsHandler
         .substInContext(astAdapter.getDartTypeOfListLiteral(listLiteral));
-    if (!backend.rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
+    if (!rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
     for (ResolutionDartType argument in type.typeArguments) {
       arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
   }
@@ skipping 54 matching lines @@
       inputs.add(argList);
     }
 
     assert(constructor.kind == ir.ProcedureKind.Factory);
 
     ResolutionInterfaceType type = localsHandler
         .substInContext(astAdapter.getDartTypeOfMapLiteral(mapLiteral));
 
     ir.Class cls = constructor.enclosingClass;
 
-    if (backend.rtiNeed.classNeedsRti(astAdapter.getClass(cls))) {
+    if (rtiNeed.classNeedsRti(astAdapter.getClass(cls))) {
       List<HInstruction> typeInputs = <HInstruction>[];
       type.typeArguments.forEach((ResolutionDartType argument) {
         typeInputs
             .add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
 
       // We lift this common call pattern into a helper function to save space
       // in the output.
       if (typeInputs.every((HInstruction input) => input.isNull())) {
         if (constructorArgs.isEmpty) {
@@ skipping 424 matching lines @@
     return stringConstant.primitiveValue.slowToString();
   }
 
   void handleForeignJsCurrentIsolateContext(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 0, 0)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
-    if (!backend.backendUsage.isIsolateInUse) {
+    if (!backendUsage.isIsolateInUse) {
       // If the isolate library is not used, we just generate code
       // to fetch the static state.
-      String name = backend.namer.staticStateHolder;
+      String name = namer.staticStateHolder;
       push(new HForeignCode(
           js.js.parseForeignJS(name), commonMasks.dynamicType, <HInstruction>[],
           nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
     } else {
       // Call a helper method from the isolate library. The isolate library uses
       // its own isolate structure that encapsulates the isolate structure used
       // for binding to methods.
       ir.Procedure target = astAdapter.currentIsolate;
       if (target == null) {
         reporter.internalError(astAdapter.getNode(invocation),
             'Isolate library and compiler mismatch.');
       }
       _pushStaticInvocation(target, <HInstruction>[], commonMasks.dynamicType);
     }
   }
 
   void handleForeignJsCallInIsolate(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2, 2)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     List<HInstruction> inputs = _visitPositionalArguments(invocation.arguments);
 
-    if (!backend.backendUsage.isIsolateInUse) {
+    if (!backendUsage.isIsolateInUse) {
       // If the isolate library is not used, we ignore the isolate argument and
       // just invoke the closure.
       push(new HInvokeClosure(new Selector.callClosure(0),
           <HInstruction>[inputs[1]], commonMasks.dynamicType));
     } else {
       // Call a helper method from the isolate library.
       ir.Procedure callInIsolate = astAdapter.callInIsolate;
       if (callInIsolate == null) {
         reporter.internalError(astAdapter.getNode(invocation),
             'Isolate library and compiler mismatch.');
@@ skipping 22 matching lines @@
     if (closure is ir.StaticGet) {
       ir.Member staticTarget = closure.target;
       if (staticTarget is ir.Procedure) {
         if (staticTarget.kind == ir.ProcedureKind.Method) {
           ir.FunctionNode function = staticTarget.function;
           if (function != null &&
               function.requiredParameterCount ==
                   function.positionalParameters.length &&
               function.namedParameters.isEmpty) {
             push(new HForeignCode(
-                js.js.expressionTemplateYielding(backend.emitter
+                js.js.expressionTemplateYielding(emitter
                     .staticFunctionAccess(astAdapter.getMethod(staticTarget))),
                 commonMasks.dynamicType,
                 <HInstruction>[],
                 nativeBehavior: native.NativeBehavior.PURE,
                 foreignFunction: astAdapter.getMethod(staticTarget)));
             return;
           }
           problem = 'does not handle a closure with optional parameters';
         }
       }
     }
 
     reporter.reportErrorMessage(astAdapter.getNode(invocation),
         MessageKind.GENERIC, {'text': "'$name' $problem."});
     stack.add(graph.addConstantNull(closedWorld)); // Result expected on stack.
     return;
   }
 
   void handleForeignJsSetStaticState(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     List<HInstruction> inputs = _visitPositionalArguments(invocation.arguments);
 
-    String isolateName = backend.namer.staticStateHolder;
+    String isolateName = namer.staticStateHolder;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
     push(new HForeignCode(js.js.parseForeignJS("$isolateName = #"),
         commonMasks.dynamicType, inputs,
         nativeBehavior: native.NativeBehavior.CHANGES_OTHER,
         effects: sideEffects));
   }
 
   void handleForeignJsGetStaticState(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 0, 0)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
-    push(new HForeignCode(js.js.parseForeignJS(backend.namer.staticStateHolder),
+    push(new HForeignCode(js.js.parseForeignJS(namer.staticStateHolder),
         commonMasks.dynamicType, <HInstruction>[],
         nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
   }
 
   void handleForeignJsGetName(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
@@ skipping 19 matching lines @@
 
   void handleForeignJsEmbeddedGlobal(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2, 2)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
     String globalName = _foreignConstantStringArgument(
         invocation, 1, 'JS_EMBEDDED_GLOBAL', 'second ');
     js.Template expr = js.js.expressionTemplateYielding(
-        backend.emitter.generateEmbeddedGlobalAccess(globalName));
+        emitter.generateEmbeddedGlobalAccess(globalName));
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehavior(invocation);
     assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
     TypeMask ssaType =
         astAdapter.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const <HInstruction>[],
         nativeBehavior: nativeBehavior));
@@ skipping 47 matching lines @@
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
       stack.add(
           // Result expected on stack.
           graph.addConstantBool(false, closedWorld));
       return;
     }
     String name = _foreignConstantStringArgument(invocation, 0, 'JS_GET_FLAG');
     bool value = false;
     switch (name) {
       case 'MUST_RETAIN_METADATA':
-        value = backend.mirrorsData.mustRetainMetadata;
+        value = mirrorsData.mustRetainMetadata;
         break;
       case 'USE_CONTENT_SECURITY_POLICY':
         value = options.useContentSecurityPolicy;
         break;
       default:
         reporter.reportErrorMessage(
             astAdapter.getNode(invocation),
             MessageKind.GENERIC,
             {'text': 'Error: Unknown internal flag "$name".'});
     }
@@ skipping 246 matching lines @@
     assert(noSuchMethod != null);
     return noSuchMethod;
   }
 
   void _generateSuperNoSuchMethod(ir.Expression invocation, String publicName,
       List<HInstruction> arguments) {
     Selector selector = astAdapter.getSelector(invocation);
     ir.Class cls = _containingClass(invocation).superclass;
     assert(cls != null);
     ir.Procedure noSuchMethod = _findNoSuchMethodInClass(cls);
-    if (backend.backendUsage.isInvokeOnUsed &&
+    if (backendUsage.isInvokeOnUsed &&
         _containingClass(noSuchMethod) != astAdapter.objectClass) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object] (it might be
       // overridden in the super class, but it might have a different number of
       // arguments), in case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       // TODO(johnniwinther): Register this more precisely.
       registry?.registerDynamicUse(new DynamicUse(selector, null));
     }
 
     ConstantValue nameConstant =
-        backend.constantSystem.createString(new DartString.literal(publicName));
+        constantSystem.createString(new DartString.literal(publicName));
 
-    js.Name internalName = backend.namer.invocationName(selector);
+    js.Name internalName = namer.invocationName(selector);
 
     var argumentsInstruction =
         new HLiteralList(arguments, commonMasks.extendableArrayType);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
-      ConstantValue argumentNameConstant = backend.constantSystem
-          .createString(new DartString.literal(argumentName));
+      ConstantValue argumentNameConstant =
+          constantSystem.createString(new DartString.literal(argumentName));
       argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
     }
     var argumentNamesInstruction =
         new HLiteralList(argumentNames, commonMasks.extendableArrayType);
     add(argumentNamesInstruction);
 
     ConstantValue kindConstant =
-        backend.constantSystem.createInt(selector.invocationMirrorKind);
+        constantSystem.createInt(selector.invocationMirrorKind);
 
     _pushStaticInvocation(
         astAdapter.createInvocationMirror,
         [
           graph.addConstant(nameConstant, closedWorld),
           graph.addConstantStringFromName(internalName, closedWorld),
           graph.addConstant(kindConstant, closedWorld),
           argumentsInstruction,
           argumentNamesInstruction
         ],
@@ skipping 117 matching lines @@
       push(
           new HIs.variable(typeValue, expression, pop(), commonMasks.boolType));
       return;
     }
 
     if (_isInterfaceWithNoDynamicTypes(type)) {
       HInstruction representations = typeBuilder
           .buildTypeArgumentRepresentations(typeValue, sourceElement);
       add(representations);
       ClassElement element = typeValue.element;
-      js.Name operator = backend.namer.operatorIs(element);
+      js.Name operator = namer.operatorIs(element);
       HInstruction isFieldName =
           graph.addConstantStringFromName(operator, closedWorld);
       HInstruction asFieldName = closedWorld.hasAnyStrictSubtype(element)
           ? graph.addConstantStringFromName(
-              backend.namer.substitutionName(element), closedWorld)
+              namer.substitutionName(element), closedWorld)
           : graph.addConstantNull(closedWorld);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
       _pushStaticInvocation(
           astAdapter.checkSubtype, inputs, commonMasks.boolType);
       push(
@@ skipping 351 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }