anchor.diff:    }
   
     @override
  -  JS.Expression visitSetLiteral(SetLiteral node) {
  +  JS.Expression visitSetLiteral(SetLiteral node) =>
  +      _emitSetLiteral(node.elements, node);
  +
  +  // TODO(nshahan) Cleanup after control flow collections experiments are removed.
  +  JS.Expression _emitSetLiteral(
  +      Iterable<CollectionElement> elements, SetOrMapLiteral node) {
       var type = node.staticType as InterfaceType;
       if (!node.isConst) {
         var setType = _emitType(type);
  -      if (node.elements.isEmpty) {
  +      if (elements.isEmpty) {
           return js.call('#.new()', [setType]);
         }
  -      return js
  -          .call('#.from([#])', [setType, _visitExpressionList(node.elements)]);
  +      return js.call(
  +          '#.from([#])', [setType, _visitCollectionElementList(elements)]);
       }
       return _cacheConst(() => runtimeCall('constSet(#, [#])', [
             _emitType((node.staticType as InterfaceType).typeArguments[0]),
  -          _visitExpressionList(node.elements)
  +          _visitCollectionElementList(elements)
           ]));
     }
   
  
positive.code:   }
  
    @override
    visitMapLiteral(MapLiteral node) {
      emitEntries() {
        var entries = <JS.Expression>[];
        for (var e in node.entries) {
          entries.add(_visitExpression(e.key));
          entries.add(_visitExpression(e.value));
        }
        return entries;
      }
  
      var type = node.staticType as InterfaceType;
      if (!node.isConst) {
        var mapType = _emitMapImplType(type);
        if (node.entries.isEmpty) {
          return js.call('new #.new()', [mapType]);
        }
        return js.call('new #.from([#])', [mapType, emitEntries()]);
      }
      return _cacheConst(() => _emitConstMap(type, emitEntries()));
    }
  
    JS.Expression _emitConstMap(InterfaceType type, List<JS.Expression> entries) {
  
negative.code:     return nodes?.map(_visitStatement)?.toList();
    }
  
    /// Visits [nodes] with [_visitColelctionElement].
    List<JS.Expression> _visitCollectionElementList(
        Iterable<CollectionElement> nodes) {
      var expressions = <JS.Expression>[];
      for (var node in nodes) {
        //TODO(nshahan) Handle [IfElement] and [ForElement].
        if (node is MapLiteralEntry) {
          expressions.add(_visitExpression(node.key));
          expressions.add(_visitExpression(node.value));
        } else {
          expressions.add(_visitExpression(node));
        }
      }
      return expressions;
    }
  
    /// Gets the start position of [node] for use in source mapping.
  