dart2js-kernel: Implement Let and PropertySet.

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 1212 matching lines @@
       ir.FunctionExpression function =
           new ir.FunctionExpression(buildFunctionNode(closure, body));
       kernel.localFunctions[closure] = function;
       return function;
     });
   }
 
   @override
   ir.Expression visitCompoundIndexSet(SendSet node, Node receiver, Node index,
       AssignmentOperator operator, Node rhs, _) {
+    // TODO(sra): Find binary operator.
     return buildIndexAccessor(receiver, index).buildCompoundAssignment(
         kernel.irName(operator.selectorName, currentElement),
         visitForValue(rhs),
         voidContext: isVoidContext);
   }
 
   @override
   ir.InvocationExpression visitConstConstructorInvoke(
       NewExpression node, ConstructedConstantExpression constant, _) {
     return buildConstructorInvoke(node, isConst: true);
@@ skipping 39 matching lines @@
         node);
   }
 
   @override
   ir.Expression handleDynamicCompounds(
       Send node, Node receiver, Name name, CompoundRhs rhs, _) {
     ir.Expression receiverNode =
         receiver == null ? new ir.ThisExpression() : visitForValue(receiver);
     ir.Expression compound = buildCompound(
         PropertyAccessor.make(receiverNode, nameToIrName(name), null, null),
-        rhs);
+        rhs,
+        node);
     if (compound is ir.VariableSet) {
       associateNode(compound.value, node);
     } else {
       associateNode(compound, node);
     }
     return compound;
   }
 
   @override
   ir.PropertySet visitDynamicPropertySet(
@@ skipping 410 matching lines @@
 
   ir.VariableGet buildLocalGet(LocalElement local) {
     return new ir.VariableGet(getLocal(local));
   }
 
   @override
   ir.VariableGet handleLocalGet(Send node, LocalElement element, _) {
     return buildLocalGet(element);
   }
 
-  ir.Expression buildCompound(Accessor accessor, CompoundRhs rhs) {
+  ir.Expression buildCompound(Accessor accessor, CompoundRhs rhs,
+                              SendSet node) {
     ir.Name name = kernel.irName(rhs.operator.selectorName, currentElement);
+    ir.Expression result;
     switch (rhs.kind) {
       case CompoundKind.POSTFIX:
-        return accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
+        result = accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
+        break;
 
       case CompoundKind.PREFIX:
-        return accessor.buildPrefixIncrement(name, voidContext: isVoidContext);
+        result = accessor.buildPrefixIncrement(name, voidContext: isVoidContext);
+        break;
 
       case CompoundKind.ASSIGNMENT:
-        return accessor.buildCompoundAssignment(name, visitForValue(rhs.rhs),
-            voidContext: isVoidContext);
+        result = accessor.buildCompoundAssignment(name, visitForValue(rhs.rhs),
+                                                  voidContext: isVoidContext);
+        break;
     }
+    assert(accessor.builtBinary != null);
+    kernel.nodeToAstOperator[accessor.builtBinary] = node;
+    if (accessor.builtGetter != null) {
+      kernel.nodeToAst[accessor.builtGetter] = node;
+    }
+    return result;
   }
 
   @override
   ir.Expression handleLocalCompounds(
       SendSet node, LocalElement local, CompoundRhs rhs, _,
       {bool isSetterValid}) {
     ir.Expression compound =
-        buildCompound(new VariableAccessor(getLocal(local)), rhs);
+        buildCompound(new VariableAccessor(getLocal(local)), rhs, node);
     if (compound is ir.VariableSet) {
       associateNode(compound.value, node);
     } else {
       associateNode(compound, node);
     }
     return compound;
   }
 
   @override
   ir.VariableSet handleLocalSet(
@@ skipping 475 matching lines @@
 
   @override
   ir.Expression visitSuperCompoundIndexSet(
       SendSet node,
       MethodElement getter,
       MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
+    // TODO(sra): Find binary operator.
     return buildSuperIndexAccessor(index, getter, setter)
         .buildCompoundAssignment(
             kernel.irName(operator.selectorName, currentElement),
             visitForValue(rhs),
             voidContext: isVoidContext);
   }
 
   @override
   ir.Initializer visitSuperConstructorInvoke(
       Send node,
@@ skipping 31 matching lines @@
       SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
-    return buildCompound(buildSuperPropertyAccessor(getter, setter), rhs);
+    return buildCompound(buildSuperPropertyAccessor(getter, setter), rhs, node);
   }
 
   @override
   ir.Expression handleStaticCompounds(
       SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
-    return buildCompound(buildStaticAccessor(getter, setter), rhs);
+    return buildCompound(buildStaticAccessor(getter, setter), rhs, node);
   }
 
   @override
   ir.Expression handleTypeLiteralConstantCompounds(
       SendSet node, ConstantExpression constant, CompoundRhs rhs, _) {
-    return buildCompound(new ReadOnlyAccessor(buildTypeLiteral(constant)), rhs);
+    return buildCompound(new ReadOnlyAccessor(buildTypeLiteral(constant)), rhs, node);

[asgerf, 2016/11/24 09:44:32]

long line

[sra1, 2016/11/24 23:53:52]

Done.

   }
 
   ir.TypeLiteral buildTypeVariable(TypeVariableElement element) {
     return new ir.TypeLiteral(kernel.typeToIr(element.type));
   }
 
   @override
   ir.Expression handleTypeVariableTypeLiteralCompounds(
       SendSet node, TypeVariableElement element, CompoundRhs rhs, _) {
-    return buildCompound(new ReadOnlyAccessor(buildTypeVariable(element)), rhs);
+    return buildCompound(new ReadOnlyAccessor(buildTypeVariable(element)), rhs, node);

[asgerf, 2016/11/24 09:44:32]

long line

[sra1, 2016/11/24 23:53:52]

Done.

   }
 
   @override
   ir.SuperPropertyGet visitSuperFieldGet(Send node, FieldElement field, _) {
     return buildSuperPropertyAccessor(field).buildSimpleRead();
   }
 
   @override
   ir.MethodInvocation visitSuperFieldInvoke(Send node, FieldElement field,
       NodeList arguments, CallStructure callStructure, _) {
@@ skipping 466 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)";
   }
 }