Formatter token emission baby-steps.

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 189 matching lines @@
 
   visitBinaryExpression(BinaryExpression node) {
     visit(node.leftOperand);
     writer.print(' ');
     writer.print(node.operator.lexeme);
     writer.print(' ');
     visit(node.rightOperand);
   }
 
   visitBlock(Block node) {
-    writer.print('{');
+//    writer.print('{');
+    emitToken(node.leftBracket);
     writer.indent();
 
     for (var stmt in node.statements) {
-      writer.newline();
+      //writer.newline();
       visit(stmt);
     }
 
     writer.unindent();
     writer.newline();
     writer.print('}');
     previousToken = node.rightBracket;
   }
 
   visitBlockFunctionBody(BlockFunctionBody node) {
     visit(node.block);
   }
 
   visitBooleanLiteral(BooleanLiteral node) {
     writer.print(node.literal.lexeme);
   }
 
   visitBreakStatement(BreakStatement node) {
-    writer.print('break');
+    emitToken(node.keyword);
     visitPrefixed(' ', node.label);
     writer.print(';');
   }
 
   visitCascadeExpression(CascadeExpression node) {
     visit(node.target);
     visitList(node.cascadeSections);
   }
 
   visitCatchClause(CatchClause node) {
     visitPrefixed('on ', node.exceptionType);
     if (node.catchKeyword != null) {
       if (node.exceptionType != null) {
         writer.print(' ');
       }
       writer.print('catch (');
       visit(node.exceptionParameter);
       visitPrefixed(', ', node.stackTraceParameter);
       writer.print(') ');
     } else {
       writer.print(' ');
     }
     visit(node.body);
+    writer.newline();
   }
 
   visitClassDeclaration(ClassDeclaration node) {
     emitToken(node.abstractKeyword, ' ');
     emitToken(node.classKeyword, ' ');
     visit(node.name);
     visit(node.typeParameters);
     visitPrefixed(' ', node.extendsClause);
     visitPrefixed(' ', node.withClause);
     visitPrefixed(' ', node.implementsClause);
@@ skipping 245 matching lines @@
     visit(node.identifier);
     visit(node.parameters);
   }
 
   visitHideCombinator(HideCombinator node) {
     writer.print('hide ');
     visitList(node.hiddenNames, ', ');
   }
 
   visitIfStatement(IfStatement node) {
-    writer.print('if (');
+    emitToken(node.ifKeyword);
+    writer.print(' (');
     visit(node.condition);
     writer.print(') ');
     visit(node.thenStatement);
     visitPrefixed(' else ', node.elseStatement);
   }
 
   visitImplementsClause(ImplementsClause node) {
     writer.print('implements ');
     visitList(node.interfaces, ', ');
   }
 
   visitImportDirective(ImportDirective node) {
     writer.print('import ');
     visit(node.uri);
     visitPrefixed(' as ', node.prefix);
     visitPrefixedList(' ', node.combinators, ' ');
 //    writer.print(';');
-    emit(node.semicolon);
+    emitToken(node.semicolon);
 //    writer.newline();
   }
 
   visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
       writer.print('..');
     } else {
       visit(node.target);
     }
     writer.print('[');
@@ skipping 54 matching lines @@
 
   visitLibraryIdentifier(LibraryIdentifier node) {
     writer.print(node.name);
   }
 
   visitListLiteral(ListLiteral node) {
     if (node.modifier != null) {
       writer.print(node.modifier.lexeme);
       writer.print(' ');
     }
-    visitSuffixed(node.typeArguments, ' ');
+    visit(node.typeArguments);
     writer.print('[');
     visitList(node.elements, ', ');
     writer.print(']');
   }
 
   visitMapLiteral(MapLiteral node) {
     if (node.modifier != null) {
       writer.print(node.modifier.lexeme);
       writer.print(' ');
     }
@@ skipping 102 matching lines @@
     visit(node.argumentList);
   }
 
   visitRethrowExpression(RethrowExpression node) {
     writer.print('rethrow');
   }
 
   visitReturnStatement(ReturnStatement node) {
     var expression = node.expression;
     if (expression == null) {
-      writer.print('return;');
+      emit(node.keyword, min: 1);
+      writer.print(';');
     } else {
-      writer.print('return ');
+      emit(node.keyword, min: 1);
+      writer.print(' ');
       expression.accept(this);
       writer.print(';');
     }
   }
 
   visitScriptTag(ScriptTag node) {
     writer.print(node.scriptTag.lexeme);
   }
 
   visitShowCombinator(ShowCombinator node) {
     writer.print('show ');
     visitList(node.shownNames, ', ');
   }
 
   visitSimpleFormalParameter(SimpleFormalParameter node) {
     emitToken(node.keyword, ' ');
     visitSuffixed(node.type, ' ');
     visit(node.identifier);
   }
 
   visitSimpleIdentifier(SimpleIdentifier node) {
-    emit(node.token);
-//    writer.print(node.token.lexeme);
+    emitToken(node.token);
   }
 
   visitSimpleStringLiteral(SimpleStringLiteral node) {
     writer.print(node.literal.lexeme);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     visitList(node.elements);
   }
 
   visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     writer.print('super');
     visitPrefixed('.', node.constructorName);
     visit(node.argumentList);
   }
 
   visitSuperExpression(SuperExpression node) {
     writer.print('super');
   }
 
   visitSwitchCase(SwitchCase node) {
     visitSuffixedList(node.labels, ' ', ' ');
-    writer.print('case ');
+    emitToken(node.keyword);
+    writer.print(' ');
     visit(node.expression);
-    writer.print(': ');
-    visitList(node.statements, ' ');
+    writer.print(':');
+    writer.indent();
+    visitList(node.statements);
+    writer.unindent();
   }
 
   visitSwitchDefault(SwitchDefault node) {
     visitSuffixedList(node.labels, ' ', ' ');
     writer.print('default: ');
     visitList(node.statements, ' ');
   }
 
   visitSwitchStatement(SwitchStatement node) {
-    writer.print('switch (');
+    emitToken(node.keyword);
+    writer.print(' (');
     visit(node.expression);
-    writer.print(') {');
-    visitList(node.members, ' ');
-    writer.print('}');
+    writer.print(') ');
+    emitToken(node.leftBracket);
+    writer.indent();
+    visitList(node.members);
+    writer.unindent();
+    emitToken(node.rightBracket);
+    writer.newline();
   }
 
   visitSymbolLiteral(SymbolLiteral node) {
      // No-op ?
   }
 
   visitThisExpression(ThisExpression node) {
     writer.print('this');
   }
 
@@ skipping 95 matching lines @@
       writer.print(prefix);
     }
     visit(body);
   }
 
   /// Emit the given [token], printing the prefix before the [token]
   /// if it is non-null.
   emitPrefixedToken(String prefix, Token token) {
     if (token != null) {
       writer.print(prefix);
-      emit(token);
+      emitToken(token);
     }
   }
 
   /// Emit the given [token], printing the suffix after the [token]
   /// node if it is non-null.
-  emitToken(Token token, String suffix) {
+  emitToken(Token token, [String suffix]) {
     if (token != null) {
       emit(token);
-      writer.print(suffix);
+      if (suffix != null) {
+        writer.print(suffix);
+      }
     }
   }
 
   /// Print a list of [nodes], separated by the given [separator].
   visitList(NodeList<ASTNode> nodes, [String separator = '']) {
     if (nodes != null) {
       var size = nodes.length;
       for (var i = 0; i < size; i++) {
         if (i > 0) {
           writer.print(separator);
@@ skipping 70 matching lines @@
     if (last == null || current == null) {
       return 0;
     }
     var lastLine =
         lineInfo.getLocation(last.offset).lineNumber;
     var currentLine =
         lineInfo.getLocation(current.offset).lineNumber;
     return  currentLine - lastLine;
   }
 
+  String toString() => writer.toString();
+  
 }