Add operators test to source_mapping_test.

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 38 matching lines @@
   R visitLocalValue(HLocalValue node);
   R visitLoopBranch(HLoopBranch node);
   R visitMultiply(HMultiply node);
   R visitNegate(HNegate node);
   R visitNot(HNot node);
   R visitOneShotInterceptor(HOneShotInterceptor node);
   R visitParameterValue(HParameterValue node);
   R visitPhi(HPhi node);
   R visitRangeConversion(HRangeConversion node);
   R visitReadModifyWrite(HReadModifyWrite node);
+  R visitRef(HRef node);
   R visitReturn(HReturn node);
   R visitShiftLeft(HShiftLeft node);
   R visitShiftRight(HShiftRight node);
   R visitStatic(HStatic node);
   R visitStaticStore(HStaticStore node);
   R visitStringConcat(HStringConcat node);
   R visitStringify(HStringify node);
   R visitSubtract(HSubtract node);
   R visitSwitch(HSwitch node);
   R visitThis(HThis node);
@@ skipping 271 matching lines @@
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
   visitOneShotInterceptor(HOneShotInterceptor node)
       => visitInvokeDynamic(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitLocalValue(node);
   visitRangeConversion(HRangeConversion node) => visitCheck(node);
   visitReadModifyWrite(HReadModifyWrite node) => visitInstruction(node);
+  visitRef(HRef node) => node.value.accept(this);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
   visitSubtract(HSubtract node) => visitBinaryArithmetic(node);
   visitSwitch(HSwitch node) => visitControlFlow(node);
   visitStatic(HStatic node) => visitInstruction(node);
   visitStaticStore(HStaticStore node) => visitInstruction(node);
   visitStringConcat(HStringConcat node) => visitInstruction(node);
   visitStringify(HStringify node) => visitInstruction(node);
   visitThis(HThis node) => visitParameterValue(node);
@@ skipping 940 matching lines @@
 
   /**
    * Return whether the instructions do not belong to a loop or
    * belong to the same loop.
    */
   bool hasSameLoopHeaderAs(HInstruction other) {
     return block.enclosingLoopHeader == other.block.enclosingLoopHeader;
   }
 }
 
+/// A reference to a [HInstruction] that can hold its own source information.
+///
+/// This used for attaching source information to reads of locals.
+class HRef extends HInstruction {
+  HRef(HInstruction value, SourceInformation sourceInformation)
+      : super([value], value.instructionType) {
+    this.sourceInformation = sourceInformation;
+  }
+
+  HInstruction get value => inputs[0];
+
+  @override
+  accept(HVisitor visitor) => visitor.visitRef(this);
+
+  String toString() => 'HRef(${value})';
+}
+
 /**
  * Late instructions are used after the main optimization phases.  They capture
  * codegen decisions just prior to generating JavaScript.
  */
 abstract class HLateInstruction extends HInstruction {
   HLateInstruction(List<HInstruction> inputs, TypeMask type)
       : super(inputs, type);
 }
 
 class HBoolify extends HInstruction {
@@ skipping 387 matching lines @@
 
   HLocalAccess(this.variable, List<HInstruction> inputs, TypeMask type)
       : super(inputs, type);
 
   HInstruction get receiver => inputs[0];
 }
 
 class HLocalGet extends HLocalAccess {
   // No need to use GVN for a [HLocalGet], it is just a local
   // access.
-  HLocalGet(Local variable, HLocalValue local, TypeMask type)
-      : super(variable, <HInstruction>[local], type);
+  HLocalGet(Local variable, HLocalValue local, TypeMask type,
+            SourceInformation sourceInformation)
+      : super(variable, <HInstruction>[local], type) {
+    this.sourceInformation = sourceInformation;
+  }
 
   accept(HVisitor visitor) => visitor.visitLocalGet(this);
 
   HLocalValue get local => inputs[0];
 }
 
 class HLocalSet extends HLocalAccess {
   HLocalSet(Local variable, HLocalValue local, HInstruction value)
       : super(variable, <HInstruction>[local, value],
               const TypeMask.nonNullEmpty());
@@ skipping 59 matching lines @@
   bool isJsStatement() => isStatement;
   bool canThrow() => canBeNull()
       ? throwBehavior.canThrow
       : throwBehavior.onNonNull.canThrow;
 
   bool onlyThrowsNSM() => throwBehavior.isOnlyNullNSMGuard;
 
   bool get isAllocation => nativeBehavior != null &&
       nativeBehavior.isAllocation &&
       !canBeNull();
+
+  String toString() => 'HForeignCode("${codeTemplate.source}",$inputs)';
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
 
   /// If this field is not `null`, this call is from an inlined constructor and
   /// we have to register the instantiated type in the code generator. The
   /// [instructionType] of this node is not enough, because we also need the
   /// type arguments. See also [SsaFromAstMixin.currentInlinedInstantiations].
   List<DartType> instantiatedTypes;
@@ skipping 581 matching lines @@
 
   // inputs[0] is initially the only input, the receiver.
 
   // inputs[1] is a constant interceptor when the interceptor is a constant
   // except for a `null` receiver.  This is used when the receiver can't be
   // falsy, except for `null`, allowing the generation of code like
   //
   //     (a && C.JSArray_methods).get$first(a)
   //
 
-  HInterceptor(HInstruction receiver, TypeMask type)
+  HInterceptor(HInstruction receiver,
+               TypeMask type)
       : super(<HInstruction>[receiver], type) {
+    this.sourceInformation = receiver.sourceInformation;
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
   }
 
   String toString() => 'interceptor on $interceptedClasses';
   accept(HVisitor visitor) => visitor.visitInterceptor(this);
   HInstruction get receiver => inputs[0];
 
   bool get isConditionalConstantInterceptor => inputs.length == 2;
@@ skipping 832 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;
 }