Add offsets to the `== null` calls inserted by null-aware desugaring.

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.
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show
         KernelArguments,
@@ skipping 55 matching lines @@
         complexAssignment);
   }
 
   /// Returns an [Expression] representing a null-aware assignment (`??=`) with
   /// the accessor on the LHS and [value] on the RHS.
   ///
   /// The returned expression evaluates to the assigned value, unless
   /// [voidContext] is true, in which case it may evaluate to anything.
   ///
   /// [type] is the static type of the RHS.
-  Expression buildNullAwareAssignment(Expression value, DartType type,
+  Expression buildNullAwareAssignment(
+      Expression value, DartType type, int offset,
       {bool voidContext: false}) {
     var complexAssignment = startComplexAssignment(value);
     if (voidContext) {
       var nullAwareCombiner = new KernelConditionalExpression(
-          buildIsNull(_makeRead(complexAssignment)),
+          buildIsNull(_makeRead(complexAssignment), offset),
           _makeWrite(value, false, complexAssignment),
           new NullLiteral());
       complexAssignment?.nullAwareCombiner = nullAwareCombiner;
       return _finish(nullAwareCombiner, complexAssignment);
     }
     var tmp = new VariableDeclaration.forValue(_makeRead(complexAssignment));
     var nullAwareCombiner = new KernelConditionalExpression(
-        buildIsNull(new VariableGet(tmp)),
+        buildIsNull(new VariableGet(tmp), offset),
         _makeWrite(value, false, complexAssignment),
         new VariableGet(tmp));
     complexAssignment?.nullAwareCombiner = nullAwareCombiner;
     return _finish(makeLet(tmp, nullAwareCombiner), complexAssignment);
   }
 
   /// 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,
       {int offset: TreeNode.noOffset,
@@ skipping 241 matching lines @@
       KernelComplexAssignment complexAssignment) {
     var write = new KernelPropertySet(receiverAccess(), name, value, setter)
       ..fileOffset = offsetForToken(token);
     complexAssignment?.write = write;
     return write;
   }
 
   Expression _finish(
       Expression body, KernelComplexAssignment complexAssignment) {
     var nullAwareGuard = new KernelConditionalExpression(
-        buildIsNull(receiverAccess()), new NullLiteral(), body)
+        buildIsNull(receiverAccess(), offsetForToken(token)),
+        new NullLiteral(),
+        body)
       ..fileOffset = offsetForToken(token);
     body = makeLet(receiver, nullAwareGuard);
     if (complexAssignment != null) {
       KernelPropertyAssign kernelPropertyAssign = complexAssignment;
       kernelPropertyAssign.nullAwareGuard = nullAwareGuard;
       kernelPropertyAssign.desugared = body;
       return kernelPropertyAssign;
     } else {
       return body;
     }
@@ skipping 311 matching lines @@
 
 Expression makeBinary(
     Expression left, Name operator, Procedure interfaceTarget, Expression right,
     {int offset: TreeNode.noOffset}) {
   return new KernelMethodInvocation(
       left, operator, new KernelArguments(<Expression>[right]),
       interfaceTarget: interfaceTarget)
     ..fileOffset = offset;
 }
 
-Expression buildIsNull(Expression value, {int offset: TreeNode.noOffset}) {
+Expression buildIsNull(Expression value, int offset) {

[Paul Berry, 2017/06/12 20:17:23]

Note: I changed `offset` to a required argument here so that it wouldn't be
forgotten by mistake.

   return makeBinary(value, equalsName, 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);
 }