Lesser direct Compiler use in SSA

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';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Identifiers, Selectors;
 import '../common/tasks.dart' show CompilerTask;
+import '../compiler.dart';
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../diagnostics/messages.dart' show Message, MessageTemplate;
 import '../dump_info.dart' show InfoReporter;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart' show ConstructorBodyElementX;
@@ skipping 119 matching lines @@
   // code-analysis too.
   final CodegenRegistry registry;
 
   /// Results from the global type-inference analysis corresponding to the
   /// current element being visited.
   ///
   /// Invariant: this property is updated together with [resolvedAst].
   GlobalTypeInferenceElementResult elementInferenceResults;
 
   final JavaScriptBackend backend;
+
+  Compiler get compiler => backend.compiler;
+
   final ConstantSystem constantSystem;
   final RuntimeTypesSubstitutions rtiSubstitutions;
 
   SourceInformationBuilder sourceInformationBuilder;
 
   bool inLazyInitializerExpression = false;
 
   // TODO(sigmund): make all comments /// instead of /* */
   /* This field is used by the native handler. */
   final NativeEmitter nativeEmitter;
@@ skipping 32 matching lines @@
       this.registry,
       JavaScriptBackend backend,
       this.closedWorld,
       this.nativeEmitter,
       SourceInformationStrategy sourceInformationFactory)
       : this.infoReporter = backend.compiler.dumpInfoTask,
         this.backend = backend,
         this.constantSystem = backend.constantSystem,
         this.rtiSubstitutions = backend.rtiSubstitutions {
     assert(target.isImplementation);
-    compiler = backend.compiler;
     elementInferenceResults = _resultOf(target);
     assert(elementInferenceResults != null);
     graph.element = target;
     sourceElementStack.add(target);
     sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     localsHandler = new LocalsHandler(
         this, target, null, backend.nativeData, backend.interceptorData);
@@ skipping 267 matching lines @@
     bool heuristicSayGoodToGo() {
       // Don't inline recursively
       if (inliningStack.any((entry) => entry.function == function)) {
         return false;
       }
 
       if (function.isSynthesized) return true;
 
       // Don't inline across deferred import to prevent leaking code. The only
       // exception is an empty function (which does not contain code).
-      bool hasOnlyNonDeferredImportPaths = compiler.deferredLoadTask
+      bool hasOnlyNonDeferredImportPaths = deferredLoadTask
           .hasOnlyNonDeferredImportPaths(compiler.currentElement, function);
 
       if (!hasOnlyNonDeferredImportPaths) {
         return doesNotContainCode();
       }
 
       // Do not inline code that is rarely executed unless it reduces size.
       if (inExpressionOfThrow || inLazyInitializerExpression) {
         return reductiveHeuristic();
       }
@@ skipping 700 matching lines @@
     List<HInstruction> constructorArguments = <HInstruction>[];
     List<FieldEntity> fields = <FieldEntity>[];
 
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement member) {
       HInstruction value = fieldValues[member];
       if (value == null) {
         // Uninitialized native fields are pre-initialized by the native
         // implementation.
         assert(invariant(
-            member, isNativeUpgradeFactory || compiler.compilationFailed));
+            member, isNativeUpgradeFactory || reporter.hasReportedError));
       } else {
         fields.add(member);
         ResolutionDartType type = localsHandler.substInContext(member.type);
         constructorArguments
             .add(typeBuilder.potentiallyCheckOrTrustType(value, type));
       }
     }, includeSuperAndInjectedMembers: true);
 
     ResolutionInterfaceType type = classElement.thisType;
     TypeMask ssaType =
@@ skipping 559 matching lines @@
           block.remove(breakInstruction);
         });
       }
     }
     jumpHandler.close();
     loopDepth--;
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     LocalFunctionElement methodElement = elements[node];
-    ClosureClassMap nestedClosureData = compiler.closureToClassMapper
+    ClosureClassMap nestedClosureData = closureToClassMapper
         .getClosureToClassMapping(methodElement.resolvedAst);
     assert(nestedClosureData != null);
     assert(nestedClosureData.closureClassElement != null);
     ClosureClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     MethodElement callElement = nestedClosureData.callElement;
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureClassElement.closureFields.forEach((ClosureFieldElement field) {
       Local capturedLocal =
@@ skipping 211 matching lines @@
     pushInvokeDynamic(send, selector, mask, [receiver],
         sourceInformation: sourceInformationBuilder.buildGet(send));
   }
 
   /// Inserts a call to checkDeferredIsLoaded for [prefixElement].
   /// If [prefixElement] is [null] ndo nothing.
   void generateIsDeferredLoadedCheckIfNeeded(
       PrefixElement prefixElement, ast.Node location) {
     if (prefixElement == null) return;
     String loadId =
-        compiler.deferredLoadTask.getImportDeferName(location, prefixElement);
+        deferredLoadTask.getImportDeferName(location, prefixElement);
     HInstruction loadIdConstant = addConstantString(loadId);
     String uri = prefixElement.deferredImport.uri.toString();
     HInstruction uriConstant = addConstantString(uri);
     MethodElement helper = helpers.checkDeferredIsLoaded;
     pushInvokeStatic(location, helper, [loadIdConstant, uriConstant]);
     pop();
   }
 
   /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that
   /// resolves to a deferred library.
   void generateIsDeferredLoadedCheckOfSend(ast.Send node) {
     generateIsDeferredLoadedCheckIfNeeded(
-        compiler.deferredLoadTask.deferredPrefixElement(node, elements), node);
+        deferredLoadTask.deferredPrefixElement(node, elements), node);
   }
 
   void handleInvalidStaticGet(ast.Send node, Element element) {
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     generateThrowNoSuchMethod(
         node, noSuchMethodTargetSymbolString(element, 'get'),
         argumentNodes: const Link<ast.Node>(),
         sourceInformation: sourceInformation);
   }
@@ skipping 13 matching lines @@
   }
 
   /// Read a static or top level [field] of constant value.
   void generateStaticConstGet(ast.Send node, FieldElement field,
       ConstantExpression constant, SourceInformation sourceInformation) {
     ConstantValue value = 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);
+        deferredLoadTask.deferredPrefixElement(node, elements);
     if (prefix != null) {
       instruction = graph.addDeferredConstant(
           value, prefix, sourceInformation, compiler, closedWorld);
     } else {
       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
@@ skipping 888 matching lines @@
       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);
+    String loadId = deferredLoadTask.getImportDeferName(node, prefixElement);
     var inputs = [
       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) {
@@ skipping 501 matching lines @@
         new Map<ResolutionDartType, Set<ResolutionDartType>>();
     bool definitelyFails = false;
 
     void addTypeVariableBoundCheck(
         GenericType instance,
         ResolutionDartType typeArgument,
         ResolutionTypeVariableType typeVariable,
         ResolutionDartType bound) {
       if (definitelyFails) return;
 
-      int subtypeRelation =
-          compiler.types.computeSubtypeRelation(typeArgument, bound);
+      int subtypeRelation = types.computeSubtypeRelation(typeArgument, bound);
       if (subtypeRelation == Types.IS_SUBTYPE) return;
 
       String message = "Can't create an instance of malbounded type '$type': "
           "'${typeArgument}' is not a subtype of bound '${bound}' for "
           "type variable '${typeVariable}' of type "
           "${type == instance
               ? "'${type.element.thisType}'"
               : "'${instance.element.thisType}' on the supertype "
                 "'${instance}' of '${type}'"
             }.";
       if (subtypeRelation == Types.NOT_SUBTYPE) {
         generateTypeError(node, message);
         definitelyFails = true;
         return;
       } else if (subtypeRelation == Types.MAYBE_SUBTYPE) {
         Set<ResolutionDartType> seenChecks = seenChecksMap.putIfAbsent(
             typeArgument, () => new Set<ResolutionDartType>());
         if (!seenChecks.contains(bound)) {
           seenChecks.add(bound);
           assertIsSubtype(node, typeArgument, bound, message);
         }
       }
     }
 
-    compiler.types.checkTypeVariableBounds(type, addTypeVariableBoundCheck);
+    types.checkTypeVariableBounds(type, addTypeVariableBoundCheck);
     if (definitelyFails) {
       return true;
     }
     for (ResolutionInterfaceType supertype in type.element.allSupertypes) {
       ResolutionDartType instance = type.asInstanceOf(supertype.element);
-      compiler.types
-          .checkTypeVariableBounds(instance, addTypeVariableBoundCheck);
+      types.checkTypeVariableBounds(instance, addTypeVariableBoundCheck);
       if (definitelyFails) {
         return true;
       }
     }
     return false;
   }
 
   visitStaticSend(ast.Send node) {
     internalError(node, "Unexpected visitStaticSend");
   }
@@ skipping 3192 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }