anchor.diff:      });
     }
   
  +  /// Visit a comma-separated list of [nodes] if not null.
  +  void visitCommaSeparatedNodes(Iterable<AstNode> nodes, {between()}) {
  +    if (nodes == null || nodes.isEmpty) return;
  +
  +    if (between == null) between = space;
  +
  +    var first = true;
  +    for (var node in nodes) {
  +      if (!first) between();
  +      first = false;
  +
  +      visit(node);
  +
  +      // The comma after the node.
  +      if (node.endToken.next.lexeme == ",") token(node.endToken.next);
  +    }
  +  }
  +
     visitComment(Comment node) => null;
   
     visitCommentReference(CommentReference node) => null;
  
positive.code: 
      // Finish writing and return the complete result.
      return builder.end();
    }
  
    visitAdjacentStrings(AdjacentStrings node) {
  
negative.code:     });
    }
  
    /// Visit a list of [nodes] if not null, optionally separated and/or preceded
    /// and followed by the given functions.
    void visitNodes(Iterable<AstNode> nodes, {before(), between(), after()}) {
      if (nodes == null || nodes.isEmpty) return;
  
      if (before != null) before();
  
      visit(nodes.first);
      for (var node in nodes.skip(1)) {
        if (between != null) between();
        visit(node);
      }
  
      if (after != null) after();
    }
  
    visitNullLiteral(NullLiteral node) {
      token(node.literal);
    }
  
    /// Visits metadata annotations on parameters and type parameters.
    ///
    /// Unlike other annotations, these are allowed to stay on the same line as
    /// the parameter.
    void visitParameterMetadata(
        NodeList<Annotation> metadata, void visitParameter()) {
      if (metadata == null || metadata.isEmpty) {
        visitParameter();
        return;
      }
  
      // Split before all of the annotations or none.
      builder.startLazyRule(_metadataRules.last);
  
      visitNodes(metadata, between: split, after: () {
        // Don't nest until right before the last metadata. Ensures we only
        // indent the parameter and not any of the metadata:
        //
        //     function(
        //         @LongAnnotation
        //         @LongAnnotation
        //             indentedParameter) {}
        builder.nestExpression(now: true);
        split();
      });
      visitParameter();
  
      builder.unnest();
  
      // Wrap the rule around the parameter too. If it splits, we want to force
      // the annotations to split as well.
      builder.endRule();
    }
  
    visitParenthesizedExpression(ParenthesizedExpression node) {
  