Add type inference for assignment to local variables.

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 78 matching lines @@
         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,
       bool voidContext: false,
-      Procedure interfaceTarget}) {
+      Procedure interfaceTarget,
+      bool isPreIncDec: false}) {
     var complexAssignment = startComplexAssignment(value);
+    complexAssignment?.isPreIncDec = isPreIncDec;
     var combiner = makeBinary(
         _makeRead(complexAssignment), binaryOperator, interfaceTarget, value,
         offset: offset);
     complexAssignment?.combiner = combiner;
     return _finish(_makeWrite(combiner, voidContext, complexAssignment),
         complexAssignment);
   }
 
   /// 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);
+        interfaceTarget: interfaceTarget,
+        isPreIncDec: true);
   }
 
   /// 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,
@@ skipping 21 matching lines @@
       KernelComplexAssignment complexAssignment) {
     return _makeWrite(value, voidContext, complexAssignment);
   }
 
   Expression _makeRead(KernelComplexAssignment complexAssignment);
 
   Expression _makeWrite(Expression value, bool voidContext,
       KernelComplexAssignment complexAssignment);
 
   Expression _finish(
-          Expression body, KernelComplexAssignment complexAssignment) =>
-      body;
+      Expression body, KernelComplexAssignment complexAssignment) {
+    if (complexAssignment != null) {
+      complexAssignment.desugared = body;
+      return complexAssignment;
+    } else {
+      return body;
+    }
+  }
 
   /// Returns an [Expression] representing a compile-time error.
   ///
   /// At runtime, an exception will be thrown.
   makeInvalidRead() {
     return internalError(
         "Unhandled compile-time error.", null, offsetForToken(token));
   }
 
   /// Returns an [Expression] representing a compile-time error wrapping
@@ skipping 16 matching lines @@
   DartType promotedType;
 
   VariableAccessor(
       BuilderHelper helper, this.variable, this.promotedType, Token token)
       : super(helper, token);
 
   Expression _makeRead(KernelComplexAssignment complexAssignment) {
     var fact = helper.typePromoter
         .getFactForAccess(variable, helper.functionNestingLevel);
     var scope = helper.typePromoter.currentScope;
-    return new KernelVariableGet(variable, fact, scope)
+    var read = new KernelVariableGet(variable, fact, scope)
       ..fileOffset = offsetForToken(token);
+    complexAssignment?.read = read;
+    return read;
   }
 
   Expression _makeWrite(Expression value, bool voidContext,
       KernelComplexAssignment complexAssignment) {
     helper.typePromoter.mutateVariable(variable, helper.functionNestingLevel);
-    return variable.isFinal || variable.isConst
+    var write = variable.isFinal || variable.isConst
         ? makeInvalidWrite(value)
         : new KernelVariableSet(variable, value)
       ..fileOffset = offsetForToken(token);
+    complexAssignment?.write = write;
+    return write;
   }
 }
 
 class PropertyAccessor extends Accessor {
   VariableDeclaration _receiverVariable;
   Expression receiver;
   Name name;
   Member getter, setter;
 
   static Accessor make(BuilderHelper helper, Expression receiver, Name name,
@@ skipping 397 matching lines @@
 
 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);
 }