Remove PrintWriter and PrintStringWriter from java_core.

pkg/analyzer/lib/src/dart/ast/utilities.dart

 // Copyright (c) 2014, 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 analyzer.src.dart.ast.utilities;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisEngine;
-import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart' show TokenMap;
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
  * An AST visitor that will clone any AST structure that it visits. The cloner
  * will only clone the structure, it will not preserve any resolution results or
  * properties associated with the nodes.
  */
 class AstCloner implements AstVisitor<AstNode> {
@@ skipping 6663 matching lines @@
     return node.end < _position;
   }
 }
 
 /**
  * A visitor used to write a source representation of a visited AST node (and
  * all of it's children) to a writer.
  */
 class ToSourceVisitor implements AstVisitor<Object> {
   /**
-   * The writer to which the source is to be written.
+   * The buffer to which the source is to be written.
    */
-  final PrintWriter _writer;
+  final StringBuffer _buffer;
 
   /**
    * Initialize a newly created visitor to write source code representing the
-   * visited nodes to the given [writer].
+   * visited nodes to the given [_buffer].
    */
-  ToSourceVisitor(this._writer);
+  ToSourceVisitor(this._buffer);
 
   @override
   Object visitAdjacentStrings(AdjacentStrings node) {
     _visitNodeListWithSeparator(node.strings, " ");
     return null;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
-    _writer.print('@');
+    _buffer.write('@');
     _visitNode(node.name);
     _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.arguments);
     return null;
   }
 
   @override
   Object visitArgumentList(ArgumentList node) {
-    _writer.print('(');
+    _buffer.write('(');
     _visitNodeListWithSeparator(node.arguments, ", ");
-    _writer.print(')');
+    _buffer.write(')');
     return null;
   }
 
   @override
   Object visitAsExpression(AsExpression node) {
     _visitNode(node.expression);
-    _writer.print(" as ");
+    _buffer.write(" as ");
     _visitNode(node.type);
     return null;
   }
 
   @override
   Object visitAssertStatement(AssertStatement node) {
-    _writer.print("assert (");
+    _buffer.write("assert (");
     _visitNode(node.condition);
     if (node.message != null) {
-      _writer.print(', ');
+      _buffer.write(', ');
       _visitNode(node.message);
     }
-    _writer.print(");");
+    _buffer.write(");");
     return null;
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     _visitNode(node.leftHandSide);
-    _writer.print(' ');
-    _writer.print(node.operator.lexeme);
-    _writer.print(' ');
+    _buffer.write(' ');
+    _buffer.write(node.operator.lexeme);
+    _buffer.write(' ');
     _visitNode(node.rightHandSide);
     return null;
   }
 
   @override
   Object visitAwaitExpression(AwaitExpression node) {
-    _writer.print("await ");
+    _buffer.write("await ");
     _visitNode(node.expression);
     return null;
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     _visitNode(node.leftOperand);
-    _writer.print(' ');
-    _writer.print(node.operator.lexeme);
-    _writer.print(' ');
+    _buffer.write(' ');
+    _buffer.write(node.operator.lexeme);
+    _buffer.write(' ');
     _visitNode(node.rightOperand);
     return null;
   }
 
   @override
   Object visitBlock(Block node) {
-    _writer.print('{');
+    _buffer.write('{');
     _visitNodeListWithSeparator(node.statements, " ");
-    _writer.print('}');
+    _buffer.write('}');
     return null;
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     Token keyword = node.keyword;
     if (keyword != null) {
-      _writer.print(keyword.lexeme);
+      _buffer.write(keyword.lexeme);
       if (node.star != null) {
-        _writer.print('*');
+        _buffer.write('*');
       }
-      _writer.print(' ');
+      _buffer.write(' ');
     }
     _visitNode(node.block);
     return null;
   }
 
   @override
   Object visitBooleanLiteral(BooleanLiteral node) {
-    _writer.print(node.literal.lexeme);
+    _buffer.write(node.literal.lexeme);
     return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
-    _writer.print("break");
+    _buffer.write("break");
     _visitNodeWithPrefix(" ", node.label);
-    _writer.print(";");
+    _buffer.write(";");
     return null;
   }
 
   @override
   Object visitCascadeExpression(CascadeExpression node) {
     _visitNode(node.target);
     _visitNodeList(node.cascadeSections);
     return null;
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
     _visitNodeWithPrefix("on ", node.exceptionType);
     if (node.catchKeyword != null) {
       if (node.exceptionType != null) {
-        _writer.print(' ');
+        _buffer.write(' ');
       }
-      _writer.print("catch (");
+      _buffer.write("catch (");
       _visitNode(node.exceptionParameter);
       _visitNodeWithPrefix(", ", node.stackTraceParameter);
-      _writer.print(") ");
+      _buffer.write(") ");
     } else {
-      _writer.print(" ");
+      _buffer.write(" ");
     }
     _visitNode(node.body);
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.abstractKeyword, " ");
-    _writer.print("class ");
+    _buffer.write("class ");
     _visitNode(node.name);
     _visitNode(node.typeParameters);
     _visitNodeWithPrefix(" ", node.extendsClause);
     _visitNodeWithPrefix(" ", node.withClause);
     _visitNodeWithPrefix(" ", node.implementsClause);
-    _writer.print(" {");
+    _buffer.write(" {");
     _visitNodeListWithSeparator(node.members, " ");
-    _writer.print("}");
+    _buffer.write("}");
     return null;
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     if (node.abstractKeyword != null) {
-      _writer.print("abstract ");
+      _buffer.write("abstract ");
     }
-    _writer.print("class ");
+    _buffer.write("class ");
     _visitNode(node.name);
     _visitNode(node.typeParameters);
-    _writer.print(" = ");
+    _buffer.write(" = ");
     _visitNode(node.superclass);
     _visitNodeWithPrefix(" ", node.withClause);
     _visitNodeWithPrefix(" ", node.implementsClause);
-    _writer.print(";");
+    _buffer.write(";");
     return null;
   }
 
   @override
   Object visitComment(Comment node) => null;
 
   @override
   Object visitCommentReference(CommentReference node) => null;
 
   @override
   Object visitCompilationUnit(CompilationUnit node) {
     ScriptTag scriptTag = node.scriptTag;
     NodeList<Directive> directives = node.directives;
     _visitNode(scriptTag);
     String prefix = scriptTag == null ? "" : " ";
     _visitNodeListWithSeparatorAndPrefix(prefix, directives, " ");
     prefix = scriptTag == null && directives.isEmpty ? "" : " ";
     _visitNodeListWithSeparatorAndPrefix(prefix, node.declarations, " ");
     return null;
   }
 
   @override
   Object visitConditionalExpression(ConditionalExpression node) {
     _visitNode(node.condition);
-    _writer.print(" ? ");
+    _buffer.write(" ? ");
     _visitNode(node.thenExpression);
-    _writer.print(" : ");
+    _buffer.write(" : ");
     _visitNode(node.elseExpression);
     return null;
   }
 
   @override
   Object visitConfiguration(Configuration node) {
-    _writer.print('if (');
+    _buffer.write('if (');
     _visitNode(node.name);
     _visitNodeWithPrefix(" == ", node.value);
-    _writer.print(') ');
+    _buffer.write(') ');
     _visitNode(node.libraryUri);
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.externalKeyword, " ");
     _visitTokenWithSuffix(node.constKeyword, " ");
     _visitTokenWithSuffix(node.factoryKeyword, " ");
     _visitNode(node.returnType);
     _visitNodeWithPrefix(".", node.name);
     _visitNode(node.parameters);
     _visitNodeListWithSeparatorAndPrefix(" : ", node.initializers, ", ");
     _visitNodeWithPrefix(" = ", node.redirectedConstructor);
     _visitFunctionWithPrefix(" ", node.body);
     return null;
   }
 
   @override
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     _visitTokenWithSuffix(node.thisKeyword, ".");
     _visitNode(node.fieldName);
-    _writer.print(" = ");
+    _buffer.write(" = ");
     _visitNode(node.expression);
     return null;
   }
 
   @override
   Object visitConstructorName(ConstructorName node) {
     _visitNode(node.type);
     _visitNodeWithPrefix(".", node.name);
     return null;
   }
 
   @override
   Object visitContinueStatement(ContinueStatement node) {
-    _writer.print("continue");
+    _buffer.write("continue");
     _visitNodeWithPrefix(" ", node.label);
-    _writer.print(";");
+    _buffer.write(";");
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
     _visitNode(node.identifier);
     return null;
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     _visitNode(node.parameter);
     if (node.separator != null) {
-      _writer.print(" ");
-      _writer.print(node.separator.lexeme);
+      _buffer.write(" ");
+      _buffer.write(node.separator.lexeme);
       _visitNodeWithPrefix(" ", node.defaultValue);
     }
     return null;
   }
 
   @override
   Object visitDoStatement(DoStatement node) {
-    _writer.print("do ");
+    _buffer.write("do ");
     _visitNode(node.body);
-    _writer.print(" while (");
+    _buffer.write(" while (");
     _visitNode(node.condition);
-    _writer.print(");");
+    _buffer.write(");");
     return null;
   }
 
   @override
   Object visitDottedName(DottedName node) {
     _visitNodeListWithSeparator(node.components, ".");
     return null;
   }
 
   @override
   Object visitDoubleLiteral(DoubleLiteral node) {
-    _writer.print(node.literal.lexeme);
+    _buffer.write(node.literal.lexeme);
     return null;
   }
 
   @override
   Object visitEmptyFunctionBody(EmptyFunctionBody node) {
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitEmptyStatement(EmptyStatement node) {
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitEnumConstantDeclaration(EnumConstantDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitNode(node.name);
     return null;
   }
 
   @override
   Object visitEnumDeclaration(EnumDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
-    _writer.print("enum ");
+    _buffer.write("enum ");
     _visitNode(node.name);
-    _writer.print(" {");
+    _buffer.write(" {");
     _visitNodeListWithSeparator(node.constants, ", ");
-    _writer.print("}");
+    _buffer.write("}");
     return null;
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
-    _writer.print("export ");
+    _buffer.write("export ");
     _visitNode(node.uri);
     _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     Token keyword = node.keyword;
     if (keyword != null) {
-      _writer.print(keyword.lexeme);
-      _writer.print(' ');
+      _buffer.write(keyword.lexeme);
+      _buffer.write(' ');
     }
-    _writer.print("=> ");
+    _buffer.write("=> ");
     _visitNode(node.expression);
     if (node.semicolon != null) {
-      _writer.print(';');
+      _buffer.write(';');
     }
     return null;
   }
 
   @override
   Object visitExpressionStatement(ExpressionStatement node) {
     _visitNode(node.expression);
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitExtendsClause(ExtendsClause node) {
-    _writer.print("extends ");
+    _buffer.write("extends ");
     _visitNode(node.superclass);
     return null;
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.staticKeyword, " ");
     _visitNode(node.fields);
-    _writer.print(";");
+    _buffer.write(";");
     return null;
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, ' ', ' ');
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
-    _writer.print("this.");
+    _buffer.write("this.");
     _visitNode(node.identifier);
     _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (node.awaitKeyword != null) {
-      _writer.print("await ");
+      _buffer.write("await ");
     }
-    _writer.print("for (");
+    _buffer.write("for (");
     if (loopVariable == null) {
       _visitNode(node.identifier);
     } else {
       _visitNode(loopVariable);
     }
-    _writer.print(" in ");
+    _buffer.write(" in ");
     _visitNode(node.iterable);
-    _writer.print(") ");
+    _buffer.write(") ");
     _visitNode(node.body);
     return null;
   }
 
   @override
   Object visitFormalParameterList(FormalParameterList node) {
     String groupEnd = null;
-    _writer.print('(');
+    _buffer.write('(');
     NodeList<FormalParameter> parameters = node.parameters;
     int size = parameters.length;
     for (int i = 0; i < size; i++) {
       FormalParameter parameter = parameters[i];
       if (i > 0) {
-        _writer.print(", ");
+        _buffer.write(", ");
       }
       if (groupEnd == null && parameter is DefaultFormalParameter) {
         if (parameter.kind == ParameterKind.NAMED) {
           groupEnd = "}";
-          _writer.print('{');
+          _buffer.write('{');
         } else {
           groupEnd = "]";
-          _writer.print('[');
+          _buffer.write('[');
         }
       }
       parameter.accept(this);
     }
     if (groupEnd != null) {
-      _writer.print(groupEnd);
+      _buffer.write(groupEnd);
     }
-    _writer.print(')');
+    _buffer.write(')');
     return null;
   }
 
   @override
   Object visitForStatement(ForStatement node) {
     Expression initialization = node.initialization;
-    _writer.print("for (");
+    _buffer.write("for (");
     if (initialization != null) {
       _visitNode(initialization);
     } else {
       _visitNode(node.variables);
     }
-    _writer.print(";");
+    _buffer.write(";");
     _visitNodeWithPrefix(" ", node.condition);
-    _writer.print(";");
+    _buffer.write(";");
     _visitNodeListWithSeparatorAndPrefix(" ", node.updaters, ", ");
-    _writer.print(") ");
+    _buffer.write(") ");
     _visitNode(node.body);
     return null;
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.externalKeyword, " ");
     _visitNodeWithSuffix(node.returnType, " ");
     _visitTokenWithSuffix(node.propertyKeyword, " ");
     _visitNode(node.name);
     _visitNode(node.functionExpression);
     return null;
   }
 
   @override
   Object visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     _visitNode(node.functionDeclaration);
     return null;
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     if (node.body is! EmptyFunctionBody) {
-      _writer.print(' ');
+      _buffer.write(' ');
     }
     _visitNode(node.body);
     return null;
   }
 
   @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     _visitNode(node.function);
     _visitNode(node.typeArguments);
     _visitNode(node.argumentList);
     return null;
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
-    _writer.print("typedef ");
+    _buffer.write("typedef ");
     _visitNodeWithSuffix(node.returnType, " ");
     _visitNode(node.name);
     _visitNode(node.typeParameters);
     _visitNode(node.parameters);
-    _writer.print(";");
+    _buffer.write(";");
     return null;
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, ' ', ' ');
     _visitNodeWithSuffix(node.returnType, " ");
     _visitNode(node.identifier);
     _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     return null;
   }
 
   @override
   Object visitHideCombinator(HideCombinator node) {
-    _writer.print("hide ");
+    _buffer.write("hide ");
     _visitNodeListWithSeparator(node.hiddenNames, ", ");
     return null;
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
-    _writer.print("if (");
+    _buffer.write("if (");
     _visitNode(node.condition);
-    _writer.print(") ");
+    _buffer.write(") ");
     _visitNode(node.thenStatement);
     _visitNodeWithPrefix(" else ", node.elseStatement);
     return null;
   }
 
   @override
   Object visitImplementsClause(ImplementsClause node) {
-    _writer.print("implements ");
+    _buffer.write("implements ");
     _visitNodeListWithSeparator(node.interfaces, ", ");
     return null;
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
-    _writer.print("import ");
+    _buffer.write("import ");
     _visitNode(node.uri);
     if (node.deferredKeyword != null) {
-      _writer.print(" deferred");
+      _buffer.write(" deferred");
     }
     _visitNodeWithPrefix(" as ", node.prefix);
     _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
-      _writer.print("..");
+      _buffer.write("..");
     } else {
       _visitNode(node.target);
     }
-    _writer.print('[');
+    _buffer.write('[');
     _visitNode(node.index);
-    _writer.print(']');
+    _buffer.write(']');
     return null;
   }
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNode(node.constructorName);
     _visitNode(node.argumentList);
     return null;
   }
 
   @override
   Object visitIntegerLiteral(IntegerLiteral node) {
-    _writer.print(node.literal.lexeme);
+    _buffer.write(node.literal.lexeme);
     return null;
   }
 
   @override
   Object visitInterpolationExpression(InterpolationExpression node) {
     if (node.rightBracket != null) {
-      _writer.print("\${");
+      _buffer.write("\${");
       _visitNode(node.expression);
-      _writer.print("}");
+      _buffer.write("}");
     } else {
-      _writer.print("\$");
+      _buffer.write("\$");
       _visitNode(node.expression);
     }
     return null;
   }
 
   @override
   Object visitInterpolationString(InterpolationString node) {
-    _writer.print(node.contents.lexeme);
+    _buffer.write(node.contents.lexeme);
     return null;
   }
 
   @override
   Object visitIsExpression(IsExpression node) {
     _visitNode(node.expression);
     if (node.notOperator == null) {
-      _writer.print(" is ");
+      _buffer.write(" is ");
     } else {
-      _writer.print(" is! ");
+      _buffer.write(" is! ");
     }
     _visitNode(node.type);
     return null;
   }
 
   @override
   Object visitLabel(Label node) {
     _visitNode(node.label);
-    _writer.print(":");
+    _buffer.write(":");
     return null;
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
     _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
     _visitNode(node.statement);
     return null;
   }
 
   @override
   Object visitLibraryDirective(LibraryDirective node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
-    _writer.print("library ");
+    _buffer.write("library ");
     _visitNode(node.name);
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitLibraryIdentifier(LibraryIdentifier node) {
-    _writer.print(node.name);
+    _buffer.write(node.name);
     return null;
   }
 
   @override
   Object visitListLiteral(ListLiteral node) {
     if (node.constKeyword != null) {
-      _writer.print(node.constKeyword.lexeme);
-      _writer.print(' ');
+      _buffer.write(node.constKeyword.lexeme);
+      _buffer.write(' ');
     }
     _visitNodeWithSuffix(node.typeArguments, " ");
-    _writer.print("[");
+    _buffer.write("[");
     _visitNodeListWithSeparator(node.elements, ", ");
-    _writer.print("]");
+    _buffer.write("]");
     return null;
   }
 
   @override
   Object visitMapLiteral(MapLiteral node) {
     if (node.constKeyword != null) {
-      _writer.print(node.constKeyword.lexeme);
-      _writer.print(' ');
+      _buffer.write(node.constKeyword.lexeme);
+      _buffer.write(' ');
     }
     _visitNodeWithSuffix(node.typeArguments, " ");
-    _writer.print("{");
+    _buffer.write("{");
     _visitNodeListWithSeparator(node.entries, ", ");
-    _writer.print("}");
+    _buffer.write("}");
     return null;
   }
 
   @override
   Object visitMapLiteralEntry(MapLiteralEntry node) {
     _visitNode(node.key);
-    _writer.print(" : ");
+    _buffer.write(" : ");
     _visitNode(node.value);
     return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.externalKeyword, " ");
     _visitTokenWithSuffix(node.modifierKeyword, " ");
     _visitNodeWithSuffix(node.returnType, " ");
     _visitTokenWithSuffix(node.propertyKeyword, " ");
     _visitTokenWithSuffix(node.operatorKeyword, " ");
     _visitNode(node.name);
     if (!node.isGetter) {
       _visitNode(node.typeParameters);
       _visitNode(node.parameters);
     }
     _visitFunctionWithPrefix(" ", node.body);
     return null;
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
     if (node.isCascaded) {
-      _writer.print("..");
+      _buffer.write("..");
     } else {
       if (node.target != null) {
         node.target.accept(this);
-        _writer.print(node.operator.lexeme);
+        _buffer.write(node.operator.lexeme);
       }
     }
     _visitNode(node.methodName);
     _visitNode(node.typeArguments);
     _visitNode(node.argumentList);
     return null;
   }
 
   @override
   Object visitNamedExpression(NamedExpression node) {
     _visitNode(node.name);
     _visitNodeWithPrefix(" ", node.expression);
     return null;
   }
 
   @override
   Object visitNativeClause(NativeClause node) {
-    _writer.print("native ");
+    _buffer.write("native ");
     _visitNode(node.name);
     return null;
   }
 
   @override
   Object visitNativeFunctionBody(NativeFunctionBody node) {
-    _writer.print("native ");
+    _buffer.write("native ");
     _visitNode(node.stringLiteral);
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitNullLiteral(NullLiteral node) {
-    _writer.print("null");
+    _buffer.write("null");
     return null;
   }
 
   @override
   Object visitParenthesizedExpression(ParenthesizedExpression node) {
-    _writer.print('(');
+    _buffer.write('(');
     _visitNode(node.expression);
-    _writer.print(')');
+    _buffer.write(')');
     return null;
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
-    _writer.print("part ");
+    _buffer.write("part ");
     _visitNode(node.uri);
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitPartOfDirective(PartOfDirective node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
-    _writer.print("part of ");
+    _buffer.write("part of ");
     _visitNode(node.libraryName);
-    _writer.print(';');
+    _buffer.write(';');
     return null;
   }
 
   @override
   Object visitPostfixExpression(PostfixExpression node) {
     _visitNode(node.operand);
-    _writer.print(node.operator.lexeme);
+    _buffer.write(node.operator.lexeme);
     return null;
   }
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     _visitNode(node.prefix);
-    _writer.print('.');
+    _buffer.write('.');
     _visitNode(node.identifier);
     return null;
   }
 
   @override
   Object visitPrefixExpression(PrefixExpression node) {
-    _writer.print(node.operator.lexeme);
+    _buffer.write(node.operator.lexeme);
     _visitNode(node.operand);
     return null;
   }
 
   @override
   Object visitPropertyAccess(PropertyAccess node) {
     if (node.isCascaded) {
-      _writer.print("..");
+      _buffer.write("..");
     } else {
       _visitNode(node.target);
-      _writer.print(node.operator.lexeme);
+      _buffer.write(node.operator.lexeme);
     }
     _visitNode(node.propertyName);
     return null;
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
-    _writer.print("this");
+    _buffer.write("this");
     _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.argumentList);
     return null;
   }
 
   @override
   Object visitRethrowExpression(RethrowExpression node) {
-    _writer.print("rethrow");
+    _buffer.write("rethrow");
     return null;
   }
 
   @override
   Object visitReturnStatement(ReturnStatement node) {
     Expression expression = node.expression;
     if (expression == null) {
-      _writer.print("return;");
+      _buffer.write("return;");
     } else {
-      _writer.print("return ");
+      _buffer.write("return ");
       expression.accept(this);
-      _writer.print(";");
+      _buffer.write(";");
     }
     return null;
   }
 
   @override
   Object visitScriptTag(ScriptTag node) {
-    _writer.print(node.scriptTag.lexeme);
+    _buffer.write(node.scriptTag.lexeme);
     return null;
   }
 
   @override
   Object visitShowCombinator(ShowCombinator node) {
-    _writer.print("show ");
+    _buffer.write("show ");
     _visitNodeListWithSeparator(node.shownNames, ", ");
     return null;
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, ' ', ' ');
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
     _visitNode(node.identifier);
     return null;
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    _writer.print(node.token.lexeme);
+    _buffer.write(node.token.lexeme);
     return null;
   }
 
   @override
   Object visitSimpleStringLiteral(SimpleStringLiteral node) {
-    _writer.print(node.literal.lexeme);
+    _buffer.write(node.literal.lexeme);
     return null;
   }
 
   @override
   Object visitStringInterpolation(StringInterpolation node) {
     _visitNodeList(node.elements);
     return null;
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    _writer.print("super");
+    _buffer.write("super");
     _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.argumentList);
     return null;
   }
 
   @override
   Object visitSuperExpression(SuperExpression node) {
-    _writer.print("super");
+    _buffer.write("super");
     return null;
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
-    _writer.print("case ");
+    _buffer.write("case ");
     _visitNode(node.expression);
-    _writer.print(": ");
+    _buffer.write(": ");
     _visitNodeListWithSeparator(node.statements, " ");
     return null;
   }
 
   @override
   Object visitSwitchDefault(SwitchDefault node) {
     _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
-    _writer.print("default: ");
+    _buffer.write("default: ");
     _visitNodeListWithSeparator(node.statements, " ");
     return null;
   }
 
   @override
   Object visitSwitchStatement(SwitchStatement node) {
-    _writer.print("switch (");
+    _buffer.write("switch (");
     _visitNode(node.expression);
-    _writer.print(") {");
+    _buffer.write(") {");
     _visitNodeListWithSeparator(node.members, " ");
-    _writer.print("}");
+    _buffer.write("}");
     return null;
   }
 
   @override
   Object visitSymbolLiteral(SymbolLiteral node) {
-    _writer.print("#");
+    _buffer.write("#");
     List<Token> components = node.components;
     for (int i = 0; i < components.length; i++) {
       if (i > 0) {
-        _writer.print(".");
+        _buffer.write(".");
       }
-      _writer.print(components[i].lexeme);
+      _buffer.write(components[i].lexeme);
     }
     return null;
   }
 
   @override
   Object visitThisExpression(ThisExpression node) {
-    _writer.print("this");
+    _buffer.write("this");
     return null;
   }
 
   @override
   Object visitThrowExpression(ThrowExpression node) {
-    _writer.print("throw ");
+    _buffer.write("throw ");
     _visitNode(node.expression);
     return null;
   }
 
   @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _visitNodeWithSuffix(node.variables, ";");
     return null;
   }
 
   @override
   Object visitTryStatement(TryStatement node) {
-    _writer.print("try ");
+    _buffer.write("try ");
     _visitNode(node.body);
     _visitNodeListWithSeparatorAndPrefix(" ", node.catchClauses, " ");
     _visitNodeWithPrefix(" finally ", node.finallyBlock);
     return null;
   }
 
   @override
   Object visitTypeArgumentList(TypeArgumentList node) {
-    _writer.print('<');
+    _buffer.write('<');
     _visitNodeListWithSeparator(node.arguments, ", ");
-    _writer.print('>');
+    _buffer.write('>');
     return null;
   }
 
   @override
   Object visitTypeName(TypeName node) {
     _visitNode(node.name);
     _visitNode(node.typeArguments);
     return null;
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitNode(node.name);
     _visitNodeWithPrefix(" extends ", node.bound);
     return null;
   }
 
   @override
   Object visitTypeParameterList(TypeParameterList node) {
-    _writer.print('<');
+    _buffer.write('<');
     _visitNodeListWithSeparator(node.typeParameters, ", ");
-    _writer.print('>');
+    _buffer.write('>');
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitNode(node.name);
     _visitNodeWithPrefix(" = ", node.initializer);
     return null;
   }
 
   @override
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
     _visitNodeListWithSeparator(node.variables, ", ");
     return null;
   }
 
   @override
   Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     _visitNode(node.variables);
-    _writer.print(";");
+    _buffer.write(";");
     return null;
   }
 
   @override
   Object visitWhileStatement(WhileStatement node) {
-    _writer.print("while (");
+    _buffer.write("while (");
     _visitNode(node.condition);
-    _writer.print(") ");
+    _buffer.write(") ");
     _visitNode(node.body);
     return null;
   }
 
   @override
   Object visitWithClause(WithClause node) {
-    _writer.print("with ");
+    _buffer.write("with ");
     _visitNodeListWithSeparator(node.mixinTypes, ", ");
     return null;
   }
 
   @override
   Object visitYieldStatement(YieldStatement node) {
     if (node.star != null) {
-      _writer.print("yield* ");
+      _buffer.write("yield* ");
     } else {
-      _writer.print("yield ");
+      _buffer.write("yield ");
     }
     _visitNode(node.expression);
-    _writer.print(";");
+    _buffer.write(";");
     return null;
   }
 
   /**
    * Visit the given function [body], printing the [prefix] before if the body
    * is not empty.
    */
   void _visitFunctionWithPrefix(String prefix, FunctionBody body) {
     if (body is! EmptyFunctionBody) {
-      _writer.print(prefix);
+      _buffer.write(prefix);
     }
     _visitNode(body);
   }
 
   /**
    * Safely visit the given [node].
    */
   void _visitNode(AstNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 
   /**
    * Print a list of [nodes] without any separation.
    */
   void _visitNodeList(NodeList<AstNode> nodes) {
     _visitNodeListWithSeparator(nodes, "");
   }
 
   /**
    * Print a list of [nodes], separated by the given [separator].
    */
   void _visitNodeListWithSeparator(NodeList<AstNode> nodes, String separator) {
     if (nodes != null) {
       int size = nodes.length;
       for (int i = 0; i < size; i++) {
         if (i > 0) {
-          _writer.print(separator);
+          _buffer.write(separator);
         }
         nodes[i].accept(this);
       }
     }
   }
 
   /**
    * Print a list of [nodes], prefixed by the given [prefix] if the list is not
    * empty, and separated by the given [separator].
    */
   void _visitNodeListWithSeparatorAndPrefix(
       String prefix, NodeList<AstNode> nodes, String separator) {
     if (nodes != null) {
       int size = nodes.length;
       if (size > 0) {
-        _writer.print(prefix);
+        _buffer.write(prefix);
         for (int i = 0; i < size; i++) {
           if (i > 0) {
-            _writer.print(separator);
+            _buffer.write(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 
   /**
    * Print a list of [nodes], separated by the given [separator], followed by
    * the given [suffix] if the list is not empty.
    */
   void _visitNodeListWithSeparatorAndSuffix(
       NodeList<AstNode> nodes, String separator, String suffix) {
     if (nodes != null) {
       int size = nodes.length;
       if (size > 0) {
         for (int i = 0; i < size; i++) {
           if (i > 0) {
-            _writer.print(separator);
+            _buffer.write(separator);
           }
           nodes[i].accept(this);
         }
-        _writer.print(suffix);
+        _buffer.write(suffix);
       }
     }
   }
 
   /**
    * Safely visit the given [node], printing the [prefix] before the node if it
    * is non-`null`.
    */
   void _visitNodeWithPrefix(String prefix, AstNode node) {
     if (node != null) {
-      _writer.print(prefix);
+      _buffer.write(prefix);
       node.accept(this);
     }
   }
 
   /**
    * Safely visit the given [node], printing the [suffix] after the node if it
    * is non-`null`.
    */
   void _visitNodeWithSuffix(AstNode node, String suffix) {
     if (node != null) {
       node.accept(this);
-      _writer.print(suffix);
+      _buffer.write(suffix);
     }
   }
 
   /**
    * Safely visit the given [token], printing the [suffix] after the token if it
    * is non-`null`.
    */
   void _visitTokenWithSuffix(Token token, String suffix) {
     if (token != null) {
-      _writer.print(token.lexeme);
-      _writer.print(suffix);
+      _buffer.write(token.lexeme);
+      _buffer.write(suffix);
     }
   }
 }