[fasta] Add and correct more offsets

pkg/front_end/lib/src/fasta/kernel/frontend_accessors.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.
 
 // Note: copied from package:kernel at revision 7346348.
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 library kernel.frontend.accessors;
 
@@ skipping 41 matching lines @@
     }
     var tmp = new VariableDeclaration.forValue(_makeRead());
     return _finish(makeLet(
         tmp,
         new ConditionalExpression(buildIsNull(new VariableGet(tmp)),
             _makeWrite(value, false), new VariableGet(tmp), type)));
   }
 
   /// Returns an [Expression] representing a compound assignment (e.g. `+=`)
   /// with the accessor on the LHS and [value] on the RHS.
-  Expression buildCompoundAssignment(Name binaryOperator, Expression value,
+  Expression buildCompoundAssignment(
+      Name binaryOperator, Expression value, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return _finish(_makeWrite(
-        makeBinary(_makeRead(), binaryOperator, interfaceTarget, value),
+        makeBinary(
+            _makeRead(), binaryOperator, interfaceTarget, value, charOffset),
         voidContext));
   }
 
   /// Returns an [Expression] representing a pre-increment or pre-decrement
   /// of the accessor.
-  Expression buildPrefixIncrement(Name binaryOperator,
+  Expression buildPrefixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
-    return buildCompoundAssignment(binaryOperator, new IntLiteral(1),
+    return buildCompoundAssignment(
+        binaryOperator, new IntLiteral(1), charOffset,
         voidContext: voidContext, interfaceTarget: interfaceTarget);
   }
 
   /// Returns an [Expression] representing a post-increment or post-decrement
   /// of the accessor.
-  Expression buildPostfixIncrement(Name binaryOperator,
+  Expression buildPostfixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     if (voidContext) {
-      return buildPrefixIncrement(binaryOperator,
+      return buildPrefixIncrement(binaryOperator, charOffset,
           voidContext: true, interfaceTarget: interfaceTarget);
     }
     var value = new VariableDeclaration.forValue(_makeRead());
     valueAccess() => new VariableGet(value);
     var dummy = new VariableDeclaration.forValue(_makeWrite(
-        makeBinary(
-            valueAccess(), binaryOperator, interfaceTarget, new IntLiteral(1)),
+        makeBinary(valueAccess(), binaryOperator, interfaceTarget,
+            new IntLiteral(1), charOffset),
         true));
     return _finish(makeLet(value, makeLet(dummy, valueAccess())));
   }
 
   Expression _makeSimpleRead() => _makeRead();
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     return _makeWrite(value, voidContext);
   }
 
@@ skipping 142 matching lines @@
 
 final Name _indexGet = new Name('[]');
 final Name _indexSet = new Name('[]=');
 
 class IndexAccessor extends Accessor {
   Expression receiver;
   Expression index;
   VariableDeclaration receiverVariable;
   VariableDeclaration indexVariable;
   Procedure getter, setter;
+  int charOffset;
 
   static Accessor make(Expression receiver, Expression index, Procedure getter,
-      Procedure setter) {
+      Procedure setter, int charOffset) {
     if (receiver is ThisExpression) {
       return new ThisIndexAccessor(index, getter, setter);
     } else {
-      return new IndexAccessor.internal(receiver, index, getter, setter);
+      return new IndexAccessor.internal(
+          receiver, index, getter, setter, charOffset);
     }
   }
 
-  IndexAccessor.internal(this.receiver, this.index, this.getter, this.setter);
+  IndexAccessor.internal(
+      this.receiver, this.index, this.getter, this.setter, this.charOffset);
 
   _makeSimpleRead() => new MethodInvocation(
-      receiver, _indexGet, new Arguments(<Expression>[index]), getter);
+      receiver, _indexGet, new Arguments(<Expression>[index]), getter)
+    ..fileOffset = charOffset;
 
   _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new MethodInvocation(
-        receiver, _indexSet, new Arguments(<Expression>[index, value]), setter);
+        receiver, _indexSet, new Arguments(<Expression>[index, value]), setter)
+      ..fileOffset = charOffset;
   }
 
   receiverAccess() {
     // We cannot reuse the receiver if it is a variable since it might be
     // reassigned in the index expression.
     receiverVariable ??= new VariableDeclaration.forValue(receiver);
-    return new VariableGet(receiverVariable);
+    return new VariableGet(receiverVariable)..fileOffset = charOffset;
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
-    return new VariableGet(indexVariable);
+    return new VariableGet(indexVariable)..fileOffset = charOffset;
   }
 
   _makeRead() {
-    return new MethodInvocation(receiverAccess(), _indexGet,
-        new Arguments(<Expression>[indexAccess()]), getter);
+    return new MethodInvocation(
+        receiverAccess(),
+        _indexGet,
+        new Arguments(<Expression>[indexAccess()]),
+        getter)..fileOffset = charOffset;
   }
 
   _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
-    return new MethodInvocation(receiverAccess(), _indexSet,
-        new Arguments(<Expression>[indexAccess(), value]), setter);
+    return new MethodInvocation(
+        receiverAccess(),
+        _indexSet,
+        new Arguments(<Expression>[indexAccess(), value]),
+        setter)..fileOffset = charOffset;
   }
 
   _makeWriteAndReturn(Expression value) {
     // The call to []= does not return the value like direct-style assignments
     // do.  We need to bind the value in a let.
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new MethodInvocation(
         receiverAccess(),
         _indexSet,
         new Arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
-        setter));
+        setter)..fileOffset = charOffset);
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
   Expression _finish(Expression body) {
     return makeLet(receiverVariable, makeLet(indexVariable, body));
   }
 }
 
 /// Special case of [IndexAccessor] to avoid creating an indirect access to
@@ skipping 126 matching lines @@
 
   Expression _finish(Expression body) => makeLet(value, body);
 }
 
 Expression makeLet(VariableDeclaration variable, Expression body) {
   if (variable == null) return body;
   return new Let(variable, body);
 }
 
 Expression makeBinary(Expression left, Name operator, Procedure interfaceTarget,
-    Expression right) {
+    Expression right, int charOffset) {
   return new MethodInvocation(
-      left, operator, new Arguments(<Expression>[right]), interfaceTarget);
+      left, operator, new Arguments(<Expression>[right]), interfaceTarget)
+    ..fileOffset = charOffset;
 }
 
 final Name _equalOperator = new Name('==');
 
 Expression buildIsNull(Expression value) {
-  return makeBinary(value, _equalOperator, null, new NullLiteral());
+  return makeBinary(
+      value, _equalOperator, null, new NullLiteral(), TreeNode.noOffset);
 }
 
 VariableDeclaration makeOrReuseVariable(Expression value) {
   // TODO: Devise a way to remember if a variable declaration was reused
   // or is fresh (hence needs a let binding).
   return new VariableDeclaration.forValue(value);
 }
 
 Expression wrapInvalid(Expression e) {
   return new Let(new VariableDeclaration.forValue(e), new InvalidExpression());
 }