Track void context.

lib/kernel_visitor.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.md file.
 
 library rasta.kernel_visitor;
 
 import 'package:kernel/ast.dart' as ir;
 
 import 'package:kernel/accessors.dart' show
     Accessor,
@@ skipping 205 matching lines @@
 
   final Map<JumpTarget, ir.LabeledStatement> breakTargets =
       <JumpTarget, ir.LabeledStatement>{};
 
   final Map<LocalElement, ir.VariableDeclaration> locals =
       <LocalElement, ir.VariableDeclaration>{};
 
   final Map<CascadeReceiver, ir.VariableGet> cascadeReceivers =
       <CascadeReceiver, ir.VariableGet>{};
 
+  bool isVoidContext = false;
+
   KernelVisitor(this.currentElement, this.elements, this.kernel);
 
   KernelVisitor get sendVisitor => this;
 
   KernelVisitor get declVisitor => this;
 
-  ir.TreeNode visitForValue(Expression node) => node?.accept(this);
+  ir.TreeNode visitForValue(Expression node) {
+    bool wasVoidContext = isVoidContext;
+    isVoidContext = false;
+    try {
+      return node?.accept(this);
+    } finally {
+      isVoidContext = wasVoidContext;
+    }
+  }
+
+  ir.TreeNode visitForEffect(Expression node) {
+    bool wasVoidContext = isVoidContext;
+    isVoidContext = true;
+    try {
+      return node?.accept(this);
+    } finally {
+      isVoidContext = wasVoidContext;
+    }
+  }
+
+  ir.TreeNode visitWithCurrentContext(Expression node) => node?.accept(this);
 
   withCurrentElement(AstElement element, f()) {
     assert(element.library == kernel.compiler.currentElement.library);
     Element previousElement = currentElement;
     currentElement = element;
     try {
       return f();
     } finally {
       currentElement = previousElement;
     }
@@ skipping 396 matching lines @@
     // [receiver]. Each [CascadeReceiver] has a getter for [receiverVariable]
     // in [cascadeReceivers].
 
     receiverVariable.initializer = visitForValue(receiver.expression);
     receiverVariable.initializer.parent = receiverVariable;
 
     ir.Expression result = new ir.VariableGet(receiverVariable); // rcv.
     for (Cascade cascade in cascades) {
       // When evaluating `cascade.expression`, we stop the recursion at
       // [visitCascadeReceiver] and instead returns an [ir.VariableGet].
+      // TODO(ahe): Use visitForEffect here?
       ir.Expression value = visitForValue(cascade.expression);
       result = new ir.Let(makeOrReuseVariable(value), result);
     }
 
     assert(startLength == cascadeReceivers.length);
     return new ir.Let(receiverVariable, result);
   }
 
   @override
   ir.VariableGet visitCascadeReceiver(CascadeReceiver node) {
@@ skipping 14 matching lines @@
     ir.DartType guard = computeType(node.type);
     return new ir.Catch(
         exception, buildStatementInBlock(node.block), guard: guard,
         stackTrace: trace);
   }
 
   @override
   ir.ConditionalExpression visitConditional(Conditional node) {
     return new ir.ConditionalExpression(
         visitForValue(node.condition),
-        visitForValue(node.thenExpression),
-        visitForValue(node.elseExpression));
+        visitWithCurrentContext(node.thenExpression),
+        visitWithCurrentContext(node.elseExpression));
   }
 
   @override
   ir.Statement visitContinueStatement(ContinueStatement node) {
     JumpTarget target = elements.getTargetOf(node);
     if (target == null) {
       // This is a continue in an invalid position.
       return new ir.InvalidStatement();
     }
     ir.SwitchCase switchCase = getContinueSwitchTarget(target);
@@ skipping 24 matching lines @@
     return new ir.EmptyStatement();
   }
 
   @override
   ir.Throw visitEnum(Enum node) {
     return buildUnsupported(node, "Enum");
   }
 
   @override
   ir.ExpressionStatement visitExpressionStatement(ExpressionStatement node) {
-    return new ir.ExpressionStatement(visitForValue(node.expression));
+    return new ir.ExpressionStatement(visitForEffect(node.expression));
   }
 
   @override
   ir.Statement visitFor(For node) {
     VariableDefinitions initializers =
         node.initializer?.asVariableDefinitions();
     ir.Expression initializer;
     List<ir.VariableDeclaration> variables;
     if (initializers != null) {
       ir.Block block = buildStatementInBlock(initializers, forceBlock: true);
       variables = new List<ir.VariableDeclaration>.from(block.statements);
     } else {
       if (node.initializer != null) {
         initializer = visitForValue(node.initializer);
       }
       variables = const <ir.VariableDeclaration>[];
     }
     ir.Expression condition = visitForValue(node.condition);
     List<ir.Expression> updates = <ir.Expression>[];
     for (Expression update in node.update) {
-      updates.add(visitForValue(update));
+      updates.add(visitForEffect(update));
     }
 
     JumpTarget jumpTarget = elements.getTargetDefinition(node);
     ir.Statement body = buildContinueTarget(
         buildStatementInBlock(node.body), node, jumpTarget);
     ir.ForStatement forStatement = new ir.ForStatement(
         variables, condition, updates, body);
     ir.Statement result = buildBreakTarget(forStatement, node, jumpTarget);
     if (initializer != null) {
       result = new ir.Block(<ir.Statement>[
@@ skipping 131 matching lines @@
         node.name.source, visitForValue(node.expression));
   }
 
   @override
   ir.Throw visitOperator(Operator node) {
     return buildUnsupported(node, "Operator");
   }
 
   @override
   ir.Expression visitParenthesizedExpression(ParenthesizedExpression node) {
-    return visitForValue(node.expression);
+    return visitWithCurrentContext(node.expression);
   }
 
   @override
   ir.Throw visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     return buildUnsupported(node, "RedirectingFactoryBody");
   }
 
   @override
   ir.ExpressionStatement visitRethrow(Rethrow node) {
     return new ir.ExpressionStatement(new ir.Rethrow());
@@ skipping 222 matching lines @@
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildCall(buildTypeLiteral(constant), callStructure, arguments);
   }
 
   ir.Expression buildTypeLiteralSet(TypeConstantExpression constant, Node rhs) {
     return new ReadOnlyAccessor(buildTypeLiteral(constant))
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitClassTypeLiteralSet(
       SendSet node,
       ConstantExpression constant,
       Node rhs,
       _) {
     return buildTypeLiteralSet(constant, rhs);
   }
@@ skipping 12 matching lines @@
   @override
   ir.Expression visitCompoundIndexSet(
       SendSet node,
       Node receiver,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
     return buildIndexAccessor(receiver, index).buildCompoundAssignment(
         kernel.irName(operator.selectorName, currentElement),
-        visitForValue(rhs));
+        visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitConstConstructorInvoke(
       NewExpression node,
       ConstructedConstantExpression constant,
       _) {
     return buildConstConstructorInvoke(node);
   }
 
@@ skipping 73 matching lines @@
   ir.Expression handleDynamicSetIfNulls(
       Send node,
       Node receiver,
       Name name,
       Node rhs,
       _) {
     ir.Name irName = kernel.nameToIrName(name);
     Accessor accessor = (receiver == null)
         ? new ThisPropertyAccessor(irName)
         : PropertyAccessor.make(visitForValue(receiver), irName);
-    return accessor.buildNullAwareAssignment(visitForValue(rhs));
+    return accessor.buildNullAwareAssignment(
+        visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.TypeLiteral visitDynamicTypeLiteralGet(
       Send node,
       ConstantExpression constant,
       _) {
     return buildTypeLiteral(constant);
   }
 
@@ skipping 68 matching lines @@
       _) {
     if (kernel.isSyntheticError(field)) {
       return new ir.InvalidInitializer();
     } else {
       return new ir.FieldInitializer(
           kernel.fieldToIr(field), visitForValue(expression));
     }
   }
 
   ir.Expression buildStaticFieldSet(FieldElement field, Node rhs) {
-    return buildStaticAccessor(field).buildAssignment(visitForValue(rhs));
+    return buildStaticAccessor(field)
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression handleFinalStaticFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       _) {
     return buildStaticFieldSet(field, rhs);
   }
 
   @override
   ir.Expression visitFinalSuperFieldSet(
       SendSet node, FieldElement field, Node rhs, _) {
     return buildSuperPropertyAccessor(field)
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   void addFieldsWithInitializers(
       ConstructorElement constructor,
       List<ir.Initializer> initializers) {
     constructor.enclosingClass.forEachInstanceField((_, FieldElement element) {
       // Convert the element into the corresponding IR field before asking
       // if the initializer exists. This is necessary to ensure that the
       // element has been analyzed before looking at its initializer.
       ir.Field field = kernel.fieldToIr(element);
@@ skipping 162 matching lines @@
   }
 
   @override
   ir.Expression visitIfNotNullDynamicPropertySet(
       SendSet node,
       Node receiver,
       Name name,
       Node rhs,
       _) {
     return buildNullAwarePropertyAccessor(receiver, name).buildAssignment(
-        visitForValue(rhs));
+        visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Throw visitIfNotNullDynamicPropertySetIfNull(
       Send node,
       Node receiver,
       Name name,
       Node rhs,
       _) {
     return buildNullAwarePropertyAccessor(receiver, name)
-        .buildNullAwareAssignment(visitForValue(rhs));
+        .buildNullAwareAssignment(
+            visitForValue(rhs), voidContext: isVoidContext);
   }
 
   ir.LogicalExpression buildLogicalExpression(
       Node left,
       Operator operator,
       Node right) {
     return new ir.LogicalExpression(
         visitForValue(left), operator.source, visitForValue(right));
   }
 
@@ skipping 23 matching lines @@
 
   @override
   ir.Expression visitIndex(Send node, Node receiver, Node index, _) {
     return buildIndexAccessor(receiver, index).buildSimpleRead();
   }
 
   ir.Expression buildIndexPostfix(
       Accessor accessor,
       IncDecOperator operator) {
     ir.Name name = kernel.irName(operator.selectorName, currentElement);
-    return accessor.buildPostfixIncrement(name);
+    return accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitIndexPostfix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       _) {
     return buildIndexPostfix(buildIndexAccessor(receiver, index), operator);
   }
 
   ir.Expression buildIndexPrefix(Accessor accessor, IncDecOperator operator) {
     ir.Name name = kernel.irName(operator.selectorName, currentElement);
-    return accessor.buildPrefixIncrement(name);
+    return accessor.buildPrefixIncrement(name, voidContext: isVoidContext);
   }
 
 
   @override
   ir.Expression visitIndexPrefix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       _) {
     return buildIndexPrefix(buildIndexAccessor(receiver, index), operator);
   }
 
   @override
   ir.Expression visitIndexSet(
       SendSet node, Node receiver, Node index, Node rhs, _) {
     return buildIndexAccessor(receiver, index)
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   ir.Initializer buildInitializingFormal(InitializingFormalElement parameter) {
     FieldElement field = parameter.fieldElement;
     if (kernel.isSyntheticError(field)) {
       return new ir.InvalidInitializer();
     } else {
       return new ir.FieldInitializer(
           kernel.fieldToIr(field), buildLocalGet(parameter));
     }
@@ skipping 117 matching lines @@
 
   @override
   ir.VariableGet handleLocalGet(Send node, LocalElement element, _) {
     return buildLocalGet(element);
   }
 
   ir.Expression buildCompound(Accessor accessor, CompoundRhs rhs) {
     ir.Name name = kernel.irName(rhs.operator.selectorName, currentElement);
     switch (rhs.kind) {
       case CompoundKind.POSTFIX:
-        return accessor.buildPostfixIncrement(name);
+        return accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
 
       case CompoundKind.PREFIX:
-        return accessor.buildPrefixIncrement(name);
+        return accessor.buildPrefixIncrement(name, voidContext: isVoidContext);
 
       case CompoundKind.ASSIGNMENT:
-        return accessor.buildCompoundAssignment(name, visitForValue(rhs.rhs));
+        return accessor.buildCompoundAssignment(
+            name, visitForValue(rhs.rhs), voidContext: isVoidContext);
     }
   }
 
   @override
   ir.Expression handleLocalCompounds(
       SendSet node,
       LocalElement local,
       CompoundRhs rhs,
       _,
       {bool isSetterValid}) {
@@ skipping 102 matching lines @@
   }
 
   @override
   ir.Expression handleLocalSetIfNulls(
       SendSet node,
       LocalElement local,
       Node rhs,
       _,
       {bool isSetterValid}) {
     return new VariableAccessor(getLocal(local))
-        .buildNullAwareAssignment(visitForValue(rhs));
+        .buildNullAwareAssignment(
+            visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   IrFunction visitRedirectingFactoryConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
       DartType redirectionType, // TODO(ahe): Should be InterfaceType.
       ConstructorElement redirectionTarget,
       _) {
@@ skipping 118 matching lines @@
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       Node rhs,
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
     return buildStaticAccessor(getter, setter)
-        .buildNullAwareAssignment(visitForValue(rhs));
+        .buildNullAwareAssignment(
+            visitForValue(rhs), voidContext: isVoidContext);
   }
 
   ir.VariableDeclaration getLocal(LocalElement local) {
     return locals.putIfAbsent(local, () {
       return new ir.VariableDeclaration(
           local.name, initializer: null, type: typeToIrHack(local.type),
           isFinal: local.isFinal, isConst: local.isConst);
     });
   }
 
@@ skipping 140 matching lines @@
       _) {
     return buildStaticInvoke(function, arguments, isConst: false);
   }
 
   @override
   ir.Expression handleStaticFunctionSet(
       Send node,
       MethodElement function,
       Node rhs,
       _) {
-    return buildStaticAccessor(function).buildAssignment(visitForValue(rhs));
+    return buildStaticAccessor(function)
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   IrFunction visitStaticGetterDeclaration(
       FunctionExpression node,
       MethodElement getter,
       Node body,
       _) {
     return buildIrFunction(ir.ProcedureKind.Getter, getter, body);
   }
@@ skipping 21 matching lines @@
     }
     return buildCall(buildStaticGet(getter), callStructure, arguments);
   }
 
   @override
   ir.Expression handleStaticGetterSet(
       SendSet node,
       FunctionElement getter,
       Node rhs,
       _) {
-    return buildStaticAccessor(getter).buildAssignment(visitForValue(rhs));
+    return buildStaticAccessor(getter)
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   IrFunction visitStaticSetterDeclaration(
       FunctionExpression node,
       MethodElement setter,
       NodeList parameters,
       Node body,
       _) {
     return buildIrFunction(ir.ProcedureKind.Setter, setter, body);
@@ skipping 13 matching lines @@
       _) {
     return buildCall(
         buildStaticAccessor(null, setter).buildSimpleRead(),
         callStructure, arguments);
   }
 
   @override
   ir.Expression handleStaticSetterSet(
       SendSet node, FunctionElement setter, Node rhs, _) {
     return buildStaticAccessor(null, setter)
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitStringFromEnvironmentConstructorInvoke(
       NewExpression node,
       StringFromEnvironmentConstantExpression constant,
       _) {
     return buildConstConstructorInvoke(node);
   }
 
@@ skipping 14 matching lines @@
       SendSet node,
       MethodElement getter,
       MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
     return
         buildSuperIndexAccessor(index, getter, setter).buildCompoundAssignment(
             kernel.irName(operator.selectorName, currentElement),
-            visitForValue(rhs));
+            visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Initializer visitSuperConstructorInvoke(
       Send node,
       ConstructorElement superConstructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
@@ skipping 88 matching lines @@
       _) {
     return buildCall(
         buildSuperPropertyAccessor(field).buildSimpleRead(),
         callStructure, arguments);
   }
 
   @override
   ir.Expression visitSuperFieldSet(
       SendSet node, FieldElement field, Node rhs, _) {
     return buildSuperPropertyAccessor(field)
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   Accessor buildSuperPropertyAccessor(Element getter, [Element setter]) {
     if (setter == null && getter.isField && !getter.isFinal &&
         !getter.isConst) {
       setter = getter;
     }
     return new SuperPropertyAccessor(
         (getter == null) ? null : kernel.elementToIr(getter),
         (setter == null) ? null : kernel.elementToIr(setter));
@@ skipping 30 matching lines @@
       _) {
     return buildCall(
         buildSuperPropertyAccessor(getter).buildSimpleRead(),
         callStructure, arguments);
   }
 
   @override
   ir.Expression visitSuperGetterSet(
       SendSet node, FunctionElement getter, Node rhs, _) {
     return buildSuperPropertyAccessor(getter)
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression handleSuperSetIfNulls(
       SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       Node rhs,
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
     return buildSuperPropertyAccessor(getter, setter)
-        .buildNullAwareAssignment(visitForValue(rhs));
+        .buildNullAwareAssignment(
+            visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperIndex(
       Send node, FunctionElement function, Node index, _) {
     return buildSuperIndexAccessor(index, function).buildSimpleRead();
   }
 
   @override
   ir.Expression visitSuperIndexPostfix(
@@ skipping 22 matching lines @@
   }
 
   @override
   ir.Expression visitSuperIndexSet(
       SendSet node,
       FunctionElement function,
       Node index,
       Node rhs,
       _) {
     return buildSuperIndexAccessor(index, null, function)
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitSuperMethodGet(Send node, MethodElement method, _) {
     return buildSuperPropertyAccessor(method).buildSimpleRead();
   }
 
   ir.SuperMethodInvocation buildSuperMethodInvoke(
       MethodElement method,
       NodeList arguments) {
@@ skipping 18 matching lines @@
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildSuperMethodInvoke(method, arguments);
   }
 
   @override
   ir.Expression visitSuperMethodSet(
       Send node, MethodElement method, Node rhs, _) {
     return buildSuperPropertyAccessor(method)
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Not visitSuperNotEquals(
       Send node,
       FunctionElement function,
       Node argument,
       _) {
     return new ir.Not(buildSuperEquals(function, argument));
   }
@@ skipping 15 matching lines @@
       _) {
     return buildCall(
         buildSuperPropertyAccessor(null, setter).buildSimpleRead(),
         callStructure, arguments);
   }
 
   @override
   ir.Expression visitSuperSetterSet(
       SendSet node, FunctionElement setter, Node rhs, _) {
     return buildSuperPropertyAccessor(null, setter)
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperUnary(
       Send node,
       UnaryOperator operator,
       FunctionElement function,
       _) {
     return new ir.SuperMethodInvocation(
         kernel.functionToIr(function), new ir.Arguments.empty());
@@ skipping 42 matching lines @@
       Send node,
       NodeList arguments,
       Selector selector,
       _) {
     return buildInvokeSelector(
         new ir.ThisExpression(), selector, buildArguments(arguments));
   }
 
   @override
   ir.Expression visitThisPropertySet(SendSet node, Name name, Node rhs, _) {
-    return buildThisPropertyAccessor(name).buildAssignment(visitForValue(rhs));
+    return buildThisPropertyAccessor(name)
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Throw visitTopLevelConstantDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       ConstantExpression constant,
       _) {
     return buildUnsupported(node, "TopLevelConstantDeclaration");
@@ skipping 71 matching lines @@
     return buildCall(buildTypeVariable(element), callStructure, arguments);
   }
 
   @override
   ir.Expression visitTypeVariableTypeLiteralSet(
       SendSet node,
       TypeVariableElement element,
       Node rhs,
       _) {
     return new ReadOnlyAccessor(buildTypeVariable(element))
-        .buildAssignment(visitForValue(rhs));
+        .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitTypeVariableTypeLiteralSetIfNull(
       Send node,
       TypeVariableElement element,
       Node rhs,
       _) {
     return new ReadOnlyAccessor(buildTypeVariable(element))
-        .buildNullAwareAssignment(visitForValue(rhs));
+        .buildNullAwareAssignment(
+            visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.TypeLiteral visitTypedefTypeLiteralGet(
       Send node,
       ConstantExpression constant,
       _) {
     return buildTypeLiteral(constant);
   }
 
@@ skipping 50 matching lines @@
   @override
   ir.Throw visitForIn(ForIn node) {
     return internalError(
         node, "Should have been caught by visitAsyncForIn or visitSyncForIn");
   }
 
   @override
   ir.Expression visitIndexSetIfNull(
       SendSet node, Node receiver, Node index, Node rhs, _) {
     return buildIndexAccessor(receiver, index)
-        .buildNullAwareAssignment(visitForValue(rhs));
+        .buildNullAwareAssignment(
+            visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitSuperIndexSetIfNull(
       SendSet node,
       MethodElement getter,
       MethodElement setter,
       Node index,
       Node rhs, _) {
     return buildSuperIndexAccessor(index, getter, setter)
-        .buildNullAwareAssignment(visitForValue(rhs));
+        .buildNullAwareAssignment(
+            visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Node visitVariableDefinitions(VariableDefinitions definitions) {
     // TODO(ahe): This method is copied from [SemanticDeclarationResolvedMixin]
     // and modified. Perhaps we can find a way to avoid code duplication.
     List<ir.VariableDeclaration> variables = <ir.VariableDeclaration>[];
     computeVariableStructures(definitions,
         (Node node, VariableStructure structure) {
       if (structure == null) {
@@ skipping 88 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }