Create and test source mapping for invocations.

pkg/compiler/lib/src/ssa/nodes.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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitAwait(HAwait node);
   R visitBitAnd(HBitAnd node);
@@ skipping 154 matching lines @@
   }
 
   HBasicBlock addNewLoopHeaderBlock(JumpTarget target,
                                     List<LabelDefinition> labels) {
     HBasicBlock result = addNewBlock();
     result.loopInformation =
         new HLoopInformation(result, target, labels);
     return result;
   }
 
-  HConstant addConstant(ConstantValue constant, Compiler compiler) {
+  HConstant addConstant(ConstantValue constant, Compiler compiler,
+                        {SourceInformation sourceInformation}) {
     HConstant result = constants[constant];
+    // TODO(johnniwinther): Support source information per constant reference.
     if (result == null) {
       TypeMask type = computeTypeMask(compiler, constant);
-      result = new HConstant.internal(constant, type);
+      result = new HConstant.internal(constant, type)
+          ..sourceInformation = sourceInformation;
       entry.addAtExit(result);
       constants[constant] = result;
     } else if (result.block == null) {
       // The constant was not used anymore.
       entry.addAtExit(result);
     }
     return result;
   }
 
   HConstant addDeferredConstant(ConstantValue constant, PrefixElement prefix,
+                                SourceInformation sourceInformation,
                                 Compiler compiler) {
     // TODO(sigurdm,johnniwinter): These deferred constants should be created
     // by the constant evaluator.
     ConstantValue wrapper = new DeferredConstantValue(constant, prefix);
     compiler.deferredLoadTask.registerConstantDeferredUse(wrapper, prefix);
-    return addConstant(wrapper, compiler);
+    return addConstant(wrapper, compiler, sourceInformation: sourceInformation);
   }
 
   HConstant addConstantInt(int i, Compiler compiler) {
     return addConstant(compiler.backend.constantSystem.createInt(i), compiler);
   }
 
   HConstant addConstantDouble(double d, Compiler compiler) {
     return addConstant(
         compiler.backend.constantSystem.createDouble(d), compiler);
   }
@@ skipping 1103 matching lines @@
  */
 abstract class HLateInstruction extends HInstruction {
   HLateInstruction(List<HInstruction> inputs, TypeMask type)
       : super(inputs, type);
 }
 
 class HBoolify extends HInstruction {
   HBoolify(HInstruction value, TypeMask type)
       : super(<HInstruction>[value], type) {
     setUseGvn();
+    sourceInformation = value.sourceInformation;
   }
 
   accept(HVisitor visitor) => visitor.visitBoolify(this);
   int typeCode() => HInstruction.BOOLIFY_TYPECODE;
   bool typeEquals(other) => other is HBoolify;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * A [HCheck] instruction is an instruction that might do a dynamic
@@ skipping 192 matching lines @@
   /** The class where the call to super is being done. */
   final ClassElement caller;
   final bool isSetter;
   final Selector selector;
 
   HInvokeSuper(Element element,
                this.caller,
                this.selector,
                inputs,
                type,
+               SourceInformation sourceInformation,
                {this.isSetter})
-      : super(element, inputs, type);
+      : super(element, inputs, type) {
+    this.sourceInformation = sourceInformation;
+  }
 
   HInstruction get receiver => inputs[0];
   HInstruction getDartReceiver(Compiler compiler) {
     return isCallOnInterceptor(compiler) ? inputs[1] : inputs[0];
   }
 
   /**
    * Returns whether this call is on an interceptor object.
    */
   bool isCallOnInterceptor(Compiler compiler) {
@@ skipping 752 matching lines @@
   accept(HVisitor visitor) => visitor.visitLessEqual(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.lessEqual;
   int typeCode() => HInstruction.LESS_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HLessEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HReturn extends HControlFlow {
-  HReturn(value) : super(<HInstruction>[value]);
+  HReturn(HInstruction value, SourceInformation sourceInformation)
+      : super(<HInstruction>[value]) {
+    this.sourceInformation = sourceInformation;
+  }
   toString() => 'return';
   accept(HVisitor visitor) => visitor.visitReturn(this);
 }
 
 class HThrowExpression extends HInstruction {
-  HThrowExpression(value)
-      : super(<HInstruction>[value], const TypeMask.nonNullEmpty());
+  HThrowExpression(HInstruction value, SourceInformation sourceInformation)
+      : super(<HInstruction>[value], const TypeMask.nonNullEmpty()) {
+    this.sourceInformation = sourceInformation;
+  }
   toString() => 'throw expression';
   accept(HVisitor visitor) => visitor.visitThrowExpression(this);
   bool canThrow() => true;
 }
 
 class HAwait extends HInstruction {
   HAwait(HInstruction value, TypeMask type)
       : super(<HInstruction>[value], type);
   toString() => 'await';
   accept(HVisitor visitor) => visitor.visitAwait(this);
   // An await will throw if its argument is not a real future.
   bool canThrow() => true;
   SideEffects sideEffects = new SideEffects();
 }
 
 class HYield extends HInstruction {
   HYield(HInstruction value, this.hasStar)
       : super(<HInstruction>[value], const TypeMask.nonNullEmpty());
   bool hasStar;
   toString() => 'yield';
   accept(HVisitor visitor) => visitor.visitYield(this);
   bool canThrow() => false;
   SideEffects sideEffects = new SideEffects();
 }
 
 class HThrow extends HControlFlow {
   final bool isRethrow;
-  HThrow(value, {this.isRethrow: false}) : super(<HInstruction>[value]);
+  HThrow(HInstruction value,
+         SourceInformation sourceInformation,
+         {this.isRethrow: false})
+      : super(<HInstruction>[value]) {
+    this.sourceInformation = sourceInformation;
+  }
   toString() => 'throw';
   accept(HVisitor visitor) => visitor.visitThrow(this);
 }
 
 class HStatic extends HInstruction {
   final Element element;
   HStatic(this.element, type) : super(<HInstruction>[], type) {
     assert(element != null);
     assert(invariant(this, element.isDeclaration));
     sideEffects.clearAllSideEffects();
@@ skipping 874 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }