anchor.diff:      builder = new ChunkBuilder(_formatter, _source);
     }
   
  +  /// Marks the collection literal that starts with [leftBracket] as being
  +  /// controlled by [argumentList].
  +  ///
  +  /// When the collection is visited, [argumentList] will determine the
  +  /// indentation and splitting rule for the collection.
  +  void beforeCollection(Token leftBracket, ArgumentSublist argumentList) {
  +    _collectionArgumentLists[leftBracket] = argumentList;
  +  }
  +
  +  /// Visit the index part of [node], excluding the target.
  +  ///
  +  /// Called by [CallChainVisitor] to handle index expressions in the middle of
  +  /// call chains.
  +  void finishIndexExpression(IndexExpression node) {
  +    if (node.target is IndexExpression) {
  +      // Edge case: On a chain of [] accesses, allow splitting between them.
  +      // Produces nicer output in cases like:
  +      //
  +      //     someJson['property']['property']['property']['property']...
  +      soloZeroSplit();
  +    }
  +
  +    builder.startSpan();
  +    token(node.leftBracket);
  +    soloZeroSplit();
  +    visit(node.index);
  +    token(node.rightBracket);
  +    builder.endSpan();
  +  }
  +
  +  /// Emit the given [modifier] if it's non null, followed by non-breaking
  +  /// whitespace.
  +  void modifier(Token modifier) {
  +    token(modifier, after: space);
  +  }
  +
  +  /// Emit a single mandatory newline.
  +  void newline() {
  +    builder.writeWhitespace(Whitespace.newline);
  +  }
  +
  +  /// Allow either one or two newlines to be emitted before the next
  +  /// non-whitespace token based on whether more than one newline exists in the
  +  /// source between the last token and the next one.
  +  void oneOrTwoNewlines() {
  +    builder.writeWhitespace(Whitespace.oneOrTwoNewlines);
  +  }
  +
     /// Runs the visitor on [node], formatting its contents.
     ///
     /// Returns a [SourceCode] containing the resulting formatted source and
  
positive.code:     token(node.separator);
      soloSplit();
      visit(node.value);
    }
  
    visitMethodDeclaration(MethodDeclaration node) {
  
negative.code: 
      // Finish writing and return the complete result.
      return builder.end();
    }
  
    /// Writes a single space split with its own rule.
    Rule soloSplit([int cost]) {
      var rule = new Rule(cost);
      builder.startRule(rule);
      split();
      builder.endRule();
      return rule;
    }
  
    /// Writes a zero-space split with its own rule.
    void soloZeroSplit() {
      builder.startRule();
      builder.split();
      builder.endRule();
    }
  
    /// Emit a non-breaking space.
    void space() {
      builder.writeWhitespace(Whitespace.space);
    }
  
    /// Writes a single space split owned by the current rule.
    ///
    /// Returns the chunk the split was applied to.
    Chunk split() => builder.split(space: true);
  
    /// Allow either a single split or newline to be emitted before the next
    /// non-whitespace token based on whether a newline exists in the source
    /// between the last token and the next one.
    void splitOrNewline() {
      builder.writeWhitespace(Whitespace.splitOrNewline);
    }
  
    /// Emit [token], along with any comments and formatted whitespace that comes
    /// before it.
    ///
    /// Does nothing if [token] is `null`. If [before] is given, it will be
    /// executed before the token is outout. Likewise, [after] will be called
    /// after the token is output.
    void token(Token token, {before(), after()}) {
      if (token == null) return;
  
      writePrecedingCommentsAndNewlines(token);
  
      if (before != null) before();
  
      _writeText(token.lexeme, token.offset);
  
      if (after != null) after();
    }
  
    /// Emit a two mandatory newlines.
    void twoNewlines() {
      builder.writeWhitespace(Whitespace.twoNewlines);
    }
  
    /// Visit a [node], and if not null, optionally preceded or followed by the
    /// specified functions.
    void visit(AstNode node, {void before(), void after()}) {
      if (node == null) return;
  
      if (before != null) before();
  
      node.accept(this);
  
      if (after != null) after();
    }
  
    visitAdjacentStrings(AdjacentStrings node) {
  