Kernel: Do not try to use return value of []=

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.
 
 // Note: copied from package:kernel at revision 7346348.
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 library kernel.frontend.accessors;
 
 import 'package:kernel/ast.dart';
 
 abstract class Accessor {
   Expression buildSimpleRead() {
     return _finish(_makeSimpleRead());
   }
 
   /// Returns an assignment to the accessor.
   ///
   /// The returned expression evaluates to the assigned value, unless
   /// [voidContext] is true, in which case it may evaluate to anything.
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return _finish(_makeSimpleWrite(value, voidContext));
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     if (voidContext) {
       return _finish(new ConditionalExpression(buildIsNull(_makeRead()),
-          _makeWrite(value, voidContext), new NullLiteral(), type));
+          _makeWrite(value, false), new NullLiteral(), type));

[ahe, 2017/02/01 14:02:38]

I think this hits more cases than you expect, so I'm not sure this is the right
fix.

Try running:

dart pkg/testing/bin/testing.dart --config=pkg/front_end/test/fasta/testing.json
compile

I think you'll see that you're changing some expectation files.

Do note that I haven't automated running these tests yet, and they're not up to
date, so you need to run the tests with and without your changes.

[kustermann, 2017/02/01 14:23:42]

The result of _makeWrite() is used, namely in a ConditionalExpression. So it
cannot be a void context. The VM will crash, because the _makeWrite() results in
caling []=() and the return value *is used*.

So why is this not a correct change?

There might be more such things, but I'm not claiming that I found all of them.
The same tests fail with and without this CL, namely:


12 failed:
compile/parser/parser_suite: Fail
compile/rasta/bad_constructor_redirection: Pass
compile/rasta/bad_explicit_super_constructor: Pass
compile/rasta/for_loop: Pass
compile/rasta/issue_000053: Pass
compile/rasta/issue_000068: Pass
compile/rasta/issue_000070: Pass
compile/rasta/malformed_function_type: Pass
compile/rasta/switch_execution_case_t02: Pass
compile/rasta/switch_fall_through: Pass
compile/rasta/try_label: Pass
compile/scanner/scanner_suite: Fail


Though it's quite difficult finding out if they fail the same way, because the
output of running this command is *huge*.

[ahe, 2017/02/01 14:33:16]

I was wrong. Thank's for clarifying.
Yes. I'm working on that right now.

     }
     var tmp = new VariableDeclaration.forValue(_makeRead());
     return _finish(makeLet(
         tmp,
         new ConditionalExpression(buildIsNull(new VariableGet(tmp)),
-            _makeWrite(value, voidContext), new VariableGet(tmp), type)));
+            _makeWrite(value, false), new VariableGet(tmp), type)));
   }
 
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return _finish(_makeWrite(
         makeBinary(_makeRead(), binaryOperator, interfaceTarget, value),
         voidContext));
   }
 
   Expression buildPrefixIncrement(Name binaryOperator,
@@ skipping 373 matching lines @@
 
 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);
 }
 
 Expression wrapInvalid(Expression e) {
   return new Let(new VariableDeclaration.forValue(e), new InvalidExpression());
 }