dart2js-kernel: map rasta 'read' node in 'field ??= e'

pkg/compiler/lib/src/kernel/kernel_visitor.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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 1300 matching lines @@
         visitForValue(receiver), nameToIrName(name), value);
   }
 
   @override
   ir.Expression handleDynamicSetIfNulls(
       Send node, Node receiver, Name name, Node rhs, _) {
     ir.Name irName = nameToIrName(name);
     Accessor accessor = (receiver == null)
         ? new ThisPropertyAccessor(irName, null, null)
         : PropertyAccessor.make(visitForValue(receiver), irName, null, null);
-    return accessor.buildNullAwareAssignment(visitForValue(rhs), null,
+    return _finishSetIfNull(node, accessor, rhs);
+  }
+
+  ir.Expression _finishSetIfNull(Send node, Accessor accessor, Node rhs) {
+    ir.Expression result = accessor.buildNullAwareAssignment(
+        visitForValue(rhs), null,
         voidContext: isVoidContext);
+    if (accessor.builtGetter != null) {
+      kernel.nodeToAst[accessor.builtGetter] = node;
+    }
+    return result;
   }
 
   @override
   ir.TypeLiteral visitDynamicTypeLiteralGet(
       Send node, ConstantExpression constant, _) {
     return buildTypeLiteral(constant);
   }
 
   @override
   ir.MethodInvocation visitDynamicTypeLiteralInvoke(
@@ skipping 211 matching lines @@
   @override
   ir.Expression visitIfNotNullDynamicPropertySet(
       SendSet node, Node receiver, Name name, Node rhs, _) {
     return buildNullAwarePropertyAccessor(receiver, name)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitIfNotNullDynamicPropertySetIfNull(
       Send node, Node receiver, Name name, Node rhs, _) {
-    return buildNullAwarePropertyAccessor(receiver, name)
-        .buildNullAwareAssignment(visitForValue(rhs), null,
-            voidContext: isVoidContext);
+    return _finishSetIfNull(
+        node, buildNullAwarePropertyAccessor(receiver, name), rhs);
   }
 
   ir.LogicalExpression buildLogicalExpression(
       Node left, Operator operator, Node right) {
     return new ir.LogicalExpression(
         visitForValue(left), operator.source, visitForValue(right));
   }
 
   @override
   ir.Expression visitIfNull(Send node, Node left, Node right, _) {
@@ skipping 318 matching lines @@
   ir.MethodInvocation handleLocalInvoke(Send node, LocalElement element,
       NodeList arguments, CallStructure callStructure, _) {
     return associateNode(
         buildCall(buildLocalGet(element), callStructure, arguments), node);
   }
 
   @override
   ir.Expression handleLocalSetIfNulls(
       SendSet node, LocalElement local, Node rhs, _,
       {bool isSetterValid}) {
-    return new VariableAccessor(getLocal(local)).buildNullAwareAssignment(
-        visitForValue(rhs), null,
-        voidContext: isVoidContext);
+    return _finishSetIfNull(node, new VariableAccessor(getLocal(local)), rhs);
   }
 
   @override
   IrFunction visitRedirectingFactoryConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
       ResolutionDartType redirectionType, // TODO(ahe): Should be InterfaceType.
       ConstructorElement redirectionTarget,
       _) {
@@ skipping 94 matching lines @@
       SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       Node rhs,
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
-    return buildStaticAccessor(getter, setter).buildNullAwareAssignment(
-        visitForValue(rhs), null,
-        voidContext: isVoidContext);
+    return _finishSetIfNull(node, buildStaticAccessor(getter, setter), rhs);
   }
 
   ir.VariableDeclaration getLocal(LocalElement local) {
     return locals.putIfAbsent(local, () {
       // Currently, initializing formals are not final.
       bool isFinal = local.isFinal && !local.isInitializingFormal;
       return associateElement(
           new ir.VariableDeclaration(local.name,
               initializer: null,
               type: typeToIrHack(local.type),
@@ skipping 424 matching lines @@
       SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       Node rhs,
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
-    return buildSuperPropertyAccessor(getter, setter).buildNullAwareAssignment(
-        visitForValue(rhs), null,
-        voidContext: isVoidContext);
+    return _finishSetIfNull(
+        node, buildSuperPropertyAccessor(getter, setter), rhs);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperIndex(
       Send node, FunctionElement function, Node index, _) {
     return buildSuperIndexAccessor(index, function).buildSimpleRead();
   }
 
   @override
   ir.Expression visitSuperIndexPostfix(Send node, MethodElement indexFunction,
@@ skipping 206 matching lines @@
   @override
   ir.Expression visitTypeVariableTypeLiteralSet(
       SendSet node, TypeVariableElement element, Node rhs, _) {
     return new ReadOnlyAccessor(buildTypeVariable(element))
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitTypeVariableTypeLiteralSetIfNull(
       Send node, TypeVariableElement element, Node rhs, _) {
-    return new ReadOnlyAccessor(buildTypeVariable(element))
-        .buildNullAwareAssignment(visitForValue(rhs), null,
-            voidContext: isVoidContext);
+    return _finishSetIfNull(
+        node, new ReadOnlyAccessor(buildTypeVariable(element)), rhs);
   }
 
   @override
   ir.TypeLiteral visitTypedefTypeLiteralGet(
       Send node, ConstantExpression constant, _) {
     return buildTypeLiteral(constant);
   }
 
   @override
   ir.MethodInvocation visitTypedefTypeLiteralInvoke(
@@ skipping 43 matching lines @@
 
   @override
   visitForIn(ForIn node) {
     // Shouldn't be called, handled by [visitAsyncForIn] or [visitSyncForIn].
     return internalError(node, "ForIn");
   }
 
   @override
   ir.Expression visitIndexSetIfNull(
       SendSet node, Node receiver, Node index, Node rhs, _) {
-    return buildIndexAccessor(receiver, index).buildNullAwareAssignment(
-        visitForValue(rhs), null,
-        voidContext: isVoidContext);
+    return _finishSetIfNull(node, buildIndexAccessor(receiver, index), rhs);
   }
 
   @override
   ir.Expression visitSuperIndexSetIfNull(SendSet node, MethodElement getter,
       MethodElement setter, Node index, Node rhs, _) {
-    return buildSuperIndexAccessor(index, getter, setter)
-        .buildNullAwareAssignment(visitForValue(rhs), null,
-            voidContext: isVoidContext);
+    return _finishSetIfNull(
+        node, buildSuperIndexAccessor(index, getter, setter), rhs);
   }
 
   @override
   ir.Node visitVariableDefinitions(VariableDefinitions definitions) {
     // TODO(ahe): This method is copied from [SemanticDeclarationResolvedMixin]
     // and modified. Perhaps we can find a way to avoid code duplication.
     List<ir.VariableDeclaration> variables = <ir.VariableDeclaration>[];
     computeVariableStructures(definitions,
         (Node node, VariableStructure structure) {
       if (structure == null) {
@@ skipping 78 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }