API clean-up

pkg/analyzer/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/analyzer.dart';
 import 'package:analyzer/src/generated/parser.dart';
@@ skipping 426 matching lines @@
 
   visitAsExpression(AsExpression node) {
     visit(node.expression);
     space();
     token(node.asOperator);
     space();
     visit(node.type);
   }
 
   visitAssertStatement(AssertStatement node) {
-    token(node.keyword);
+    token(node.assertKeyword);
     token(node.leftParenthesis);
     visit(node.condition);
     token(node.rightParenthesis);
     token(node.semicolon);
   }
 
   visitAssignmentExpression(AssignmentExpression node) {
     visit(node.leftHandSide);
     space();
     token(node.operator);
@@ skipping 57 matching lines @@
     }
 
     visit(node.block);
   }
 
   visitBooleanLiteral(BooleanLiteral node) {
     token(node.literal);
   }
 
   visitBreakStatement(BreakStatement node) {
-    token(node.keyword);
+    token(node.breakKeyword);
     visitNode(node.label, precededBy: space);
     token(node.semicolon);
   }
 
   visitCascadeExpression(CascadeExpression node) {
     visit(node.target);
     indent(2);
     // Single cascades do not force a linebreak (dartbug.com/16384)
     if (node.cascadeSections.length > 1) {
       newlines();
@@ skipping 48 matching lines @@
     } else {
       preserveLeadingNewlines();
     }
     token(node.rightBracket, precededBy: unindent);
   }
 
   visitClassTypeAlias(ClassTypeAlias node) {
     preserveLeadingNewlines();
     visitMemberMetadata(node.metadata);
     modifier(node.abstractKeyword);
-    token(node.keyword);
+    token(node.typedefKeyword);
     space();
     visit(node.name);
     visit(node.typeParameters);
     space();
     token(node.equals);
     space();
     visit(node.superclass);
     visitNode(node.withClause, precededBy: space);
     visitNode(node.implementsClause, precededBy: space);
     token(node.semicolon);
@@ skipping 96 matching lines @@
     unindent(2);
   }
 
   visitConstructorRedirects(ConstructorDeclaration node) {
     token(node.separator /* = */, precededBy: space, followedBy: space);
     visitCommaSeparatedNodes(node.initializers);
     visit(node.redirectedConstructor);
   }
 
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
-    token(node.keyword);
+    token(node.thisKeyword);
     token(node.period);
     visit(node.fieldName);
     space();
     token(node.equals);
     space();
     visit(node.expression);
   }
 
   visitConstructorName(ConstructorName node) {
     visit(node.type);
     token(node.period);
     visit(node.name);
   }
 
   visitContinueStatement(ContinueStatement node) {
-    token(node.keyword);
+    token(node.continueKeyword);
     visitNode(node.label, precededBy: space);
     token(node.semicolon);
   }
 
   visitDeclaredIdentifier(DeclaredIdentifier node) {
     modifier(node.keyword);
     visitNode(node.type, followedBy: space);
     visit(node.identifier);
   }
 
@@ skipping 37 matching lines @@
       token(node.semicolon);
     }
   }
 
   visitEnumConstantDeclaration(EnumConstantDeclaration node){
     visit(node.name);
   }
 
   visitEnumDeclaration(EnumDeclaration node){
     visitMemberMetadata(node.metadata);
-    token(node.keyword);
+    token(node.enumKeyword);
     space();
     visit(node.name);
     space();
     token(node.leftBracket);
     newlines();
     indent();
     visitCommaSeparatedNodes(node.constants);
     newlines();
     token(node.rightBracket, precededBy: unindent);
   }
@@ skipping 17 matching lines @@
     visit(node.expression);
     token(node.semicolon);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visit(node.expression);
     token(node.semicolon);
   }
 
   visitExtendsClause(ExtendsClause node) {
-    token(node.keyword);
+    token(node.extendsKeyword);
     space();
     visit(node.superclass);
   }
 
   visitFieldDeclaration(FieldDeclaration node) {
     visitMemberMetadata(node.metadata);
     modifier(node.staticKeyword);
     visit(node.fields);
     token(node.semicolon);
   }
 
   visitFieldFormalParameter(FieldFormalParameter node) {
     token(node.keyword, followedBy: space);
     visitNode(node.type, followedBy: space);
-    token(node.thisToken);
+    token(node.thisKeyword);
     token(node.period);
     visit(node.identifier);
     visit(node.parameters);
   }
 
   visitForEachStatement(ForEachStatement node) {
     token(node.awaitKeyword, followedBy: nonBreakingSpace);
     token(node.forKeyword);
     space();
     token(node.leftParenthesis);
@@ skipping 89 matching lines @@
     visit(node.body);
   }
 
   visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     visit(node.function);
     visit(node.argumentList);
   }
 
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     visitMemberMetadata(node.metadata);
-    token(node.keyword);
+    token(node.typedefKeyword);
     space();
     visitNode(node.returnType, followedBy: space);
     visit(node.name);
     visit(node.typeParameters);
     visit(node.parameters);
     token(node.semicolon);
   }
 
   visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     visitNode(node.returnType, followedBy: space);
@@ skipping 26 matching lines @@
         visit(node.elseStatement);
       } else {
         printAsBlock(node.elseStatement);
       }
     } else {
       visit(node.thenStatement);
     }
   }
 
   visitImplementsClause(ImplementsClause node) {
-    token(node.keyword);
+    token(node.implementsKeyword);
     space();
     visitCommaSeparatedNodes(node.interfaces);
   }
 
   visitImportDirective(ImportDirective node) {
     visitDirectiveMetadata(node.metadata);
     token(node.keyword);
     nonBreakingSpace();
     visit(node.uri);
-    token(node.deferredToken, precededBy: space);
-    token(node.asToken, precededBy: space, followedBy: space);
+    token(node.deferredKeyword, precededBy: space);
+    token(node.asKeyword, precededBy: space, followedBy: space);
     allowContinuedLines((){
       visit(node.prefix);
       visitNodes(node.combinators, precededBy: space, separatedBy: space);
     });
     token(node.semicolon);
   }
 
   visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
       token(node.period);
@@ skipping 118 matching lines @@
     visit(node.methodName);
     visit(node.argumentList);
   }
 
   visitNamedExpression(NamedExpression node) {
     visit(node.name);
     visitNode(node.expression, precededBy: space);
   }
 
   visitNativeClause(NativeClause node) {
-    token(node.keyword);
+    token(node.nativeKeyword);
     space();
     visit(node.name);
   }
 
   visitNativeFunctionBody(NativeFunctionBody node) {
-    token(node.nativeToken);
+    token(node.nativeKeyword);
     space();
     visit(node.stringLiteral);
     token(node.semicolon);
   }
 
   visitNullLiteral(NullLiteral node) {
     token(node.literal);
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     token(node.leftParenthesis);
     visit(node.expression);
     token(node.rightParenthesis);
   }
 
   visitPartDirective(PartDirective node) {
     token(node.keyword);
     space();
     visit(node.uri);
     token(node.semicolon);
   }
 
   visitPartOfDirective(PartOfDirective node) {
     token(node.keyword);
     space();
-    token(node.ofToken);
+    token(node.ofKeyword);
     space();
     visit(node.libraryName);
     token(node.semicolon);
   }
 
   visitPostfixExpression(PostfixExpression node) {
     visit(node.operand);
     token(node.operator);
   }
 
@@ skipping 12 matching lines @@
     if (node.isCascaded) {
       token(node.operator);
     } else {
       visit(node.target);
       token(node.operator);
     }
     visit(node.propertyName);
   }
 
   visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
-    token(node.keyword);
+    token(node.thisKeyword);
     token(node.period);
     visit(node.constructorName);
     visit(node.argumentList);
   }
 
   visitRethrowExpression(RethrowExpression node) {
-    token(node.keyword);
+    token(node.rethrowKeyword);
   }
 
   visitReturnStatement(ReturnStatement node) {
     var expression = node.expression;
     if (expression == null) {
-      token(node.keyword);
+      token(node.returnKeyword);
       token(node.semicolon);
     } else {
-      token(node.keyword);
+      token(node.returnKeyword);
       allowContinuedLines((){
         space();
         expression.accept(this);
         token(node.semicolon);
       });
     }
   }
 
   visitScriptTag(ScriptTag node) {
     token(node.scriptTag);
@@ skipping 26 matching lines @@
     // Process token (for comments etc. but don't print the lexeme)
     token(node.beginToken, printToken: (tok) => null);
     var start = node.beginToken.offset;
     var end = node.endToken.end;
     String string = source.substring(start, end);
     append(string);
     //visitNodes(node.elements);
   }
 
   visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    token(node.keyword);
+    token(node.superKeyword);
     token(node.period);
     visit(node.constructorName);
     visit(node.argumentList);
   }
 
   visitSuperExpression(SuperExpression node) {
-    token(node.keyword);
+    token(node.superKeyword);
   }
 
   visitSwitchCase(SwitchCase node) {
     visitNodes(node.labels, separatedBy: space, followedBy: space);
     token(node.keyword);
     space();
     visit(node.expression);
     token(node.colon);
     newlines();
     indent();
     visitNodes(node.statements, separatedBy: newlines);
     unindent();
   }
 
   visitSwitchDefault(SwitchDefault node) {
     visitNodes(node.labels, separatedBy: space, followedBy: space);
     token(node.keyword);
     token(node.colon);
     newlines();
     indent();
     visitNodes(node.statements, separatedBy: newlines);
     unindent();
   }
 
   visitSwitchStatement(SwitchStatement node) {
-    token(node.keyword);
+    token(node.switchKeyword);
     space();
     token(node.leftParenthesis);
     visit(node.expression);
     token(node.rightParenthesis);
     space();
     token(node.leftBracket);
     indent();
     newlines();
     visitNodes(node.members, separatedBy: newlines, followedBy: newlines);
     token(node.rightBracket, precededBy: unindent);
 
   }
 
   visitSymbolLiteral(SymbolLiteral node) {
     token(node.poundSign);
     var components = node.components;
     for (var component in components) {
       // The '.' separator
       if (component.previous.lexeme == '.') {
         token(component.previous);
       }
       token(component);
     }
   }
 
   visitThisExpression(ThisExpression node) {
-    token(node.keyword);
+    token(node.thisKeyword);
   }
 
   visitThrowExpression(ThrowExpression node) {
-    token(node.keyword);
+    token(node.throwKeyword);
     space();
     visit(node.expression);
   }
 
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     visit(node.variables);
     token(node.semicolon);
   }
 
   visitTryStatement(TryStatement node) {
@@ skipping 12 matching lines @@
   }
 
   visitTypeName(TypeName node) {
     visit(node.name);
     visit(node.typeArguments);
   }
 
   visitTypeParameter(TypeParameter node) {
     visitMemberMetadata(node.metadata);
     visit(node.name);
-    token(node.keyword /* extends */, precededBy: space, followedBy: space);
+    token(node.extendsKeyword, precededBy: space, followedBy: space);
     visit(node.bound);
   }
 
   visitTypeParameterList(TypeParameterList node) {
     token(node.leftBracket);
     visitCommaSeparatedNodes(node.typeParameters);
     token(node.rightBracket);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
@@ skipping 50 matching lines @@
       visitCommaSeparatedNodes(node.variables);
     }
   }
 
   visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     visit(node.variables);
     token(node.semicolon);
   }
 
   visitWhileStatement(WhileStatement node) {
-    token(node.keyword);
+    token(node.whileKeyword);
     space();
     token(node.leftParenthesis);
     allowContinuedLines((){
       visit(node.condition);
       token(node.rightParenthesis);
     });
     if (node.body is! EmptyStatement) {
       space();
     }
     visit(node.body);
@@ skipping 408 matching lines @@
   int linesBetween(int lastOffset, int currentOffset) {
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 }