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 23 matching lines @@
       return _finish(new ConditionalExpression(buildIsNull(_makeRead()),
           _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,
+  Expression buildCompoundAssignment(
+      Name binaryOperator, Expression value, int offset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return _finish(_makeWrite(
-        builtBinary =
-            makeBinary(_makeRead(), binaryOperator, interfaceTarget, value),
+        builtBinary = makeBinary(
+            _makeRead(), binaryOperator, interfaceTarget, value, offset),
         voidContext));
   }
 
-  Expression buildPrefixIncrement(Name binaryOperator,
+  Expression buildPrefixIncrement(Name binaryOperator, int offset,
       {bool voidContext: false, Procedure interfaceTarget}) {
-    return buildCompoundAssignment(binaryOperator, new IntLiteral(1),
+    return buildCompoundAssignment(binaryOperator, new IntLiteral(1), offset,
         voidContext: voidContext, interfaceTarget: interfaceTarget);
   }
 
-  Expression buildPostfixIncrement(Name binaryOperator,
+  Expression buildPostfixIncrement(Name binaryOperator, int offset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     if (voidContext) {
-      return buildPrefixIncrement(binaryOperator,
+      return buildPrefixIncrement(binaryOperator, 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),
         true));
     return _finish(makeLet(value, makeLet(dummy, valueAccess())));
   }
 
   Expression _makeSimpleRead() => _makeRead();
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     return _makeWrite(value, voidContext);
   }
 
@@ skipping 36 matching lines @@
     } else {
       return new PropertyAccessor._internal(receiver, name, getter, setter);
     }
   }
 
   PropertyAccessor._internal(
       this.receiver, this.name, this.getter, this.setter);
 
   _makeSimpleRead() => new PropertyGet(receiver, name, getter);
   _makeSimpleWrite(Expression value, bool voidContext) {
     return new PropertySet(receiver, name, value, setter);

[asgerf, 2017/01/04 14:20:01]

This node and most other accessor-created nodes are still missing offsets.

They would have to be stored in the constructor.

[jensj, 2017/01/05 09:07:55]

Yes, I'm not claiming that I won't have to make changes to kernel again; I've
only added the stuff I've seen that I need to make debugging of the dill files
I've tested on behave like the corresponding dart files.
I don't think I understand this comment.

[asgerf, 2017/01/05 11:37:41]

I just meant that in order to implement the last part, we would have to pass the
offsets to the Accessor constructors and store them in fields on the Accessor
object. I'm not saying it needs to be in this CL.

   }
 
   receiverAccess() {
     _receiverVariable ??= new VariableDeclaration.forValue(receiver);
     return new VariableGet(_receiverVariable);
   }
 
   _makeRead() => builtGetter = new PropertyGet(receiverAccess(), name, getter);
 
   _makeWrite(Expression value, bool voidContext) {
@@ skipping 258 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 offset) {
   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);
 }
 
 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());
 }