Add type inference for assignments to properties.

pkg/front_end/lib/src/fasta/kernel/fasta_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.
 
 library fasta.fasta_accessors;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show
         KernelArguments,
         KernelComplexAssignment,
         KernelIndexAssign,
+        KernelPropertyAssign,
         KernelStaticAssignment,
         KernelThisExpression,
         KernelVariableAssignment;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
 import 'package:front_end/src/scanner/token.dart' show Token;
 
 import 'frontend_accessors.dart' show Accessor;
 
@@ skipping 646 matching lines @@
     if (receiver is ThisExpression) {
       return new ThisPropertyAccessor(helper, token, name, getter, setter);
     } else {
       return isNullAware
           ? new NullAwarePropertyAccessor(
               helper, token, receiver, name, getter, setter, null)
           : new PropertyAccessor.internal(
               helper, token, receiver, name, getter, setter);
     }
   }
+
+  @override
+  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
+      new KernelPropertyAssign(receiver, rhs);
 }
 
 class StaticAccessor extends kernel.StaticAccessor with FastaAccessor {
   StaticAccessor(
       BuilderHelper helper, Token token, Member readTarget, Member writeTarget)
       : super(helper, readTarget, writeTarget, token) {
     assert(readTarget != null || writeTarget != null);
   }
 
   factory StaticAccessor.fromBuilder(BuilderHelper helper, Builder builder,
@@ skipping 77 matching lines @@
 
   Expression makeInvalidWrite(Expression value) {
     return helper.invokeSuperNoSuchMethod(
         plainNameForRead,
         new Arguments(<Expression>[value])..fileOffset = value.fileOffset,
         offsetForToken(token),
         isSetter: true);
   }
 
   toString() => "SuperPropertyAccessor()";
+
+  @override
+  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
+      new KernelPropertyAssign(null, rhs, isSuper: true);
 }
 
 class ThisIndexAccessor extends kernel.ThisIndexAccessor with FastaAccessor {
   ThisIndexAccessor(BuilderHelper helper, Token token, Expression index,
       Procedure getter, Procedure setter)
       : super(helper, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
@@ skipping 42 matching lines @@
     if (interfaceTarget is Field) {
       // TODO(ahe): In strong mode we should probably rewrite this to
       // `this.name.call(arguments)`.
       interfaceTarget = null;
     }
     return helper.buildMethodInvocation(
         new KernelThisExpression(), name, arguments, offset);
   }
 
   toString() => "ThisPropertyAccessor()";
+
+  @override
+  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
+      new KernelPropertyAssign(null, rhs);
 }
 
 class NullAwarePropertyAccessor extends kernel.NullAwarePropertyAccessor
     with FastaAccessor {
   final BuilderHelper helper;
 
   NullAwarePropertyAccessor(this.helper, Token token, Expression receiver,
       Name name, Member getter, Member setter, DartType type)
       : super(helper, receiver, name, getter, setter, type, token);
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     return internalError("Not implemented yet.");
   }
 
   toString() => "NullAwarePropertyAccessor()";
+
+  @override
+  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
+      new KernelPropertyAssign(receiverExpression, rhs);
 }
 
 int adjustForImplicitCall(String name, int offset) {
   // Normally the offset is at the start of the token, but in this case,
   // because we insert a '.call', we want it at the end instead.
   return offset + (name?.length ?? 0);
 }
 
 class VariableAccessor extends kernel.VariableAccessor with FastaAccessor {
   VariableAccessor(
@@ skipping 152 matching lines @@
     offset ??= offsetForToken(this.token);
     return helper.throwNoSuchMethodError(new NullLiteral()..fileOffset = offset,
         plainNameForRead, arguments, offset,
         isGetter: isGetter, isSetter: isSetter);
   }
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }