Less 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' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
-import '../common_elements.dart' show CommonElements;
 import '../elements/resolution_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;
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
@@ skipping 191 matching lines @@
         sourceInformationBuilder.buildVariableDeclaration();
     localsHandler = new LocalsHandler(this, target, null, compiler);
     loopHandler = new SsaLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
   }
 
   BackendHelpers get helpers => backend.helpers;
 
   RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
 
-  DiagnosticReporter get reporter => compiler.reporter;
-
-  CommonElements get commonElements => closedWorld.commonElements;
-
   Element get targetElement => target;
 
   /// Reference to resolved elements in [target]'s AST.
   TreeElements get elements => resolvedAst.elements;
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   @override
   void visitNode(ast.Node node) {
@@ skipping 34 matching lines @@
     if (target.isGenerativeConstructor) {
       result = buildFactory(resolvedAst);
     } else if (target.isGenerativeConstructorBody ||
         target.isFactoryConstructor ||
         target.isFunction ||
         target.isGetter ||
         target.isSetter) {
       result = buildMethod(target);
     } else if (target.isField) {
       if (target.isInstanceMember) {
-        assert(compiler.options.enableTypeAssertions);
+        assert(options.enableTypeAssertions);
         result = buildCheckedSetter(target);
       } else {
         result = buildLazyInitializer(target);
       }
     } else {
       reporter.internalError(target, 'Unexpected element kind $target.');
     }
     assert(result.isValid());
     return result;
   }
@@ skipping 121 matching lines @@
     ResolvedAst functionResolvedAst = function.resolvedAst;
     bool insideLoop = loopDepth > 0 || graph.calledInLoop;
 
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
         backend.inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
-      if (compiler.options.disableInlining) return false;
+      if (options.disableInlining) return false;
 
       assert(invariant(
           currentNode != null ? currentNode : function,
           selector != null ||
               Elements.isStaticOrTopLevel(function) ||
               function.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $function."));
       if (selector != null) {
         if (!selector.applies(function)) return false;
         if (mask != null && !mask.canHit(function, selector, closedWorld)) {
@@ skipping 26 matching lines @@
           return false;
         }
       }
 
       return true;
     }
 
     bool doesNotContainCode() {
       // A function with size 1 does not contain any code.
       return InlineWeeder.canBeInlined(functionResolvedAst, 1,
-          enableUserAssertions: compiler.options.enableUserAssertions);
+          enableUserAssertions: options.enableUserAssertions);
     }
 
     bool reductiveHeuristic() {
       // The call is on a path which is executed rarely, so inline only if it
       // does not make the program larger.
       if (isCalledOnce(function)) {
         return InlineWeeder.canBeInlined(functionResolvedAst, null,
-            enableUserAssertions: compiler.options.enableUserAssertions);
+            enableUserAssertions: options.enableUserAssertions);
       }
       // TODO(sra): Measure if inlining would 'reduce' the size.  One desirable
       // case we miss by doing nothing is inlining very simple constructors
       // where all fields are initialized with values from the arguments at this
       // call site.  The code is slightly larger (`new Foo(1)` vs `Foo$(1)`) but
       // that usually means the factory constructor is left unused and not
       // emitted.
       // We at least inline bodies that are empty (and thus have a size of 1).
       return doesNotContainCode();
     }
@@ skipping 18 matching lines @@
       // Do not inline code that is rarely executed unless it reduces size.
       if (inExpressionOfThrow || inLazyInitializerExpression) {
         return reductiveHeuristic();
       }
 
       if (cachedCanBeInlined == true) {
         // We may have forced the inlining of some methods. Therefore check
         // if we can inline this method regardless of size.
         assert(InlineWeeder.canBeInlined(functionResolvedAst, null,
             allowLoops: true,
-            enableUserAssertions: compiler.options.enableUserAssertions));
+            enableUserAssertions: options.enableUserAssertions));
         return true;
       }
 
       int numParameters = function.functionSignature.parameterCount;
       int maxInliningNodes;
       if (insideLoop) {
         maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP +
             InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters;
       } else {
         maxInliningNodes = InlineWeeder.INLINING_NODES_OUTSIDE_LOOP +
             InlineWeeder.INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR * numParameters;
       }
 
       // If a method is called only once, and all the methods in the
       // inlining stack are called only once as well, we know we will
       // save on output size by inlining this method.
       if (isCalledOnce(function)) {
         maxInliningNodes = null;
       }
       bool canInline = InlineWeeder.canBeInlined(
           functionResolvedAst, maxInliningNodes,
-          enableUserAssertions: compiler.options.enableUserAssertions);
+          enableUserAssertions: options.enableUserAssertions);
       if (canInline) {
         backend.inlineCache.markAsInlinable(function, insideLoop: insideLoop);
       } else {
         backend.inlineCache
             .markAsNonInlinable(function, insideLoop: insideLoop);
       }
       return canInline;
     }
 
     void doInlining() {
@@ skipping 944 matching lines @@
     push(attachPosition(instruction, node));
   }
 
   /// Pops the most recent instruction from the stack and 'boolifies' it.
   ///
   /// Boolification is checking if the value is '=== true'.
   @override
   HInstruction popBoolified() {
     HInstruction value = pop();
     if (typeBuilder.checkOrTrustTypes) {
-      ResolutionInterfaceType boolType = compiler.commonElements.boolType;
+      ResolutionInterfaceType boolType = commonElements.boolType;
       return typeBuilder.potentiallyCheckOrTrustType(value, boolType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     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;
   }
 
   void visit(ast.Node node) {
     if (node != null) node.accept(this);
   }
 
   /// Visit [node] and pop the resulting [HInstruction].
   HInstruction visitAndPop(ast.Node node) {
     node.accept(this);
     return pop();
   }
 
   visitAssert(ast.Assert node) {
-    if (!compiler.options.enableUserAssertions) return;
+    if (!options.enableUserAssertions) return;
 
     if (!node.hasMessage) {
       // Generate:
       //
       //     assertHelper(condition);
       //
       visit(node.condition);
       pushInvokeStatic(node, helpers.assertHelper, [pop()]);
       pop();
       return;
@@ skipping 299 matching lines @@
           node, "SsaFromAstMixin.visitIdentifier on non-this.");
     }
   }
 
   void handleIf(
       {ast.Node node,
       void visitCondition(),
       void visitThen(),
       void visitElse(),
       SourceInformation sourceInformation}) {
-    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler, node);
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
     branchBuilder.handleIf(visitCondition, visitThen, visitElse,
         sourceInformation: sourceInformation);
   }
 
   visitIf(ast.If node) {
     assert(isReachable);
     handleIf(
         node: node,
         visitCondition: () => visit(node.condition),
         visitThen: () => visit(node.thenPart),
         visitElse: node.elsePart != null ? () => visit(node.elsePart) : null,
         sourceInformation: sourceInformationBuilder.buildIf(node));
   }
 
   @override
   void visitIfNull(ast.Send node, ast.Node left, ast.Node right, _) {
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleIfNull(() => visit(left), () => visit(right));
   }
 
   /// Optimizes logical binary where the left is also a logical binary.
   ///
   /// This method transforms the operator by optimizing the case where [left] is
   /// a logical "and" or logical "or". Then it uses [branchBuilder] to build the
   /// graph for the optimized expression.
   ///
   /// For example, `(x && y) && z` is transformed into `x && (y && z)`:
@@ skipping 24 matching lines @@
           branchBuilder,
           isAnd: isAnd);
     } else {
       branchBuilder.handleLogicalBinary(() => visit(left), visitRight,
           isAnd: isAnd);
     }
   }
 
   @override
   void visitLogicalAnd(ast.Send node, ast.Node left, ast.Node right, _) {
-    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler, node);
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
     handleLogicalBinaryWithLeftNode(left, () => visit(right), branchBuilder,
         isAnd: true);
   }
 
   @override
   void visitLogicalOr(ast.Send node, ast.Node left, ast.Node right, _) {
-    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler, node);
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
     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);
@@ skipping 248 matching lines @@
   @override
   void visitIfNotNullDynamicPropertyGet(
       ast.Send node, ast.Node receiver, Name name, _) {
     // exp?.x compiled as:
     //   t1 = exp;
     //   result = t1 == null ? t1 : t1.x;
     // This is equivalent to t1 == null ? null : t1.x, but in the current form
     // we will be able to later compress it as:
     //   t1 || t1.x
     HInstruction expression;
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(
         () {
           expression = visitAndPop(receiver);
           pushCheckNull(expression);
         },
         () => stack.add(expression),
         () {
           generateInstanceGetterWithCompiledReceiver(
               node,
               elements.getSelector(node),
@@ skipping 338 matching lines @@
   visitDynamicPropertyInvoke(ast.Send node, ast.Node receiver,
       ast.NodeList arguments, Selector selector, _) {
     generateDynamicSend(node);
   }
 
   @override
   visitIfNotNullDynamicPropertyInvoke(ast.Send node, ast.Node receiver,
       ast.NodeList arguments, Selector selector, _) {
     /// Desugar `exp?.m()` to `(t1 = exp) == null ? t1 : t1.m()`
     HInstruction receiver;
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(() {
       receiver = generateInstanceSendReceiver(node);
       pushCheckNull(receiver);
     }, () => stack.add(receiver), () => _generateDynamicSend(node, receiver));
   }
 
   @override
   visitThisPropertyInvoke(
       ast.Send node, ast.NodeList arguments, Selector selector, _) {
     generateDynamicSend(node);
@@ skipping 150 matching lines @@
       reporter.reportErrorMessage(argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a literal string.'});
     }
     String name = string.dartString.slowToString();
     bool value = false;
     switch (name) {
       case 'MUST_RETAIN_METADATA':
         value = backend.mirrorsData.mustRetainMetadata;
         break;
       case 'USE_CONTENT_SECURITY_POLICY':
-        value = compiler.options.useContentSecurityPolicy;
+        value = options.useContentSecurityPolicy;
         break;
       default:
         reporter.reportErrorMessage(node, MessageKind.GENERIC,
             {'text': 'Error: Unknown internal flag "$name".'});
     }
     stack.add(graph.addConstantBool(value, closedWorld));
   }
 
   void handleForeignJsGetName(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
@@ skipping 759 matching lines @@
     expectedType.typeArguments.forEach((ResolutionDartType argument) {
       inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement,
           sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(
       ast.NewExpression node, ResolutionInterfaceType type) {
-    if (!compiler.options.enableTypeAssertions) return false;
+    if (!options.enableTypeAssertions) return false;
 
     Map<ResolutionDartType, Set<ResolutionDartType>> seenChecksMap =
         new Map<ResolutionDartType, Set<ResolutionDartType>>();
     bool definitelyFails = false;
 
     void addTypeVariableBoundCheck(
         GenericType instance,
         ResolutionDartType typeArgument,
         ResolutionTypeVariableType typeVariable,
         ResolutionDartType bound) {
@@ skipping 365 matching lines @@
 
   @override
   void bulkHandleNode(ast.Node node, String message, _) {
     internalError(node, "Unexpected bulk handled node: $node");
   }
 
   @override
   void bulkHandleNew(ast.NewExpression node, [_]) {
     Element element = elements[node.send];
     final bool isSymbolConstructor =
-        element == compiler.commonElements.symbolConstructor;
+        element == commonElements.symbolConstructor;
     if (!Elements.isMalformed(element)) {
       ConstructorElement function = element;
       element = function.effectiveTarget;
     }
     if (Elements.isError(element)) {
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR ||
           error.messageKind == MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR) {
         generateThrowNoSuchMethod(
             node.send, noSuchMethodTargetSymbolString(error, 'constructor'),
@@ skipping 127 matching lines @@
               backend.nativeData.computeUnescapedJSInteropName(parameter.name);
           parameterNameMap[jsName] = new js.InterpolatedExpression(positions++);
         }
         i++;
       });
       var codeTemplate =
           new js.Template(null, js.objectLiteral(parameterNameMap));
 
       var nativeBehavior = new native.NativeBehavior()
         ..codeTemplate = codeTemplate;
-      if (compiler.options.trustJSInteropTypeAnnotations) {
+      if (options.trustJSInteropTypeAnnotations) {
         nativeBehavior.typesReturned.add(constructor.enclosingClass.thisType);
       }
       return new HForeignCode(
           codeTemplate, commonMasks.dynamicType, filteredArguments,
           nativeBehavior: nativeBehavior)
         ..sourceInformation = sourceInformation;
     }
     var target = new HForeignCode(
         js.js.parseForeignJS(
             "${backend.nativeData.getFixedBackendMethodPath(element)}."
@@ skipping 10 matching lines @@
 
     var nativeBehavior = new native.NativeBehavior()
       ..sideEffects.setAllSideEffects();
 
     ResolutionDartType type = element.isConstructor
         ? element.enclosingClass.thisType
         : element.type.returnType;
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
-    nativeBehavior.typesReturned.add(
-        compiler.options.trustJSInteropTypeAnnotations
-            ? type
-            : const ResolutionDynamicType());
+    nativeBehavior.typesReturned.add(options.trustJSInteropTypeAnnotations
+        ? type
+        : const ResolutionDynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
     if (type is ResolutionInterfaceType &&
         backend.nativeData.isNativeClass(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
-    if (!compiler.options.trustJSInteropTypeAnnotations ||
+    if (!options.trustJSInteropTypeAnnotations ||
         type.isObject ||
         type.isDynamic) {
       ClassElement cls = backend.helpers.jsJavaScriptObjectClass;
       nativeBehavior.typesInstantiated.add(cls.thisType);
     }
 
     String code;
     if (element.isGetter) {
       code = "#";
     } else if (element.isSetter) {
@@ skipping 140 matching lines @@
       if (Elements.isUnresolved(getter)) {
         generateSuperNoSuchMethodSend(node, getterSelector, getterInputs);
         getterInstruction = pop();
       } else {
         getterInstruction =
             buildInvokeSuper(getterSelector, getter, getterInputs);
         add(getterInstruction);
       }
 
       if (node.isIfNullAssignment) {
-        SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+        SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
         brancher.handleIfNull(() => stack.add(getterInstruction), () {
           addDynamicSendArgumentsToList(node, setterInputs);
           generateSuperSendSet();
           stack.add(setterInputs.last);
         });
       } else {
         handleComplexOperatorSend(node, getterInstruction, arguments);
         setterInputs.add(pop());
         generateSuperSendSet();
         stack.add(node.isPostfix ? getterInstruction : setterInputs.last);
@@ skipping 299 matching lines @@
 
       pushInvokeDynamic(node, elements.getGetterSelectorInComplexSendSet(node),
           elementInferenceResults.typeOfGetter(node), [receiver, index]);
       HInstruction getterInstruction = pop();
       if (node.isIfNullAssignment) {
         // Compile x[i] ??= e as:
         //   t1 = x[i]
         //   if (t1 == null)
         //      t1 = x[i] = e;
         //   result = t1
-        SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+        SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
         brancher.handleIfNull(() => stack.add(getterInstruction), () {
           visit(arguments.head);
           HInstruction value = pop();
           pushInvokeDynamic(
               node,
               elements.getSelector(node),
               elementInferenceResults.typeOfSend(node),
               [receiver, index, value]);
           pop();
           stack.add(value);
@@ skipping 30 matching lines @@
   void visitIfNotNullDynamicPropertySet(
       ast.SendSet node, ast.Node receiver, Name name, ast.Node rhs, _) {
     // compile e?.x = e2 to:
     //
     // t1 = e
     // if (t1 == null)
     //   result = t1 // same as result = null
     // else
     //   result = e.x = e2
     HInstruction receiverInstruction;
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(
         () {
           receiverInstruction = generateInstanceSendReceiver(node);
           pushCheckNull(receiverInstruction);
         },
         () => stack.add(receiverInstruction),
         () {
           generateInstanceSetterWithCompiledReceiver(
               node, receiverInstruction, visitAndPop(rhs));
         });
@@ skipping 152 matching lines @@
     if (Elements.isInstanceSend(node, elements)) {
       void generateAssignment(HInstruction receiver) {
         // desugars `e.x op= e2` to `e.x = e.x op e2`
         generateInstanceGetterWithCompiledReceiver(
             node,
             elements.getGetterSelectorInComplexSendSet(node),
             elementInferenceResults.typeOfGetter(node),
             receiver);
         HInstruction getterInstruction = pop();
         if (node.isIfNullAssignment) {
-          SsaBranchBuilder brancher =
-              new SsaBranchBuilder(this, compiler, node);
+          SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
           brancher.handleIfNull(() => stack.add(getterInstruction), () {
             visit(node.arguments.head);
             generateInstanceSetterWithCompiledReceiver(node, receiver, pop());
           });
         } else {
           handleComplexOperatorSend(node, getterInstruction, node.arguments);
           HInstruction value = pop();
           generateInstanceSetterWithCompiledReceiver(node, receiver, value);
         }
         if (node.isPostfix) {
           pop();
           stack.add(getterInstruction);
         }
       }
 
       if (node.isConditional) {
         // generate `e?.x op= e2` as:
         //   t1 = e
         //   t1 == null ? t1 : (t1.x = t1.x op e2);
         HInstruction receiver;
-        SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+        SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
         brancher.handleConditional(() {
           receiver = generateInstanceSendReceiver(node);
           pushCheckNull(receiver);
         }, () => stack.add(receiver), () => generateAssignment(receiver));
       } else {
         generateAssignment(generateInstanceSendReceiver(node));
       }
       return;
     }
 
     if (getter.isMalformed) {
       generateStaticUnresolvedGet(node, getter);
     } else if (getter.isField) {
       generateStaticFieldGet(node, getter);
     } else if (getter.isGetter) {
       generateStaticGetterGet(node, getter);
     } else if (getter.isFunction) {
       generateStaticFunctionGet(node, getter);
     } else if (getter.isLocal) {
       handleLocalGet(node, getter);
     } else {
       internalError(node, "Unexpected getter: $getter");
     }
     HInstruction getterInstruction = pop();
     if (node.isIfNullAssignment) {
-      SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+      SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
       brancher.handleIfNull(() => stack.add(getterInstruction), () {
         visit(node.arguments.head);
         generateNonInstanceSetter(node, element, pop());
       });
     } else {
       handleComplexOperatorSend(node, getterInstruction, node.arguments);
       HInstruction value = pop();
       generateNonInstanceSetter(node, element, value);
     }
     if (node.isPostfix) {
@@ skipping 278 matching lines @@
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(closedWorld);
     } else {
       visit(node.expression);
       value = pop();
       if (isBuildingAsyncFunction) {
-        if (compiler.options.enableTypeAssertions &&
+        if (options.enableTypeAssertions &&
             !isValidAsyncReturnType(returnType)) {
           String message = "Async function returned a Future, "
               "was declared to return a $returnType.";
           generateTypeError(node, message);
           pop();
           return;
         }
       } else {
         value = typeBuilder.potentiallyCheckOrTrustType(value, returnType);
       }
@@ skipping 91 matching lines @@
   }
 
   _inferredTypeOfNewList(ast.Send node) =>
       _resultOf(sourceElement).typeOfNewList(node) ?? commonMasks.dynamicType;
 
   _inferredTypeOfListLiteral(ast.LiteralList node) =>
       _resultOf(sourceElement).typeOfListLiteral(node) ??
       commonMasks.dynamicType;
 
   visitConditional(ast.Conditional node) {
-    SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, 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);
     stack.add(stringBuilder.result);
   }
 
   visitStringInterpolationPart(ast.StringInterpolationPart node) {
     // The parts are iterated in visitStringInterpolation.
     reporter.internalError(
         node, 'SsaBuilder.visitStringInterpolation should not be called.');
   }
 
   visitEmptyStatement(ast.EmptyStatement node) {
     // Do nothing, empty statement.
   }
 
   visitModifiers(ast.Modifiers node) {
-    compiler.unimplemented(node, 'SsaFromAstMixin.visitModifiers.');
+    throw new SpannableAssertionFailure(
+        node, 'SsaFromAstMixin.visitModifiers not implemented.');
   }
 
   visitBreakStatement(ast.BreakStatement node) {
     assert(!isAborted());
     handleInTryStatement();
     JumpTarget target = elements.getTargetOf(node);
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     if (node.target == null) {
@@ skipping 1081 matching lines @@
             wrapStatementGraph(catchGraph), wrapStatementGraph(finallyGraph)),
         exitBlock);
     inTryStatement = oldInTryStatement;
   }
 
   visitCatchBlock(ast.CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(ast.Typedef node) {
-    compiler.unimplemented(node, 'SsaFromAstMixin.visitTypedef.');
+    throw new SpannableAssertionFailure(
+        node, 'SsaFromAstMixin.visitTypedef not implemented.');
   }
 
   visitTypeVariable(ast.TypeVariable node) {
-    reporter.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
+    throw new SpannableAssertionFailure(
+        node, 'SsaFromAstMixin.visitTypeVariable not implemented.');
   }
 
   /**
    * This method is invoked before inlining the body of [function] into this
    * [SsaBuilder].
    */
   void enterInlinedMethod(MethodElement function,
       ResolvedAst functionResolvedAst, List<HInstruction> compiledArguments,
       {ResolutionInterfaceType instanceType}) {
     AstInliningState state = new AstInliningState(
@@ skipping 95 matching lines @@
   final SsaBuilder builder;
   final ast.Node diagnosticNode;
 
   /**
    * The string value generated so far.
    */
   HInstruction result = null;
 
   StringBuilderVisitor(this.builder, this.diagnosticNode);
 
-  Compiler get compiler => builder.compiler;
-
   void visit(ast.Node node) {
     node.accept(this);
   }
 
   visitNode(ast.Node node) {
     builder.reporter.internalError(node, 'Unexpected node.');
   }
 
   void visitExpression(ast.Node node) {
     node.accept(builder);
@@ skipping 255 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }