Non-format-changing kernel offset changes

pkg/kernel/lib/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.
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 library kernel.frontend.accessors;
 
 import '../ast.dart';
 
@@ skipping 24 matching lines @@
           _makeWrite(value, voidContext), new NullLiteral(), type));
     }
     var tmp = new VariableDeclaration.forValue(_makeRead());
     return _finish(makeLet(
         tmp,
         new ConditionalExpression(buildIsNull(new VariableGet(tmp)),
             _makeWrite(value, voidContext), new VariableGet(tmp), type)));
   }
 
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
-      {bool voidContext: false, Procedure interfaceTarget}) {
+      {int offset: TreeNode.noOffset,
+      bool voidContext: false,
+      Procedure interfaceTarget}) {
     return _finish(_makeWrite(
-        builtBinary =
-            makeBinary(_makeRead(), binaryOperator, interfaceTarget, value),
+        builtBinary = makeBinary(
+            _makeRead(), binaryOperator, interfaceTarget, value,
+            offset: offset),
         voidContext));
   }
 
   Expression buildPrefixIncrement(Name binaryOperator,
-      {bool voidContext: false, Procedure interfaceTarget}) {
+      {int offset: TreeNode.noOffset,
+      bool voidContext: false,
+      Procedure interfaceTarget}) {
     return buildCompoundAssignment(binaryOperator, new IntLiteral(1),
-        voidContext: voidContext, interfaceTarget: interfaceTarget);
+        offset: offset,
+        voidContext: voidContext,
+        interfaceTarget: interfaceTarget);
   }
 
   Expression buildPostfixIncrement(Name binaryOperator,
-      {bool voidContext: false, Procedure interfaceTarget}) {
+      {int offset: TreeNode.noOffset,
+      bool voidContext: false,
+      Procedure interfaceTarget}) {
     if (voidContext) {
-      return buildPrefixIncrement(binaryOperator,
+      return buildPrefixIncrement(binaryOperator, offset: offset,
           voidContext: true, interfaceTarget: interfaceTarget);
     }
     var value = new VariableDeclaration.forValue(_makeRead());
     valueAccess() => new VariableGet(value);
     var dummy = new VariableDeclaration.forValue(_makeWrite(
-        builtBinary = makeBinary(
-            valueAccess(), binaryOperator, interfaceTarget, new IntLiteral(1)),
+        builtBinary = makeBinary(valueAccess(), binaryOperator, interfaceTarget,
+            new IntLiteral(1), offset: offset),
         true));
     return _finish(makeLet(value, makeLet(dummy, valueAccess())));
   }
 
   Expression _makeSimpleRead() => _makeRead();
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     return _makeWrite(value, voidContext);
   }
 
@@ skipping 314 matching lines @@
   _makeWrite(Expression value, bool voidContext) => makeInvalidWrite(value);
 
   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 makeBinary(
+    Expression left, Name operator, Procedure interfaceTarget, Expression right,
+    {int offset: TreeNode.noOffset}) {
   return new MethodInvocation(
-      left, operator, new Arguments(<Expression>[right]), interfaceTarget);
+      left, operator, new Arguments(<Expression>[right]), interfaceTarget)
+    ..fileOffset = offset;
 }
 
 final Name _equalOperator = new Name('==');
 
-Expression buildIsNull(Expression value) {
-  return makeBinary(value, _equalOperator, null, new NullLiteral());
+Expression buildIsNull(Expression value, {int offset: TreeNode.noOffset}) {
+  return makeBinary(value, _equalOperator, null, new NullLiteral(),
+      offset: offset);
 }
 
 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());
 }