anchor.diff:  
     @override
     void visitListLiteral(ListLiteral node) {
  -    safelyVisitTokenWithSuffix(node.constKeyword, ' ');
  -    safelyVisitNode(node.typeArguments);
  +    _visitToken(node.constKeyword, suffix: ' ');
  +    _visitNode(node.typeArguments);
       sink.write('[');
  -    safelyVisitNodeListWithSeparator(node.elements, ', ');
  +    _visitNodeList(node.elements, separator: ', ');
       sink.write(']');
     }
   
     @override
     void visitMapLiteralEntry(MapLiteralEntry node) {
  -    safelyVisitNode(node.key);
  -    sink.write(" : ");
  -    safelyVisitNode(node.value);
  +    _visitNode(node.key);
  +    sink.write(' : ');
  +    _visitNode(node.value);
     }
   
     @override
     void visitMethodDeclaration(MethodDeclaration node) {
  -    safelyVisitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
  -    safelyVisitTokenWithSuffix(node.externalKeyword, " ");
  -    safelyVisitTokenWithSuffix(node.modifierKeyword, " ");
  -    safelyVisitNodeWithSuffix(node.returnType, " ");
  -    safelyVisitTokenWithSuffix(node.propertyKeyword, " ");
  -    safelyVisitTokenWithSuffix(node.operatorKeyword, " ");
  -    safelyVisitNode(node.name);
  +    _visitNodeList(node.metadata, separator: ' ', suffix: ' ');
  +    _visitToken(node.externalKeyword, suffix: ' ');
  +    _visitToken(node.modifierKeyword, suffix: ' ');
  +    _visitNode(node.returnType, suffix: ' ');
  +    _visitToken(node.propertyKeyword, suffix: ' ');
  +    _visitToken(node.operatorKeyword, suffix: ' ');
  +    _visitNode(node.name);
       if (!node.isGetter) {
  -      safelyVisitNode(node.typeParameters);
  -      safelyVisitNode(node.parameters);
  -    }
  -    safelyVisitFunctionWithPrefix(" ", node.body);
  +      _visitNode(node.typeParameters);
  +      _visitNode(node.parameters);
  +    }
  +    _visitFunctionBody(node.body);
     }
   
     @override
  
positive.code:     for (int i = 0; i < size; i++) {
        FormalParameter parameter = parameters[i];
        if (i > 0) {
          sink.write(", ");
        }
        if (groupEnd == null && parameter is DefaultFormalParameter) {
          if (parameter.isNamed) {
            groupEnd = "}";
            sink.write('{');
          } else {
            groupEnd = "]";
            sink.write('[');
          }
        }
  
negative.code:   /// visited nodes to the given [sink].
    ToSourceVisitor(this.sink);
  
    @override
    void visitAdjacentStrings(AdjacentStrings node) {
      _visitNodeList(node.strings, separator: ' ');
    }
  
    @override
    void visitAnnotation(Annotation node) {
      sink.write('@');
      _visitNode(node.name);
      _visitNode(node.typeArguments);
      _visitNode(node.constructorName, prefix: '.');
      _visitNode(node.arguments);
    }
  
    @override
    void visitArgumentList(ArgumentList node) {
      sink.write('(');
      _visitNodeList(node.arguments, separator: ', ');
      sink.write(')');
    }
  
    @override
    void visitAsExpression(AsExpression node) {
      _visitNode(node.expression);
      sink.write(' as ');
      _visitNode(node.type);
    }
  
    @override
    void visitAssertInitializer(AssertInitializer node) {
      sink.write('assert (');
      _visitNode(node.condition);
      if (node.message != null) {
        sink.write(', ');
        _visitNode(node.message);
      }
      sink.write(');');
    }
  
    @override
    void visitAssertStatement(AssertStatement node) {
      sink.write('assert (');
      _visitNode(node.condition);
      if (node.message != null) {
        sink.write(', ');
        _visitNode(node.message);
      }
      sink.write(');');
    }
  
    @override
    void visitAssignmentExpression(AssignmentExpression node) {
      _visitNode(node.leftHandSide);
      sink.write(' ');
      sink.write(node.operator.lexeme);
      sink.write(' ');
      _visitNode(node.rightHandSide);
    }
  
    @override
    void visitAwaitExpression(AwaitExpression node) {
      sink.write('await ');
      _visitNode(node.expression);
    }
  
    @override
  