Make source information mandatory for building send-like node in CPS

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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.
 library dart2js.ir_nodes;
 
 import 'dart:collection';
 import 'cps_fragment.dart' show CpsFragment;
 import 'cps_ir_nodes_sexpr.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
@@ skipping 1095 matching lines @@
 
 /// Gets the value from a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  A [LetPrim] with a [GetMutable] can then be seen as:
 ///
 ///   let prim p = ![variable] in [body]
 ///
 class GetMutable extends Primitive {
   final Reference<MutableVariable> variableRef;
+  final SourceInformation sourceInformation;
 
   MutableVariable get variable => variableRef.definition;
 
-  GetMutable(MutableVariable variable)
+  GetMutable(MutableVariable variable, {this.sourceInformation})
       : this.variableRef = new Reference<MutableVariable>(variable);
 
   accept(Visitor visitor) => visitor.visitGetMutable(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
     variableRef.parent = this;
   }
 }
 
 /// Assign a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  This can be seen as a dereferencing assignment:
 ///
 ///   { [variable] := [value]; [body] }
 class SetMutable extends Primitive {
   final Reference<MutableVariable> variableRef;
   final Reference<Primitive> valueRef;
+  final SourceInformation sourceInformation;
 
   MutableVariable get variable => variableRef.definition;
   Primitive get value => valueRef.definition;
 
-  SetMutable(MutableVariable variable, Primitive value)
+  SetMutable(
+      MutableVariable variable,
+      Primitive value,
+      {this.sourceInformation})
       : this.variableRef = new Reference<MutableVariable>(variable),
         this.valueRef = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetMutable(this);
 
   bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
     variableRef.parent = this;
     valueRef.parent = this;
   }
 }
 
 /// Directly reads from a field on a given object.
 ///
 /// The [object] must either be `null` or an object that has [field].
 class GetField extends Primitive {
   final Reference<Primitive> objectRef;
   FieldElement field;
+  final SourceInformation sourceInformation;
 
   /// True if the field never changes value.
   final bool isFinal;
 
   /// True if the object is known not to be null.
   // TODO(asgerf): This is a placeholder until we agree on how to track
   //               side effects.
   bool objectIsNotNull = false;
 
   Primitive get object => objectRef.definition;
 
-  GetField(Primitive object, this.field, {this.isFinal: false})
+  GetField(
+      Primitive object,
+      this.field,
+      {this.sourceInformation,
+       this.isFinal: false})
       : this.objectRef = new Reference<Primitive>(object);
 
   accept(Visitor visitor) => visitor.visitGetField(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => objectIsNotNull;
   bool get isSafeForReordering => false;
 
   toString() => 'GetField($field)';
 
   void setParentPointers() {
     objectRef.parent = this;
   }
 
   int get effects => isFinal ? 0 : Effects.dependsOnInstanceField;
 }
 
 /// Directly assigns to a field on a given object.
 class SetField extends Primitive {
   final Reference<Primitive> objectRef;
   FieldElement field;
   final Reference<Primitive> valueRef;
+  final SourceInformation sourceInformation;
 
   Primitive get object => objectRef.definition;
   Primitive get value => valueRef.definition;
 
-  SetField(Primitive object, this.field, Primitive value)
+  SetField(
+      Primitive object,
+      this.field,
+      Primitive value,
+      {this.sourceInformation})
       : this.objectRef = new Reference<Primitive>(object),
         this.valueRef = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetField(this);
 
   bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
@@ skipping 304 matching lines @@
   void setParentPointers() {
     _setParentsOnList(argumentRefs, this);
   }
 }
 
 class ForeignCode extends UnsafePrimitive {
   final js.Template codeTemplate;
   final TypeMask storedType;
   final List<Reference<Primitive>> argumentRefs;
   final native.NativeBehavior nativeBehavior;
+  final SourceInformation sourceInformation;
   final FunctionElement dependency;
 
   Primitive argument(int n) => argumentRefs[n].definition;
   Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
 
-  ForeignCode(this.codeTemplate, this.storedType, List<Primitive> arguments,
+  ForeignCode(
+      this.codeTemplate,
+      this.storedType,
+      List<Primitive> arguments,
       this.nativeBehavior,
+      this.sourceInformation,
       {this.dependency})
       : this.argumentRefs = _referenceList(arguments) {
     effects = Effects.from(nativeBehavior.sideEffects);
   }
 
   accept(Visitor visitor) => visitor.visitForeignCode(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
@@ skipping 1265 matching lines @@
         getList(node.argumentRefs),
         node.sourceInformation)..allocationSiteType = node.allocationSiteType;
   }
 
   Definition visitTypeCast(TypeCast node) {
     return new TypeCast(
         getCopy(node.valueRef), node.dartType, getList(node.typeArgumentRefs));
   }
 
   Definition visitSetMutable(SetMutable node) {
-    return new SetMutable(getCopy(node.variableRef), getCopy(node.valueRef));
+    return new SetMutable(getCopy(node.variableRef), getCopy(node.valueRef),
+        sourceInformation: node.sourceInformation);
   }
 
   Definition visitSetStatic(SetStatic node) {
     return new SetStatic(
         node.element, getCopy(node.valueRef), node.sourceInformation);
   }
 
   Definition visitSetField(SetField node) {
     return new SetField(
-        getCopy(node.objectRef), node.field, getCopy(node.valueRef));
+        getCopy(node.objectRef), node.field, getCopy(node.valueRef),
+        sourceInformation: node.sourceInformation);
   }
 
   Definition visitGetLazyStatic(GetLazyStatic node) {
     return new GetLazyStatic(node.element,
         isFinal: node.isFinal, sourceInformation: node.sourceInformation);
   }
 
   Definition visitAwait(Await node) {
     return new Await(getCopy(node.inputRef));
   }
 
   Definition visitYield(Yield node) {
     return new Yield(getCopy(node.inputRef), node.hasStar);
   }
 
   Definition visitLiteralList(LiteralList node) {
     return new LiteralList(node.dartType, getList(node.valueRefs))
       ..allocationSiteType = node.allocationSiteType;
   }
 
   Definition visitConstant(Constant node) {
     return new Constant(node.value, sourceInformation: node.sourceInformation);
   }
 
   Definition visitGetMutable(GetMutable node) {
-    return new GetMutable(getCopy(node.variableRef));
+    return new GetMutable(
+        getCopy(node.variableRef), sourceInformation: node.sourceInformation);
   }
 
   Definition visitParameter(Parameter node) {
     return new Parameter(node.hint);
   }
 
   Definition visitMutableVariable(MutableVariable node) {
     return new MutableVariable(node.hint);
   }
 
@@ skipping 95 matching lines @@
     return new ReceiverCheck(
         getCopy(node.valueRef), node.selector, node.sourceInformation,
         condition: getCopyOrNull(node.conditionRef),
         useSelector: node.useSelector,
         isNullCheck: node.isNullCheck);
   }
 
   Definition visitForeignCode(ForeignCode node) {
     return new ForeignCode(node.codeTemplate, node.storedType,
         getList(node.argumentRefs), node.nativeBehavior,
+        node.sourceInformation,
         dependency: node.dependency);
   }
 }
 
 /// A trampolining visitor to copy [FunctionDefinition]s.
 class CopyingVisitor extends TrampolineRecursiveVisitor {
   // The visitor maintains a map from original continuations to their copies.
   Map<Continuation, Continuation> _copies = <Continuation, Continuation>{};
 
   // The visitor uses an auxiliary visitor to copy definitions.
@@ skipping 125 matching lines @@
     plug(new Branch.loose(
         _definitions.getCopy(node.conditionRef),
         _copies[node.trueContinuation],
         _copies[node.falseContinuation])..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }