Formatter code transform bit-flip support.

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';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/services/writer.dart';
 
 /// Formatter options.
 class FormatterOptions {
 
   /// Create formatter options with defaults derived (where defined) from
   /// the style guide: <http://www.dartlang.org/articles/style-guide/>.
   const FormatterOptions({this.initialIndentationLevel: 0,
                  this.spacesPerIndent: 2,
                  this.lineSeparator: NEW_LINE,
                  this.pageWidth: 80,
                  this.tabsForIndent: false,
-                 this.tabSize: 2});
+                 this.tabSize: 2,
+                 this.codeTransforms: false});
 
   final String lineSeparator;
   final int initialIndentationLevel;
   final int spacesPerIndent;
   final int tabSize;
   final bool tabsForIndent;
   final int pageWidth;
+  final bool codeTransforms;
 }
 
 
 /// Thrown when an error occurs in formatting.
 class FormatterException implements Exception {
 
   /// A message describing the error.
   final String message;
 
   /// Creates a new FormatterException with an optional error [message].
@@ skipping 35 matching lines @@
 
   /// Format the specified portion (from [offset] with [length]) of the given
   /// [source] string, optionally providing an [indentationLevel].
   FormattedSource format(CodeKind kind, String source, {int offset, int end,
     int indentationLevel: 0, Selection selection: null});
 
 }
 
 /// Source selection state information.
 class Selection {
-  
+
   /// The offset of the source selection.
   final int offset;
-  
+
   /// The length of the selection.
   final int length;
-  
+
   Selection(this.offset, this.length);
-  
+
   String toString() => 'Selection (offset: $offset, length: $length)';
 }
 
 /// Formatted source.
 class FormattedSource {
-  
+
   /// Selection state or null if unspecified.
-  final Selection selection;
-  
+  Selection selection;
+
   /// Formatted source string.
   final String source;
-  
+
   /// Create a formatted [source] result, with optional [selection] information.
   FormattedSource(this.source, [this.selection = null]);
 }
 
 
 class CodeFormatterImpl implements CodeFormatter, AnalysisErrorListener {
 
   final FormatterOptions options;
   final errors = <AnalysisError>[];
   final whitespace = new RegExp(r'[\s]+');
 
   LineInfo lineInfo;
 
   CodeFormatterImpl(this.options);
 
   FormattedSource format(CodeKind kind, String source, {int offset, int end,
       int indentationLevel: 0, Selection selection: null}) {
 
     var startToken = tokenize(source);
     checkForErrors();
 
     var node = parse(kind, startToken);
     checkForErrors();
 
     var formatter = new SourceVisitor(options, lineInfo, selection);
     node.accept(formatter);
 
     var formattedSource = formatter.writer.toString();
-    
+
     checkTokenStreams(startToken, tokenize(formattedSource));
 
     return new FormattedSource(formattedSource, formatter.selection);
   }
 
   checkTokenStreams(Token t1, Token t2) =>
       new TokenStreamComparator(lineInfo, t1, t2).verifyEquals();
 
   ASTNode parse(CodeKind kind, Token start) {
 
@@ skipping 41 matching lines @@
   verifyEquals() {
     while (!isEOF(token1)) {
       checkPrecedingComments();
       if (!checkTokens()) {
         throwNotEqualException(token1, token2);
       }
       advance();
 
     }
     // TODO(pquitslund): consider a better way to notice trailing synthetics
-    if (!isEOF(token2) && 
+    if (!isEOF(token2) &&
         !(isCLOSE_CURLY_BRACKET(token2) && isEOF(token2.next))) {
       throw new FormatterException(
           'Expected "EOF" but got "${token2}".');
     }
   }
 
   checkPrecedingComments() {
     var comment1 = token1.precedingComments;
     var comment2 = token2.precedingComments;
     while (comment1 != null) {
@@ skipping 64 matching lines @@
 
 }
 
 // Cached parser for testing token types.
 final tokenTester = new Parser(null,null);
 
 /// Test if this token is an EOF token.
 bool isEOF(Token token) => tokenIs(token, TokenType.EOF);
 
 /// Test for token type.
-bool tokenIs(Token token, TokenType type) => 
+bool tokenIs(Token token, TokenType type) =>
     token != null && tokenTester.matches4(token, type);
 
 /// Test if this token is a GT token.
 bool isGT(Token token) => tokenIs(token, TokenType.GT);
 
 /// Test if this token is a GT_GT token.
 bool isGT_GT(Token token) => tokenIs(token, TokenType.GT_GT);
 
 /// Test if this token is an INDEX token.
 bool isINDEX(Token token) => tokenIs(token, TokenType.INDEX);
@@ skipping 10 matching lines @@
 bool isOPEN_SQ_BRACKET(Token token) =>
     tokenIs(token, TokenType.OPEN_SQUARE_BRACKET);
 
 /// Test if this token is a CLOSE_SQUARE_BRACKET token.
 bool isCLOSE_SQUARE_BRACKET(Token token) =>
     tokenIs(token, TokenType.CLOSE_SQUARE_BRACKET);
 
 
 /// An AST visitor that drives formatting heuristics.
 class SourceVisitor implements ASTVisitor {
-  
+
   static final OPEN_CURLY = syntheticToken(TokenType.OPEN_CURLY_BRACKET, '{');
   static final CLOSE_CURLY = syntheticToken(TokenType.CLOSE_CURLY_BRACKET, '}');
-  
+
   static const SYNTH_OFFSET = -13;
-  
+
   static StringToken syntheticToken(TokenType type, String value) =>
       new StringToken(type, value, SYNTH_OFFSET);
-  
+
   static bool isSynthetic(Token token) => token.offset == SYNTH_OFFSET;
 
   /// The writer to which the source is to be written.
   final SourceWriter writer;
 
   /// Cached line info for calculating blank lines.
   LineInfo lineInfo;
 
   /// Cached previous token for calculating preceding whitespace.
   Token previousToken;
 
   /// A flag to indicate that a newline should be emitted before the next token.
   bool needsNewline = false;
-  
+
   /// A counter for spaces that should be emitted preceding the next token.
   int leadingSpaces = 0;
 
   /// Used for matching EOL comments
   final twoSlashes = new RegExp(r'//[^/]');
-  
+
   /// Original pre-format selection information (may be null).
   final Selection preSelection;
-  
+
+  final bool codeTransforms;
+
   /// Post format selection information.
   Selection selection;
 
+
   /// Initialize a newly created visitor to write source code representing
   /// the visited nodes to the given [writer].
-  SourceVisitor(FormatterOptions options, this.lineInfo, this.preSelection) :
+  SourceVisitor(FormatterOptions options, this.lineInfo, this.preSelection):
       writer = new SourceWriter(indentCount: options.initialIndentationLevel,
-                                lineSeparator: options.lineSeparator);
+                                lineSeparator: options.lineSeparator),
+      codeTransforms = options.codeTransforms;
 
   visitAdjacentStrings(AdjacentStrings node) {
     visitNodes(node.strings, separatedBy: space);
   }
 
   visitAnnotation(Annotation node) {
     token(node.atSign);
     visit(node.name);
     token(node.period);
     visit(node.constructorName);
@@ skipping 146 matching lines @@
     var scriptTag = node.scriptTag;
     var directives = node.directives;
     visit(scriptTag);
 
     visitNodes(directives, separatedBy: newlines, followedBy: newlines);
 
     visitNodes(node.declarations, separatedBy: newlines);
 
     // Handle trailing whitespace
     token(node.endToken /* EOF */);
-    
+
     // Be a good citizen, end with a NL
     ensureTrailingNewline();
   }
 
   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);
     token(node.period);
     visit(node.name);
     visit(node.parameters);
-    
+
     // Check for redirects or initializer lists
     if (node.separator != null) {
       if (node.redirectedConstructor != null) {
         visitConstructorRedirects(node);
-      } else { 
+      } else {
         visitConstructorInitializers(node);
       }
     }
 
     visitPrefixedBody(space, node.body);
   }
 
   visitConstructorInitializers(ConstructorDeclaration node) {
     newlines();
     indent(2);
     token(node.separator /* : */);
     space();
     for (var i = 0; i < node.initializers.length; i++) {
       if (i > 0) {
         comma();
         newlines();
         space(2);
       }
       node.initializers[i].accept(this);
-    } 
+    }
     unindent(2);
   }
 
   visitConstructorRedirects(ConstructorDeclaration node) {
     token(node.separator /* = */, precededBy: space, followedBy: space);
     visitNodes(node.initializers, separatedBy: commaSeperator);
     visit(node.redirectedConstructor);
   }
-  
+
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     token(node.keyword);
     token(node.period);
     visit(node.fieldName);
     space();
     token(node.equals);
     space();
     visit(node.expression);
   }
 
@@ skipping 189 matching lines @@
     visitNode(node.returnType, followedBy: space);
     visit(node.identifier);
     visit(node.parameters);
   }
 
   visitHideCombinator(HideCombinator node) {
     token(node.keyword);
     space();
     visitNodes(node.hiddenNames, separatedBy: commaSeperator);
   }
-  
+
   visitIfStatement(IfStatement node) {
     var hasElse = node.elseStatement != null;
     token(node.ifKeyword);
     space();
     token(node.leftParenthesis);
     visit(node.condition);
     token(node.rightParenthesis);
     space();
     if (hasElse) {
       printAsBlock(node.thenStatement);
       space();
       token(node.elseKeyword);
       space();
       printAsBlock(node.elseStatement);
     } else {
       visit(node.thenStatement);
     }
   }
-  
+
   visitImplementsClause(ImplementsClause node) {
     token(node.keyword);
     space();
     visitNodes(node.interfaces, separatedBy: commaSeperator);
   }
 
   visitImportDirective(ImportDirective node) {
     token(node.keyword);
     space();
     visit(node.uri);
@@ skipping 80 matching lines @@
   }
 
   visitMapLiteral(MapLiteral node) {
     modifier(node.constKeyword);
     visitNode(node.typeArguments, followedBy: space);
     token(node.leftBracket);
     visitNodes(node.entries, separatedBy: commaSeperator);
     optionalTrailingComma(node.rightBracket);
     token(node.rightBracket);
   }
-  
+
   visitMapLiteralEntry(MapLiteralEntry node) {
     visit(node.key);
     token(node.separator);
     space();
     visit(node.value);
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
     modifier(node.externalKeyword);
     modifier(node.modifierKeyword);
@@ skipping 335 matching lines @@
   newlines() {
     needsNewline = true;
   }
 
   /// Optionally emit a trailing comma.
   optionalTrailingComma(Token rightBracket) {
     if (rightBracket.previous.lexeme == ',') {
       comma();
     }
   }
-  
+
   token(Token token, {precededBy(), followedBy(), int minNewlines: 0}) {
     if (token != null) {
       if (needsNewline) {
         minNewlines = max(1, minNewlines);
       }
       var emitted = emitPrecedingCommentsAndNewlines(token, min: minNewlines);
       if (emitted > 0) {
         needsNewline = false;
       }
       if (precededBy != null) {
         precededBy();
       }
       checkForSelectionUpdate(token);
       append(token.lexeme);
       if (followedBy != null) {
         followedBy();
       }
       previousToken = token;
     }
   }
-  
+
   emitSpaces() {
     while (leadingSpaces > 0) {
       writer.print(' ');
       leadingSpaces--;
     }
   }
-  
+
   checkForSelectionUpdate(Token token) {
     // Cache the first token on or AFTER the selection offset
     if (preSelection != null && selection == null) {
       // Check for overshots
       var overshot = token.offset - preSelection.offset;
       if (overshot >= 0) {
         //TODO(pquitslund): update length (may need truncating)
         selection = new Selection(
-            writer.toString().length + leadingSpaces - overshot, 
+            writer.toString().length + leadingSpaces - overshot,
             preSelection.length);
       }
     }
   }
 
   commaSeperator() {
     comma();
     space();
   }
 
   comma() {
     writer.print(',');
   }
 
-  
+
   /// Emit a non-breakable space.
   space([n = 1]) {
     //TODO(pquitslund): replace with a proper space token
     leadingSpaces+=n;
   }
-  
+
   /// Emit a breakable space
   breakableSpace() {
     //Implement
   }
 
   /// Append the given [string] to the source writer if it's non-null.
   append(String string) {
     if (string != null && !string.isEmpty) {
       emitSpaces();
       writer.print(string);
     }
   }
 
   /// Indent.
   indent([n = 1]) {
     while (n-- > 0) {
       writer.indent();
     }
   }
-  
+
   /// Unindent
   unindent([n = 1]) {
     while (n-- > 0) {
       writer.unindent();
     }
   }
-  
+
   /// Print this statement as if it were a block (e.g., surrounded by braces).
   printAsBlock(Statement statement) {
-    if (statement is! Block) {
+    if (codeTransforms && statement is! Block) {
       token(OPEN_CURLY);
       indent();
       newlines();
       visit(statement);
       newlines();
       unindent();
       token(CLOSE_CURLY);
     } else {
       visit(statement);
     }
   }
-  
+
   /// Emit any detected comments and newlines or a minimum as specified
   /// by [min].
   int emitPrecedingCommentsAndNewlines(Token token, {min: 0}) {
 
     var comment = token.precedingComments;
     var currentToken = comment != null ? comment : token;
 
     //Handle EOLs before newlines
     if (isAtEOL(comment)) {
       emitComment(comment, previousToken);
@@ skipping 26 matching lines @@
     previousToken = token;
     return lines;
   }
 
 
   ensureTrailingNewline() {
     if (writer.lastToken is! NewlineToken) {
       writer.newline();
     }
   }
-  
-  
+
+
   /// Test if this [comment] is at the end of a line.
   bool isAtEOL(Token comment) =>
       comment != null && comment.toString().trim().startsWith(twoSlashes) &&
       sameLine(comment, previousToken);
 
   /// Emit this [comment], inserting leading whitespace if appropriate.
   emitComment(Token comment, Token previousToken) {
     if (!writer.currentLine.isWhitespace() && !isBlock(comment)) {
       var ws = countSpacesBetween(previousToken, comment);
       // Preserve one space but no more
@@ skipping 69 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }