Complain about assignments to parenthesized expressions.

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;
 
 export 'package:kernel/frontend/accessors.dart' show wrapInvalid;
 
 import 'package:kernel/frontend/accessors.dart'
     show Accessor, buildIsNull, makeLet;
 
 import 'package:kernel/ast.dart';
 
 import '../errors.dart' show internalError;
 
 import '../builder/scope.dart' show AccessErrorBuilder, ProblemBuilder;
 
 import 'package:kernel/frontend/accessors.dart' as kernel
     show
         IndexAccessor,
         NullAwarePropertyAccessor,
         PropertyAccessor,
+        ReadOnlyAccessor,
         StaticAccessor,
         SuperIndexAccessor,
         SuperPropertyAccessor,
         ThisIndexAccessor,
         ThisPropertyAccessor,
         VariableAccessor;
 
 import 'kernel_builder.dart'
     show Builder, KernelClassBuilder, PrefixBuilder, TypeDeclarationBuilder;
 
@@ skipping 735 matching lines @@
   Expression doInvocation(int offset, Arguments arguments) {
     // 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 buildMethodInvocation(buildSimpleRead(), callName, arguments,
         offset + (variable.name?.length ?? 0));
   }
 
   toString() => "VariableAccessor()";
 }
 
+class ReadOnlyAccessor extends kernel.ReadOnlyAccessor with FastaAccessor {
+  final BuilderHelper helper;
+
+  final String plainNameForRead;
+
+  ReadOnlyAccessor(
+      this.helper, Expression expression, this.plainNameForRead, int offset)
+      : super(expression, offset);
+
+  Expression doInvocation(int offset, Arguments arguments) {
+    return buildMethodInvocation(
+        buildSimpleRead(), callName, arguments, offset);
+  }
+}
+
+class ParenthesizedExpression extends ReadOnlyAccessor {
+  ParenthesizedExpression(
+      BuilderHelper helper, Expression expression, int offset)
+      : super(helper, expression, "<a parenthesized expression>", offset);
+
+  Expression makeInvalidWrite(Expression value) {
+    return helper.buildCompileTimeError(
+        "Can't assign to a parenthesized expression.", offset);
+  }
+}
+
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }
 
 Expression buildMethodInvocation(
     Expression receiver, Name name, Arguments arguments, int offset,
     {bool isNullAware: false}) {
   if (isNullAware) {
     VariableDeclaration variable = new VariableDeclaration.forValue(receiver);
     return makeLet(
         variable,
         new ConditionalExpression(
             buildIsNull(new VariableGet(variable)),
             new NullLiteral(),
             new MethodInvocation(new VariableGet(variable), name, arguments)
               ..fileOffset = offset,
             const DynamicType()));
   } else {
     return new MethodInvocation(receiver, name, arguments)..fileOffset = offset;
   }
 }