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

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.dart

 // Copyright (c) 2014, 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 tree_ir_nodes;
 
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 38 matching lines @@
   static int _usedHashCodes = 0;
   final int hashCode = ++_usedHashCodes;
 }
 
 /**
  * The base class of [Expression]s.
  */
 abstract class Expression extends Node {
   accept(ExpressionVisitor v);
   accept1(ExpressionVisitor1 v, arg);
+
+  SourceInformation get sourceInformation => null;
 }
 
 abstract class Statement extends Node {
   Statement get next;
   void set next(Statement s);
   accept(StatementVisitor v);
   accept1(StatementVisitor1 v, arg);
 }
 
 /**
@@ skipping 47 matching lines @@
     assert(host != null);
   }
 
   String toString() =>
       element == null ? 'Variable.${hashCode}' : element.toString();
 }
 
 /// Read the value of a variable.
 class VariableUse extends Expression {
   Variable variable;
+  SourceInformation sourceInformation;
 
   /// Creates a use of [variable] and updates its `readCount`.
-  VariableUse(this.variable) {
+  VariableUse(this.variable, {this.sourceInformation}) {
     variable.readCount++;
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitVariableUse(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitVariableUse(this, arg);
   }
 }
 
 class Assign extends Expression {
   Variable variable;
   Expression value;
+  SourceInformation sourceInformation;
 
-  Assign(this.variable, this.value) {
+  Assign(this.variable, this.value, {this.sourceInformation}) {
     variable.writeCount++;
   }
 
   accept(ExpressionVisitor v) => v.visitAssign(this);
   accept1(ExpressionVisitor1 v, arg) => v.visitAssign(this, arg);
 
   static ExpressionStatement makeStatement(Variable variable,
                                            Expression value,
                                            [Statement next]) {
     return new ExpressionStatement(new Assign(variable, value), next);
@@ skipping 533 matching lines @@
   accept(ExpressionVisitor visitor) => visitor.visitCreateInstance(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitCreateInstance(this, arg);
   }
 }
 
 class GetField extends Expression {
   Expression object;
   Element field;
   bool objectIsNotNull;
+  SourceInformation sourceInformation;
 
-  GetField(this.object, this.field, {this.objectIsNotNull: false});
+  GetField(
+      this.object,
+      this.field,
+      this.sourceInformation,
+      {this.objectIsNotNull: false});
 
   accept(ExpressionVisitor visitor) => visitor.visitGetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitGetField(this, arg);
 }
 
 class SetField extends Expression {
   Expression object;
   Element field;
   Expression value;
+  SourceInformation sourceInformation;
 
   /// If non-null, this is a compound assignment to the field, using the given
   /// operator.  The operator must be a compoundable operator.
   BuiltinOperator compound;
 
-  SetField(this.object, this.field, this.value, {this.compound});
+  SetField(
+      this.object,
+      this.field,
+      this.value,
+      this.sourceInformation,
+      {this.compound});
 
   accept(ExpressionVisitor visitor) => visitor.visitSetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
 }
 
 
 /// Read the type test property from [object]. The value is truthy/fasly rather
 /// than bool. [object] must not be `null`.
 class GetTypeTestProperty extends Expression {
   Expression object;
@@ skipping 127 matching lines @@
   }
 }
 
 class ForeignCode extends Node {
   final js.Template codeTemplate;
   final types.TypeMask type;
   final List<Expression> arguments;
   final native.NativeBehavior nativeBehavior;
   final List<bool> nullableArguments;  // One 'bit' per argument.
   final Element dependency;
+  final SourceInformation sourceInformation;
 
-  ForeignCode(this.codeTemplate, this.type, this.arguments, this.nativeBehavior,
-      this.nullableArguments, this.dependency) {
+  ForeignCode(
+      this.codeTemplate,
+      this.type,
+      this.arguments,
+      this.nativeBehavior,
+      this.nullableArguments,
+      this.dependency,
+      this.sourceInformation) {
     assert(arguments.length == nullableArguments.length);
   }
 }
 
 class ForeignExpression extends ForeignCode implements Expression {
   ForeignExpression(
       js.Template codeTemplate, types.TypeMask type,
       List<Expression> arguments, native.NativeBehavior nativeBehavior,
       List<bool> nullableArguments,
-      Element dependency)
+      Element dependency,
+      SourceInformation sourceInformation)
       : super(codeTemplate, type, arguments, nativeBehavior, nullableArguments,
-          dependency);
+          dependency, sourceInformation);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitForeignExpression(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitForeignExpression(this, arg);
   }
 }
 
 class ForeignStatement extends ForeignCode implements Statement {
   ForeignStatement(
       js.Template codeTemplate, types.TypeMask type,
       List<Expression> arguments, native.NativeBehavior nativeBehavior,
       List<bool> nullableArguments,
-      Element dependency)
+      Element dependency,
+      SourceInformation sourceInformation)
       : super(codeTemplate, type, arguments, nativeBehavior, nullableArguments,
-          dependency);
+          dependency, sourceInformation);
 
   accept(StatementVisitor visitor) {
     return visitor.visitForeignStatement(this);
   }
 
   accept1(StatementVisitor1 visitor, arg) {
     return visitor.visitForeignStatement(this, arg);
   }
 
   @override
@@ skipping 687 matching lines @@
 
   /// Number of uses of the current fallthrough target.
   int get useCount => _stack.last.useCount;
 
   /// Indicate that a statement will fall through to the current fallthrough
   /// target.
   void use() {
     ++_stack.last.useCount;
   }
 }