Add KernelToElementMap.getSpannable to avoid most usage of KernelAstAdapter.getNode

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;
 import '../common/names.dart';
@@ skipping 1272 matching lines @@
         visitThen: () => ifStatement.then.accept(this),
         visitElse: () => ifStatement.otherwise?.accept(this));
   }
 
   void handleIf(
       {ir.Node node,
       void visitCondition(),
       void visitThen(),
       void visitElse(),
       SourceInformation sourceInformation}) {
-    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(
-        this, node == null ? node : astAdapter.getNode(node));
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this,
+        node == null ? node : _elementMap.getSpannable(targetElement, node));
     branchBuilder.handleIf(visitCondition, visitThen, visitElse,
         sourceInformation: sourceInformation);
   }
 
   @override
   void visitAsExpression(ir.AsExpression asExpression) {
     asExpression.operand.accept(this);
     HInstruction expressionInstruction = pop();
 
     if (asExpression.type is ir.InvalidType) {
@@ skipping 428 matching lines @@
     // to create the phis in [joinBlock].
     // If we never jump to the join block, [caseHandlers] will stay empty, and
     // the join block is never added to the graph.
     HBasicBlock joinBlock = new HBasicBlock();
     List<LocalsHandler> caseHandlers = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
       caseHandlers.add(locals);
     });
     jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
-      assert(invariant(astAdapter.getNode(switchStatement), false,
+      assert(invariant(
+          _elementMap.getSpannable(targetElement, switchStatement), false,
           message: 'Continue cannot target a switch.'));
     });
     if (!isAborted()) {
       current.close(new HGoto());
       lastOpenedBlock.addSuccessor(joinBlock);
       caseHandlers.add(localsHandler);
     }
     if (!hasDefault) {
       // Always create a default case, to avoid a critical edge in the
       // graph.
@@ skipping 537 matching lines @@
     } else if (name == 'JS_GET_FLAG') {
       handleForeignJsGetFlag(invocation);
     } else if (name == 'JS_EFFECT') {
       stack.add(graph.addConstantNull(closedWorld));
     } else if (name == 'JS_INTERCEPTOR_CONSTANT') {
       handleJsInterceptorConstant(invocation);
     } else if (name == 'JS_STRING_CONCAT') {
       handleJsStringConcat(invocation);
     } else {
       reporter.internalError(
-          astAdapter.getNode(invocation), "Unknown foreign: ${name}");
+          _elementMap.getSpannable(targetElement, invocation),
+          "Unknown foreign: ${name}");
     }
   }
 
   bool _unexpectedForeignArguments(
       ir.StaticInvocation invocation, int minPositional,
       [int maxPositional]) {
     String pluralizeArguments(int count) {
       if (count == 0) return 'no arguments';
       if (count == 1) return 'one argument';
       if (count == 2) return 'two arguments';
       return '$count arguments';
     }
 
     String name() => invocation.target.name.name;
 
     ir.Arguments arguments = invocation.arguments;
     bool bad = false;
     if (arguments.types.isNotEmpty) {
       reporter.reportErrorMessage(
-          astAdapter.getNode(invocation),
+          _elementMap.getSpannable(targetElement, invocation),
           MessageKind.GENERIC,
           {'text': "Error: '${name()}' does not take type arguments."});
       bad = true;
     }
     if (arguments.positional.length < minPositional) {
       String phrase = pluralizeArguments(minPositional);
       if (maxPositional != minPositional) phrase = 'at least $phrase';
       reporter.reportErrorMessage(
-          astAdapter.getNode(invocation),
+          _elementMap.getSpannable(targetElement, invocation),
           MessageKind.GENERIC,
           {'text': "Error: Too few arguments. '${name()}' takes $phrase."});
       bad = true;
     }
     if (maxPositional != null && arguments.positional.length > maxPositional) {
       String phrase = pluralizeArguments(maxPositional);
       if (maxPositional != minPositional) phrase = 'at most $phrase';
       reporter.reportErrorMessage(
-          astAdapter.getNode(invocation),
+          _elementMap.getSpannable(targetElement, invocation),
           MessageKind.GENERIC,
           {'text': "Error: Too many arguments. '${name()}' takes $phrase."});
       bad = true;
     }
     if (arguments.named.isNotEmpty) {
       reporter.reportErrorMessage(
-          astAdapter.getNode(invocation),
+          _elementMap.getSpannable(targetElement, invocation),
           MessageKind.GENERIC,
           {'text': "Error: '${name()}' does not take named arguments."});
       bad = true;
     }
     return bad;
   }
 
   /// Returns the value of the string argument. The argument must evaluate to a
   /// constant.  If there is an error, the error is reported and `null` is
   /// returned.
   String _foreignConstantStringArgument(
       ir.StaticInvocation invocation, int position, String methodName,
       [String adjective = '']) {
     ir.Expression argument = invocation.arguments.positional[position];
     argument.accept(this);
     HInstruction instruction = pop();
 
     if (!instruction.isConstantString()) {
       reporter.reportErrorMessage(
-          astAdapter.getNode(argument), MessageKind.GENERIC, {
+          _elementMap.getSpannable(targetElement, argument),
+          MessageKind.GENERIC, {
         'text': "Error: Expected String constant as ${adjective}argument "
             "to '$methodName'."
       });
       return null;
     }
 
     HConstant hConstant = instruction;
     StringConstantValue stringConstant = hConstant.constant;
     return stringConstant.primitiveValue;
   }
@@ skipping 11 matching lines @@
       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.
       FunctionEntity target = _commonElements.currentIsolate;
       if (target == null) {
-        reporter.internalError(astAdapter.getNode(invocation),
+        reporter.internalError(
+            _elementMap.getSpannable(targetElement, 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 (!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.
       FunctionEntity callInIsolate = _commonElements.callInIsolate;
       if (callInIsolate == null) {
-        reporter.internalError(astAdapter.getNode(invocation),
+        reporter.internalError(
+            _elementMap.getSpannable(targetElement, invocation),
             'Isolate library and compiler mismatch.');
       }
       _pushStaticInvocation(callInIsolate, inputs, commonMasks.dynamicType);
     }
   }
 
   void handleForeignDartClosureToJs(
       ir.StaticInvocation invocation, String name) {
     // TODO(sra): Do we need to wrap the closure in something that saves the
     // current isolate?
@@ skipping 26 matching lines @@
                 <HInstruction>[],
                 nativeBehavior: native.NativeBehavior.PURE,
                 foreignFunction: _elementMap.getMethod(staticTarget)));
             return;
           }
           problem = 'does not handle a closure with optional parameters';
         }
       }
     }
 
-    reporter.reportErrorMessage(astAdapter.getNode(invocation),
-        MessageKind.GENERIC, {'text': "'$name' $problem."});
+    reporter.reportErrorMessage(
+        _elementMap.getSpannable(targetElement, 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;
     }
@@ skipping 33 matching lines @@
     HInstruction instruction = pop();
 
     if (instruction is HConstant) {
       js.Name name =
           astAdapter.getNameForJsGetName(argument, instruction.constant);
       stack.add(graph.addConstantStringFromName(name, closedWorld));
       return;
     }
 
     reporter.reportErrorMessage(
-        astAdapter.getNode(argument),
+        _elementMap.getSpannable(targetElement, argument),
         MessageKind.GENERIC,
         {'text': 'Error: Expected a JsGetName enum value.'});
     // Result expected on stack.
     stack.add(graph.addConstantNull(closedWorld));
   }
 
   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(
         emitter.generateEmbeddedGlobalAccess(globalName));
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehavior(invocation);
-    assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
+    assert(invariant(_elementMap.getSpannable(targetElement, invocation),
+        nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
     TypeMask ssaType =
         _typeInferenceMap.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const <HInstruction>[],
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsBuiltin(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     List<ir.Expression> arguments = invocation.arguments.positional;
     ir.Expression nameArgument = arguments[1];
 
     nameArgument.accept(this);
     HInstruction instruction = pop();
 
     js.Template template;
     if (instruction is HConstant) {
       template = astAdapter.getJsBuiltinTemplate(instruction.constant);
     }
     if (template == null) {
       reporter.reportErrorMessage(
-          astAdapter.getNode(nameArgument),
+          _elementMap.getSpannable(targetElement, nameArgument),
           MessageKind.GENERIC,
           {'text': 'Error: Expected a JsBuiltin enum value.'});
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     for (ir.Expression argument in arguments.skip(2)) {
       argument.accept(this);
       inputs.add(pop());
     }
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehavior(invocation);
-    assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
+    assert(invariant(_elementMap.getSpannable(targetElement, invocation),
+        nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
     TypeMask ssaType =
         _typeInferenceMap.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(template, ssaType, inputs,
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsGetFlag(ir.StaticInvocation invocation) {
     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 = getFlagValue(name);
     if (value == null) {
       reporter.reportErrorMessage(
-          astAdapter.getNode(invocation),
+          _elementMap.getSpannable(targetElement, invocation),
           MessageKind.GENERIC,
           {'text': 'Error: Unknown internal flag "$name".'});
     } else {
       stack.add(graph.addConstantBool(value, closedWorld));
     }
   }
 
   void handleJsInterceptorConstant(ir.StaticInvocation invocation) {
     // Single argument must be a TypeConstant which is converted into a
     // InterceptorConstant.
@@ skipping 11 matching lines @@
           argumentConstant.representedType is ResolutionInterfaceType) {
         ResolutionInterfaceType type = argumentConstant.representedType;
         // TODO(sra): Check that type is a subclass of [Interceptor].
         ConstantValue constant = new InterceptorConstantValue(type.element);
         HInstruction instruction = graph.addConstant(constant, closedWorld);
         stack.add(instruction);
         return;
       }
     }
 
-    reporter.reportErrorMessage(astAdapter.getNode(invocation),
+    reporter.reportErrorMessage(
+        _elementMap.getSpannable(targetElement, invocation),
         MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     stack.add(graph.addConstantNull(closedWorld));
   }
 
   void handleForeignJs(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehaviorForJsCall(invocation);
-    assert(invariant(astAdapter.getNode(invocation), nativeBehavior != null,
+    assert(invariant(_elementMap.getSpannable(targetElement, invocation),
+        nativeBehavior != null,
         message: "No NativeBehavior for $invocation"));
 
     List<HInstruction> inputs = <HInstruction>[];
     for (ir.Expression argument in invocation.arguments.positional.skip(2)) {
       argument.accept(this);
       inputs.add(pop());
     }
 
     if (nativeBehavior.codeTemplate.positionalArgumentCount != inputs.length) {
       reporter.reportErrorMessage(
-          astAdapter.getNode(invocation), MessageKind.GENERIC, {
+          _elementMap.getSpannable(targetElement, invocation),
+          MessageKind.GENERIC, {
         'text': 'Mismatch between number of placeholders'
             ' and number of arguments.'
       });
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     if (native.HasCapturedPlaceholders.check(nativeBehavior.codeTemplate.ast)) {
       reporter.reportErrorMessage(
-          astAdapter.getNode(invocation), MessageKind.JS_PLACEHOLDER_CAPTURE);
+          _elementMap.getSpannable(targetElement, invocation),
+          MessageKind.JS_PLACEHOLDER_CAPTURE);
     }
 
     TypeMask ssaType =
         _typeInferenceMap.typeFromNativeBehavior(nativeBehavior, closedWorld);
 
     SourceInformation sourceInformation = null;
     push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
         isStatement: !nativeBehavior.codeTemplate.isExpression,
         effects: nativeBehavior.sideEffects,
         nativeBehavior: nativeBehavior)
@@ skipping 401 matching lines @@
     HInstruction awaited = pop();
     // TODO(herhut): Improve this type.
     push(new HAwait(awaited, closedWorld.commonMasks.dynamicType));
   }
 
   @override
   void visitRethrow(ir.Rethrow rethrowNode) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
       exception = graph.addConstantNull(closedWorld);
-      reporter.internalError(astAdapter.getNode(rethrowNode),
+      reporter.internalError(
+          _elementMap.getSpannable(targetElement, rethrowNode),
           'rethrowableException should not be null.');
     }
     handleInTryStatement();
     SourceInformation sourceInformation = null;
     closeAndGotoExit(new HThrow(exception, sourceInformation, isRethrow: true));
     // ir.Rethrow is an expression so we need to push a value - a constant with
     // no type.
     stack.add(graph.addConstantUnreachable(closedWorld));
   }
 
@@ skipping 275 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }