Add type inference for complex assignments whose LHS is an index expression.

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,
+        KernelComplexAssign,
+        KernelConditionalExpression,
         KernelMethodInvocation,
         KernelPropertyGet,
         KernelPropertySet,
+        KernelVariableDeclaration,
         KernelVariableGet,
         KernelVariableSet;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
 import 'package:front_end/src/scanner/token.dart' show Token;
 
 import 'package:front_end/src/fasta/kernel/fasta_accessors.dart'
     show BuilderHelper;
 
@@ skipping 38 matching lines @@
   /// 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,
       {bool voidContext: false}) {
     if (voidContext) {
-      return _finish(new ConditionalExpression(buildIsNull(_makeRead()),
-          _makeWrite(value, false), new NullLiteral(), type));
+      return _finish(new KernelConditionalExpression(
+          buildIsNull(_makeRead()), _makeWrite(value, false), new NullLiteral(),
+          isNullAwareCombiner: true));
     }
     var tmp = new VariableDeclaration.forValue(_makeRead());
     return _finish(makeLet(
         tmp,
-        new ConditionalExpression(buildIsNull(new VariableGet(tmp)),
-            _makeWrite(value, false), new VariableGet(tmp), type)));
+        new KernelConditionalExpression(buildIsNull(new VariableGet(tmp)),
+            _makeWrite(value, false), new VariableGet(tmp),
+            isNullAwareCombiner: true)));
   }
 
   /// 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,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     return _finish(_makeWrite(
         makeBinary(_makeRead(), binaryOperator, interfaceTarget, value,
-            offset: offset),
+            offset: offset, isCombiner: true),
         voidContext));
   }
 
   /// Returns an [Expression] representing a pre-increment or pre-decrement
   /// of the accessor.
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     return buildCompoundAssignment(binaryOperator, new IntLiteral(1),
         offset: offset,
         voidContext: voidContext,
         interfaceTarget: interfaceTarget);
   }
 
   /// Returns an [Expression] representing a post-increment or post-decrement
   /// of the accessor.
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     if (voidContext) {
       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(
-        makeBinary(
-            valueAccess(), binaryOperator, interfaceTarget, new IntLiteral(1),
-            offset: offset),
-        true));
+    var dummy = new KernelVariableDeclaration.forValue(
+        _makeWrite(
+            makeBinary(valueAccess(), binaryOperator, interfaceTarget,
+                new IntLiteral(1),
+                offset: offset, isCombiner: true),
+            true),
+        helper.functionNestingLevel,
+        isDiscarding: true);
     return _finish(makeLet(value, makeLet(dummy, valueAccess())));
   }
 
   Expression _makeSimpleRead() => _makeRead();
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     return _makeWrite(value, voidContext);
   }
 
   Expression _makeRead();
@@ skipping 127 matching lines @@
 
   Expression _makeRead() =>
       new KernelPropertyGet(receiverAccess(), name, getter);
 
   Expression _makeWrite(Expression value, bool voidContext) {
     return new KernelPropertySet(receiverAccess(), name, value, setter);
   }
 
   Expression _finish(Expression body) => makeLet(
       receiver,
-      new ConditionalExpression(
-          buildIsNull(receiverAccess()), new NullLiteral(), body, type));
+      new KernelConditionalExpression(
+          buildIsNull(receiverAccess()), new NullLiteral(), body));
 }
 
 class SuperPropertyAccessor extends Accessor {
   Name name;
   Member getter, setter;
 
   SuperPropertyAccessor(
       BuilderHelper helper, this.name, this.getter, this.setter, Token token)
       : super(helper, token);
 
@@ skipping 74 matching lines @@
         interfaceTarget: setter)
       ..fileOffset = offsetForToken(token);
   }
 
   // TODO(dmitryas): remove this method after the "[]=" operator of the Context
   // class is made to return a value.
   _makeWriteAndReturn(Expression value) {
     // The call to []= does not return the value like direct-style assignments
     // do.  We need to bind the value in a let.
     var valueVariable = new VariableDeclaration.forValue(value);
-    var dummy = new VariableDeclaration.forValue(new KernelMethodInvocation(
-        receiverAccess(),
-        indexSetName,
-        new KernelArguments(
-            <Expression>[indexAccess(), new VariableGet(valueVariable)]),
-        interfaceTarget: setter)
-      ..fileOffset = offsetForToken(token));
+    var dummy = new KernelVariableDeclaration.forValue(
+        new KernelMethodInvocation(
+            receiverAccess(),
+            indexSetName,
+            new KernelArguments(
+                <Expression>[indexAccess(), new VariableGet(valueVariable)]),
+            interfaceTarget: setter)
+          ..fileOffset = offsetForToken(token),
+        helper.functionNestingLevel,
+        isDiscarding: true);
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
   Expression _finish(Expression body) {
-    return makeLet(receiverVariable, makeLet(indexVariable, body));
+    if (receiverVariable == null) {
+      assert(indexVariable == null);
+      return body;
+    } else {
+      return new KernelComplexAssign(
+          receiverVariable, makeLet(indexVariable, body));
+    }
   }
 }
 
 /// Special case of [IndexAccessor] to avoid creating an indirect access to
 /// 'this'.
 class ThisIndexAccessor extends Accessor {
   Expression index;
   VariableDeclaration indexVariable;
   Procedure getter, setter;
 
@@ skipping 135 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,
-    {int offset: TreeNode.noOffset}) {
+    {int offset: TreeNode.noOffset, bool isCombiner: false}) {
   return new KernelMethodInvocation(
       left, operator, new KernelArguments(<Expression>[right]),
-      interfaceTarget: interfaceTarget)
+      interfaceTarget: interfaceTarget, isCombiner: isCombiner)
     ..fileOffset = offset;
 }
 
 Expression buildIsNull(Expression value, {int offset: TreeNode.noOffset}) {
   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);
 }