anchor.diff:      }
     }
   }
  +
  +/// An 'if' element in a map literal.
  +class IfMapEntry extends TreeNode with _FakeMapEntryMixin {
  +  Expression condition;
  +  MapEntry then;
  +  MapEntry otherwise;
  +
  +  IfMapEntry(this.condition, this.then, this.otherwise) {
  +    condition?.parent = this;
  +    then?.parent = this;
  +    otherwise?.parent = this;
  +  }
  +
  +  @override
  +  visitChildren(Visitor<Object> v) {
  +    condition?.accept(v);
  +    then?.accept(v);
  +    otherwise?.accept(v);
  +  }
  +
  +  @override
  +  transformChildren(Transformer v) {
  +    if (condition != null) {
  +      condition = condition.accept(v);
  +      condition?.parent = this;
  +    }
  +    if (then != null) {
  +      then = then.accept(v);
  +      then?.parent = this;
  +    }
  +    if (otherwise != null) {
  +      otherwise = otherwise.accept(v);
  +      otherwise?.parent = this;
  +    }
  +  }
  +}
  +
  +/// A 'for' element in a map literal.
  +class ForMapEntry extends TreeNode with _FakeMapEntryMixin {
  +  final List<VariableDeclaration> variables; // May be empty, but not null.
  +  Expression condition; // May be null.
  +  final List<Expression> updates; // May be empty, but not null.
  +  MapEntry body;
  +
  +  ForMapEntry(this.variables, this.condition, this.updates, this.body) {
  +    setParents(variables, this);
  +    condition?.parent = this;
  +    setParents(updates, this);
  +    body?.parent = this;
  +  }
  +
  +  @override
  +  visitChildren(Visitor<Object> v) {
  +    visitList(variables, v);
  +    condition?.accept(v);
  +    visitList(updates, v);
  +    body?.accept(v);
  +  }
  +
  +  @override
  +  transformChildren(Transformer v) {
  +    transformList(variables, v, this);
  +    if (condition != null) {
  +      condition = condition.accept(v);
  +      condition?.parent = this;
  +    }
  +    transformList(updates, v, this);
  +    if (body != null) {
  +      body = body.accept(v);
  +      body?.parent = this;
  +    }
  +  }
  +}
  +
  +/// A 'for-in' element in a map literal.
  +class ForInMapEntry extends TreeNode with _FakeMapEntryMixin {
  +  VariableDeclaration variable; // Has no initializer.
  +  Expression iterable;
  +  MapEntry body;
  +  bool isAsync; // True if this is an 'await for' loop.
  +
  +  ForInMapEntry(this.variable, this.iterable, this.body,
  +      {this.isAsync: false}) {
  +    variable?.parent = this;
  +    iterable?.parent = this;
  +    body?.parent = this;
  +  }
  +
  +  visitChildren(Visitor<Object> v) {
  +    variable?.accept(v);
  +    iterable?.accept(v);
  +    body?.accept(v);
  +  }
  +
  +  transformChildren(Transformer v) {
  +    if (variable != null) {
  +      variable = variable.accept(v);
  +      variable?.parent = this;
  +    }
  +    if (iterable != null) {
  +      iterable = iterable.accept(v);
  +      iterable?.parent = this;
  +    }
  +    if (body != null) {
  +      body = body.accept(v);
  +      body?.parent = this;
  +    }
  +  }
  +}
  
positive.code: 
  import '../problems.dart' show getFileUri, unsupported;
  
  /// A spread element in a list or set literal.
  ///
  /// Spread elements are not truly expressions and they cannot appear in
  /// arbitrary expression contexts in the Kernel program.  They can only appear
  /// as elements in list or set literals.
  class SpreadElement extends Expression {
    final DartType inferredType = const BottomType();
    Expression expression;
    bool isNullAware;
  
    SpreadElement(this.expression, this.isNullAware) {
      expression?.parent = this;
    }
  
    /// Spread elements are not expressions and do not have a static type.
    @override
    DartType getStaticType(TypeEnvironment types) {
      return unsupported("getStaticType", fileOffset, getFileUri(this));
    }
  
    @override
    accept(ExpressionVisitor<Object> v) => v.defaultExpression(this);
  
    @override
    accept1(ExpressionVisitor1<Object, Object> v, arg) {
      return unsupported("accept1", fileOffset, getFileUri(this));
    }
  
    @override
  
negative.code: import 'dart:core' hide MapEntry;
  
  import 'package:kernel/ast.dart'
      show
          DartType,
          Expression,
          MapEntry,
          setParents,
          transformList,
          TreeNode,
          VariableDeclaration,
          visitList;
  
  import 'package:kernel/type_environment.dart' show TypeEnvironment;
  
  