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:     builder.unnest();
    }
  
    visitInstanceCreationExpression(InstanceCreationExpression node) {
      builder.startSpan();
      token(node.keyword);
  
negative.code:     if (node.target is MethodInvocation) builder.unnest();
    }
  
    /// Whether a cascade should be allowed to be inline as opposed to one
    /// expression per line.
    bool _allowInlineCascade(List<Expression> sections) {
      if (sections.length < 2) return true;
  
      var name;
      // We could be more forgiving about what constitutes sections with
      // consistent names but for now we require all sections to have the same
      // method name.
      for (var expression in sections) {
        if (expression is MethodInvocation) {
          if (name == null) {
            name = expression.methodName.name;
          } else if (name != expression.methodName.name) {
            return false;
          }
        } else {
          return false;
        }
      }
      return true;
    }
  
    visitCatchClause(CatchClause node) {
      token(node.onKeyword, after: space);
      visit(node.exceptionType);
  