Formatter checkpoint (String literal elimination).

pkg/analyzer_experimental/lib/src/services/formatter_impl.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library formatter_impl;
 
 import 'dart:math';
 
 import 'package:analyzer_experimental/analyzer.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart';
@@ skipping 146 matching lines @@
   /// the next token.
   bool preservePrecedingNewlines = false;
   
   /// Initialize a newly created visitor to write source code representing
   /// the visited nodes to the given [writer].
   SourceVisitor(FormatterOptions options, this.lineInfo) :
       writer = new SourceWriter(indentCount: options.initialIndentationLevel,
                                 lineSeparator: options.lineSeparator);
 
   visitAdjacentStrings(AdjacentStrings node) {
-    visitList(node.strings, ' ');
+    visitNodes(node.strings, separatedBy: space);
   }
 
   visitAnnotation(Annotation node) {
     token(node.atSign);
     visit(node.name);
-    visitPrefixed('.', node.constructorName);
+    token(node.period);
+    visit(node.constructorName);
     visit(node.arguments);
   }
 
   visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     token(node.question);
     visit(node.identifier);
   }
 
   visitArgumentList(ArgumentList node) {
     token(node.leftParenthesis);
-    visitList(node.arguments, ', ');
+    visitNodes(node.arguments, separatedBy: commaSeperator);
     token(node.rightParenthesis);
   }
 
   visitAsExpression(AsExpression node) {
     visit(node.expression);
     space();
     token(node.asOperator);
     space();
     visit(node.type);
   }
@@ skipping 18 matching lines @@
   visitBinaryExpression(BinaryExpression node) {
     visit(node.leftOperand);
     space();
     token(node.operator);
     space();
     visit(node.rightOperand);
   }
 
   visitBlock(Block node) {
     token(node.leftBracket);
-    needsNewline = true;
     indent();
 
-    for (var stmt in node.statements) {
-      visit(stmt);
-    }
-
+    visitNodes(node.statements, precededBy: newlines, separatedBy: newlines);
+    
     unindent();
-    preservePrecedingNewlines = true;
-    needsNewline = true;
+    newlines();
     token(node.rightBracket);
   }
 
   visitBlockFunctionBody(BlockFunctionBody node) {
     visit(node.block);
   }
 
   visitBooleanLiteral(BooleanLiteral node) {
     token(node.literal);
   }
 
   visitBreakStatement(BreakStatement node) {
-    preservePrecedingNewlines = true;
     token(node.keyword);
-    visitPrefixed(' ', node.label);
+    visitNode(node.label, precededBy: space);
     token(node.semicolon);
-    needsNewline = true;
   }
 
   visitCascadeExpression(CascadeExpression node) {
     visit(node.target);
-    visitList(node.cascadeSections);
+    visitNodes(node.cascadeSections);
   }
 
   visitCatchClause(CatchClause node) {
-    visitPrefixed('on ', node.exceptionType);
+    
+    token(node.onKeyword, precededBy: space, followedBy: space);
+    visit(node.exceptionType);
+
     if (node.catchKeyword != null) {
       if (node.exceptionType != null) {
         space();
       }
       token(node.catchKeyword);
       space();
       token(node.leftParenthesis);
       visit(node.exceptionParameter);
-      visitPrefixed(', ', node.stackTraceParameter);
+      token(node.comma, followedBy: space);
+      visit(node.stackTraceParameter);
       token(node.rightParenthesis);
       space();
     } else {
       space();
     }
     visit(node.body);
-    needsNewline = true;
   }
 
   visitClassDeclaration(ClassDeclaration node) {
-    preservePrecedingNewlines = true;
     modifier(node.abstractKeyword);
     token(node.classKeyword);
     space();
     visit(node.name);
     visit(node.typeParameters);
-    visitPrefixed(' ', node.extendsClause);
-    visitPrefixed(' ', node.withClause);
-    visitPrefixed(' ', node.implementsClause);
+    visitNode(node.extendsClause, precededBy: space);
+    visitNode(node.withClause, precededBy: space);
+    visitNode(node.implementsClause, precededBy: space);
     space();
     token(node.leftBracket);
+    
     indent();
-
-    for (var i = 0; i < node.members.length; i++) {
-      visit(node.members[i]);
-    }
-
+    visitNodes(node.members, precededBy: newlines, separatedBy: newlines);
     unindent();
-
-    emitPrecedingNewlines(node.rightBracket, min: 1);
+    newlines();
+    
     token(node.rightBracket);
   }
 
   visitClassTypeAlias(ClassTypeAlias node) {
     token(node.keyword);
     space();
     visit(node.name);
     visit(node.typeParameters);
     space();
     token(node.equals);
     space();
     if (node.abstractKeyword != null) {
       token(node.abstractKeyword);
       space();
     }
     visit(node.superclass);
-    visitPrefixed(' ', node.withClause);
-    visitPrefixed(' ', node.implementsClause);
+    visitNode(node.withClause, precededBy: space);
+    visitNode(node.implementsClause, precededBy: space);
     token(node.semicolon);
   }
 
   visitComment(Comment node) => null;
 
   visitCommentReference(CommentReference node) => null;
 
   visitCompilationUnit(CompilationUnit node) {
     
     // Cache EOF for leading whitespace calculation
     var start = node.beginToken.previous;
     if (start != null && start.type is TokenType_EOF) {
       previousToken = start;
     }
     
     var scriptTag = node.scriptTag;
     var directives = node.directives;
     visit(scriptTag);
-    visitList(directives);
-    visitList(node.declarations);
+    
+    preservePrecedingNewlines = true;
+    visitNodes(directives, separatedBy: newlines);
+    
+    preservePrecedingNewlines = true;
+    visitNodes(node.declarations, separatedBy: newlines);
 
     // Handle trailing whitespace
     preservePrecedingNewlines = true;
     token(node.endToken /* EOF */);
   }
 
   visitConditionalExpression(ConditionalExpression node) {
     visit(node.condition);
     space();
     token(node.question);
     space();
     visit(node.thenExpression);
     space();
     token(node.colon);
     space();
     visit(node.elseExpression);
   }
 
   visitConstructorDeclaration(ConstructorDeclaration node) {
     modifier(node.externalKeyword);
     modifier(node.constKeyword);
     modifier(node.factoryKeyword);
     visit(node.returnType);
-    visitPrefixed('.', node.name);
+    token(node.period);
+    visit(node.name);
     visit(node.parameters);
-    visitPrefixedList(' : ', node.initializers, ', ');
-    visitPrefixed(' = ', node.redirectedConstructor);
-    visitPrefixedBody(' ', node.body);
+    token(node.separator /* = or : */, precededBy: space, followedBy: space);
+    visitNodes(node.initializers, separatedBy: commaSeperator);
+    visit(node.redirectedConstructor);
+    
+    visitPrefixedBody(space, node.body);
   }
 
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     token(node.keyword);
     token(node.period);
     visit(node.fieldName);
     space();
     token(node.equals);
     space();
     visit(node.expression);
   }
 
   visitConstructorName(ConstructorName node) {
     visit(node.type);
-    visitPrefixed('.', node.name);
+    token(node.period);
+    visit(node.name);
   }
 
   visitContinueStatement(ContinueStatement node) {
     token(node.keyword);
-    visitPrefixed(' ', node.label);
+    visitNode(node.label, precededBy: space);
     token(node.semicolon);
   }
 
   visitDeclaredIdentifier(DeclaredIdentifier node) {
     token(node.keyword);
     space();
     visit(node.type);
     //TODO(pquitslund): avoiding visitSuffixed(..) but we can do better
     if (node.type != null) {
       space();
     }
     visit(node.identifier);
   }
 
   visitDefaultFormalParameter(DefaultFormalParameter node) {
     visit(node.parameter);
     if (node.separator != null) {
-      space();
+      // The '=' separator is preceded by a space
+      if (node.separator.type == TokenType.EQ) {
+        space();
+      }
       token(node.separator);
-      visitPrefixed(' ', node.defaultValue);
+      visitNode(node.defaultValue, precededBy: space);
     }
   }
 
   visitDoStatement(DoStatement node) {
     token(node.doKeyword);
     space();
     visit(node.body);
     space();
     token(node.whileKeyword);
     space();
@@ skipping 12 matching lines @@
   }
 
   visitEmptyStatement(EmptyStatement node) {
     token(node.semicolon);
   }
 
   visitExportDirective(ExportDirective node) {
     token(node.keyword);
     space();
     visit(node.uri);
-    visitPrefixedList(' ', node.combinators, ' ');
+    visitNodes(node.combinators, precededBy: space, separatedBy: space);
     token(node.semicolon);
   }
 
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
     token(node.functionDefinition);
     space();
     visit(node.expression);
     token(node.semicolon);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visit(node.expression);
     token(node.semicolon);
   }
 
   visitExtendsClause(ExtendsClause node) {
     token(node.keyword);
     space();
     visit(node.superclass);
   }
 
   visitFieldDeclaration(FieldDeclaration node) {
-    needsNewline = true;
-    preservePrecedingNewlines = true;
     modifier(node.keyword);
     visit(node.fields);
     token(node.semicolon);
   }
 
   visitFieldFormalParameter(FieldFormalParameter node) {
     token(node.keyword);
     space();
     visit(node.type);
     space();
@@ skipping 41 matching lines @@
     if (groupEnd != null) {
       append(groupEnd);
     }
     token(node.rightParenthesis);
   }
 
   visitForStatement(ForStatement node) {
     token(node.forKeyword);
     space();
     token(node.leftParenthesis);
-    var initialization = node.initialization;
-    if (initialization != null) {
-      visit(initialization);
+    if (node.initialization != null) {
+      visit(node.initialization);
     } else {
       visit(node.variables);
     }
     token(node.leftSeparator);
-    visitPrefixed(' ', node.condition);
+    space();
+    visit(node.condition);
     token(node.rightSeparator);
-    visitPrefixedList(' ', node.updaters, ', ');
-    token(node.leftParenthesis);
+    visitNodes(node.updaters, precededBy: space, separatedBy: space);
+    token(node.rightParenthesis);
     space();
     visit(node.body);
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
-    needsNewline = true;
-    preservePrecedingNewlines = true;
-    visitSuffixed(node.returnType, ' ');
+    visitNode(node.returnType, followedBy: space);
     token(node.propertyKeyword, followedBy: space);
     visit(node.name);
     visit(node.functionExpression);
   }
 
   visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     visit(node.functionDeclaration);
     // TODO(pquitslund): fix and handle in function body
     append(';');
   }
 
   visitFunctionExpression(FunctionExpression node) {
     visit(node.parameters);
     space();
     visit(node.body);
   }
 
   visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     visit(node.function);
     visit(node.argumentList);
   }
 
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     token(node.keyword);
     space();
-    visitSuffixed(node.returnType, ' ');
+    visitNode(node.returnType, followedBy: space);
     visit(node.name);
     visit(node.typeParameters);
     visit(node.parameters);
     token(node.semicolon);
   }
 
   visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
-    visitSuffixed(node.returnType, ' ');
+    visitNode(node.returnType, followedBy: space);
     visit(node.identifier);
     visit(node.parameters);
   }
 
   visitHideCombinator(HideCombinator node) {
     token(node.keyword);
     space();
-    visitList(node.hiddenNames, ', ');
+    visitNodes(node.hiddenNames, separatedBy: commaSeperator);
   }
 
   visitIfStatement(IfStatement node) {
-    preservePrecedingNewlines = true;
     token(node.ifKeyword);
     space();
     token(node.leftParenthesis);
     visit(node.condition);
     token(node.rightParenthesis);
     space();
     visit(node.thenStatement);
     //visitPrefixed(' else ', node.elseStatement);
     if (node.elseStatement != null) {
       space();
       token(node.elseKeyword);
       space();
       visit(node.elseStatement);
     }
-    needsNewline = true;
   }
   
   visitImplementsClause(ImplementsClause node) {
     token(node.keyword);
     space();
-    visitList(node.interfaces, ', ');
+    visitNodes(node.interfaces, separatedBy: commaSeperator);
   }
 
   visitImportDirective(ImportDirective node) {
-    preservePrecedingNewlines = true;
     token(node.keyword);
     space();
     visit(node.uri);
-    visitPrefixed(' as ', node.prefix);
-    visitPrefixedList(' ', node.combinators, ' ');
+    token(node.asToken, precededBy: space, followedBy: space);
+    visit(node.prefix);
+    visitNodes(node.combinators, precededBy: space, separatedBy: space);
     token(node.semicolon);
-    needsNewline = true;
   }
 
   visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
       token(node.period);
     } else {
       visit(node.target);
     }
     token(node.leftBracket);
     visit(node.index);
@@ skipping 34 matching lines @@
     space();
     visit(node.type);
   }
 
   visitLabel(Label node) {
     visit(node.label);
     token(node.colon);
   }
 
   visitLabeledStatement(LabeledStatement node) {
-    visitSuffixedList(node.labels, ' ', ' ');
+    visitNodes(node.labels, separatedBy: space, followedBy: space);
     visit(node.statement);
   }
 
   visitLibraryDirective(LibraryDirective node) {
     token(node.keyword);
     space();
     visit(node.name);
     token(node.semicolon);
   }
 
   visitLibraryIdentifier(LibraryIdentifier node) {
     append(node.name);
   }
 
   visitListLiteral(ListLiteral node) {
-    if (node.modifier != null) {
-      token(node.modifier);
-      space();
-    }
+    modifier(node.modifier);
     visit(node.typeArguments);
     token(node.leftBracket);
-    visitList(node.elements, ', ');
+    visitNodes(node.elements, separatedBy: commaSeperator);
     token(node.rightBracket);
   }
 
   visitMapLiteral(MapLiteral node) {
     modifier(node.modifier);
-    visitSuffixed(node.typeArguments, ' ');
+    visitNode(node.typeArguments, followedBy: space);
     token(node.leftBracket);
-    visitList(node.entries, ', ');
+    visitNodes(node.entries, separatedBy: commaSeperator);
     token(node.rightBracket);
   }
 
   visitMapLiteralEntry(MapLiteralEntry node) {
     visit(node.key);
     space();
     token(node.separator);
     space();
     visit(node.value);
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
-    needsNewline = true;
-    preservePrecedingNewlines = true;
     modifier(node.externalKeyword);
     modifier(node.modifierKeyword);
-    visitSuffixed(node.returnType, ' ');
+    visitNode(node.returnType, followedBy: space);
     modifier(node.propertyKeyword);
     modifier(node.operatorKeyword);
     visit(node.name);
     if (!node.isGetter) {
       visit(node.parameters);
     }
-    visitPrefixedBody(' ', node.body);
+    visitPrefixedBody(space, node.body);
   }
 
   visitMethodInvocation(MethodInvocation node) {
-    if (node.isCascaded) {
-      token(node.period);
-    } else {
-      visitSuffixed(node.target, '.');
-    }
+    visit(node.target);
+    token(node.period);
     visit(node.methodName);
     visit(node.argumentList);
   }
 
   visitNamedExpression(NamedExpression node) {
     visit(node.name);
-    visitPrefixed(' ', node.expression);
+    visitNode(node.expression, precededBy: space);
   }
 
   visitNativeClause(NativeClause node) {
     token(node.keyword);
     space();
     visit(node.name);
   }
 
   visitNativeFunctionBody(NativeFunctionBody node) {
     token(node.nativeToken);
@@ skipping 47 matching lines @@
       token(node.operator);
     } else {
       visit(node.target);
       token(node.operator);
     }
     visit(node.propertyName);
   }
 
   visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     token(node.keyword);
-    visitPrefixed('.', node.constructorName);
+    token(node.period);
+    visit(node.constructorName);
     visit(node.argumentList);
   }
 
   visitRethrowExpression(RethrowExpression node) {
     token(node.keyword);
   }
 
   visitReturnStatement(ReturnStatement node) {
-    preservePrecedingNewlines = true;
     var expression = node.expression;
     if (expression == null) {
       token(node.keyword);
       token(node.semicolon);
     } else {
       token(node.keyword);
       space();
       expression.accept(this);
       token(node.semicolon);
     }
   }
 
   visitScriptTag(ScriptTag node) {
     token(node.scriptTag);
   }
 
   visitShowCombinator(ShowCombinator node) {
     token(node.keyword);
     space();
-    visitList(node.shownNames, ', ');
+    visitNodes(node.shownNames, separatedBy: commaSeperator);
   }
 
   visitSimpleFormalParameter(SimpleFormalParameter node) {
     modifier(node.keyword);
-    visitSuffixed(node.type, ' ');
+    visitNode(node.type, followedBy: space);
     visit(node.identifier);
   }
 
   visitSimpleIdentifier(SimpleIdentifier node) {
     token(node.token);
   }
 
   visitSimpleStringLiteral(SimpleStringLiteral node) {
     token(node.literal);
   }
 
   visitStringInterpolation(StringInterpolation node) {
-    visitList(node.elements);
+    visitNodes(node.elements);
   }
 
   visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     token(node.keyword);
-    visitPrefixed('.', node.constructorName);
+    token(node.period);
+    visit(node.constructorName);
     visit(node.argumentList);
   }
 
   visitSuperExpression(SuperExpression node) {
     token(node.keyword);
   }
 
   visitSwitchCase(SwitchCase node) {
-    preservePrecedingNewlines = true;
-    visitSuffixedList(node.labels, ' ', ' ');
+    visitNodes(node.labels, separatedBy: space, followedBy: space);
     token(node.keyword);
     space();
     visit(node.expression);
     token(node.colon);
+    newlines();
     indent();
-    needsNewline = true;
-    visitList(node.statements);
+    visitNodes(node.statements, separatedBy: newlines);
     unindent();
   }
 
   visitSwitchDefault(SwitchDefault node) {
-    preservePrecedingNewlines = true;
-    visitSuffixedList(node.labels, ' ', ' ');
+    visitNodes(node.labels, separatedBy: space, followedBy: space);
     token(node.keyword);
     token(node.colon);
     space();
-    visitList(node.statements, ' ');
+    visitNodes(node.statements, separatedBy: space);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     token(node.keyword);
     space();
     token(node.leftParenthesis);
     visit(node.expression);
     token(node.rightParenthesis);
     space();
     token(node.leftBracket);
     indent();
-    visitList(node.members);
+    newlines();
+    visitNodes(node.members, separatedBy: newlines, followedBy: newlines);
     unindent();
     token(node.rightBracket);
-    needsNewline = true;
   }
 
   visitSymbolLiteral(SymbolLiteral node) {
      // No-op ?
   }
 
   visitThisExpression(ThisExpression node) {
     token(node.keyword);
   }
 
   visitThrowExpression(ThrowExpression node) {
     token(node.keyword);
     space();
     visit(node.expression);
   }
 
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    preservePrecedingNewlines = true;
     visit(node.variables);
     token(node.semicolon);
   }
 
   visitTryStatement(TryStatement node) {
-    preservePrecedingNewlines = true;
     token(node.tryKeyword);
     space();
     visit(node.body);
-    visitPrefixedList(' ', node.catchClauses, ' ');
-    visitPrefixed(' finally ', node.finallyClause);
+    visitNodes(node.catchClauses, precededBy: space, separatedBy: space);
+    token(node.finallyKeyword, precededBy: space, followedBy: space);
+    visit(node.finallyClause);
   }
 
   visitTypeArgumentList(TypeArgumentList node) {
     token(node.leftBracket);
-    visitList(node.arguments, ', ');
+    visitNodes(node.arguments, separatedBy: commaSeperator);
     token(node.rightBracket);
   }
 
   visitTypeName(TypeName node) {
     visit(node.name);
     visit(node.typeArguments);
   }
 
   visitTypeParameter(TypeParameter node) {
     visit(node.name);
-    visitPrefixed(' extends ', node.bound);
+    token(node.keyword /* extends */, precededBy: space, followedBy: space);
+    visit(node.bound);
   }
 
   visitTypeParameterList(TypeParameterList node) {
     token(node.leftBracket);
-    visitList(node.typeParameters, ', ');
+    visitNodes(node.typeParameters, separatedBy: commaSeperator);
     token(node.rightBracket);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     visit(node.name);
     if (node.initializer != null) {
       space();
       token(node.equals);
       space();
       visit(node.initializer);
     }
   }
 
   visitVariableDeclarationList(VariableDeclarationList node) {
-    token(node.keyword);
-    space();
-    visitSuffixed(node.type, ' ');
-    visitList(node.variables, ', ');
+    modifier(node.keyword);
+    visitNode(node.type, followedBy: space);
+    visitNodes(node.variables, separatedBy: commaSeperator);
   }
 
   visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     visit(node.variables);
     token(node.semicolon);
-    needsNewline = true;
   }
 
   visitWhileStatement(WhileStatement node) {
     token(node.keyword);
     space();
     token(node.leftParenthesis);
     visit(node.condition);
     token(node.rightParenthesis);
     space();
     visit(node.body);
   }
 
   visitWithClause(WithClause node) {
     token(node.withKeyword);
     space();
-    visitList(node.mixinTypes, ', ');
+    visitNodes(node.mixinTypes, separatedBy: commaSeperator);
   }
 
   /// Safely visit the given [node].
   visit(ASTNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 
-  /// Safely visit the given [node], printing the [suffix] after the node if it
-  /// is non-null.
-  visitSuffixed(ASTNode node, String suffix) {
-    if (node != null) {
-      node.accept(this);
-      append(suffix);
-    }
-  }
-
-  /// Safely visit the given [node], printing the [prefix] before the node if
-  /// it is non-null.
-  visitPrefixed(String prefix, ASTNode node) {
-    if (node != null) {
-      append(prefix);
-      node.accept(this);
-    }
-  }
-
   /// Visit the given function [body], printing the [prefix] before if given
   /// body is not empty.
-  visitPrefixedBody(String prefix, FunctionBody body) {
+  visitPrefixedBody(prefix(), FunctionBody body) {
     if (body is! EmptyFunctionBody) {
-      append(prefix);
+      prefix();
     }
     visit(body);
   }
 
-  /// Print a list of [nodes], optionally separated by the given [separator].
-  visitList(NodeList<ASTNode> nodes, [String separator = '']) {
+  /// Visit a list of [nodes] if not null, optionally separated and/or preceded 
+  /// and followed by the given functions.
+  visitNodes(NodeList<ASTNode> nodes, {precededBy(): null,
+      separatedBy() : null, followedBy(): null}) {
     if (nodes != null) {
       var size = nodes.length;
-      for (var i = 0; i < size; i++) {
-        if (i > 0) {
-          append(separator);
+      if (size > 0) {
+        if (precededBy != null) {
+          precededBy();
         }
-        nodes[i].accept(this);
+        for (var i = 0; i < size; i++) {
+          if (i > 0 && separatedBy != null) {
+            separatedBy();
+          }
+          nodes[i].accept(this);
+        }
+        if (followedBy != null) {
+          followedBy();
+        }
+      }
+    }
+  }
+  
+  /// Visit a [node], and if not null, optionally preceded or followed by the 
+  /// specified functions.
+  visitNode(ASTNode node, {precededBy(): null, followedBy(): null}) {
+    if (node != null) {
+      if (precededBy != null) {
+        precededBy();
+      }
+      node.accept(this);
+      if (followedBy != null) {
+        followedBy();
       }
     }
   }
 
-  /// Print a list of [nodes], separated by the given [separator].
-  visitSuffixedList(NodeList<ASTNode> nodes, String separator, String suffix) {
-    if (nodes != null) {
-      var size = nodes.length;
-      if (size > 0) {
-        for (var i = 0; i < size; i++) {
-          if (i > 0) {
-            append(separator);
-          }
-          nodes[i].accept(this);
-        }
-        append(suffix);
-      }
-    }
-  }
-
-  /// Print a list of [nodes], separated by the given [separator].
-  visitPrefixedList(String prefix, NodeList<ASTNode> nodes,
-      [String separator = null]) {
-    if (nodes != null) {
-      var size = nodes.length;
-      if (size > 0) {
-        append(prefix);
-        for (var i = 0; i < size; i++) {
-          if (i > 0 && separator != null) {
-            append(separator);
-          }
-          nodes[i].accept(this);
-        }
-      }
-    }
-  }
 
   /// Emit the given [modifier] if it's non null, followed by non-breaking 
   /// whitespace.
   modifier(Token modifier) {
     token(modifier, followedBy: space);
   }
     
-  token(Token token, {followedBy(), int minNewlines: 0}) {
+  
+  /// Indicate that at least one newline should be emitted and possibly more
+  /// if the source has them.
+  newlines() {
+    preservePrecedingNewlines = true;
+    needsNewline = true;
+  }
+  
+  token(Token token, {precededBy(), followedBy(), int minNewlines: 0}) {
     if (token != null) {
       if (needsNewline) {
         minNewlines = max(1, minNewlines);
       }
       if (preservePrecedingNewlines || minNewlines > 0) {
         var emitted = emitPrecedingNewlines(token, min: minNewlines);
         preservePrecedingNewlines = false;
         if (emitted > 0) {
           needsNewline = false;
         }
       }
+      if (precededBy !=null) {
+        precededBy();
+      }
       append(token.lexeme);
       if (followedBy != null) { 
         followedBy();
       }
       previousToken = token;
     }    
   }
-    
+   
+  commaSeperator() {
+    comma();
+    space();
+  }
+  
+  comma() {
+    append(',');
+  }
+  
   /// Emit a non-breakable space.
   space() {
     //TODO(pquitslund): replace with a proper space token
     append(' ');
   }
   
   /// Emit a breakable space
   breakableSpace() {
     //Implement
   }
@@ skipping 51 matching lines @@
     var lastLine =
         lineInfo.getLocation(last.offset).lineNumber;
     var currentLine =
         lineInfo.getLocation(current.offset).lineNumber;
     return  currentLine - lastLine;
   }
 
   String toString() => writer.toString();
   
 }