dartfmt pkg/compiler

pkg/compiler/lib/src/tree/unparser.dart

 // Copyright (c) 2012, 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.
 
 import '../tokens/token.dart' show BeginGroupToken, Token;
-import '../tokens/token_constants.dart' as Tokens show IDENTIFIER_TOKEN, KEYWORD_TOKEN, PLUS_TOKEN;
+import '../tokens/token_constants.dart' as Tokens
+    show IDENTIFIER_TOKEN, KEYWORD_TOKEN, PLUS_TOKEN;
 import '../util/util.dart';
 import 'nodes.dart';
 
 String unparse(Node node, {minify: true}) {
   Unparser unparser = new Unparser(minify: minify);
   unparser.unparse(node);
   return unparser.result;
 }
 
 class Unparser extends Indentation implements Visitor {
@@ skipping 13 matching lines @@
     }
   }
 
   void space([String token = " "]) {
     write(minify ? "" : token);
   }
 
   void addToken(Token token) {
     if (token == null) return;
     write(token.value);
-    if (identical(token.kind, Tokens.KEYWORD_TOKEN)
-        || identical(token.kind, Tokens.IDENTIFIER_TOKEN)) {
+    if (identical(token.kind, Tokens.KEYWORD_TOKEN) ||
+        identical(token.kind, Tokens.IDENTIFIER_TOKEN)) {
       write(' ');
     }
   }
 
   bool onEmptyLine = true;
 
   write(object) {
     String s = object.toString();
     if (s == '') return;
     if (onEmptyLine) {
       sb.write(indentation);
     }
     sb.write(s);
     onEmptyLine = false;
   }
 
-  unparse(Node node) { visit(node); }
+  unparse(Node node) {
+    visit(node);
+  }
 
   visit(Node node) {
     if (node != null) node.accept(this);
   }
 
   visitAssert(Assert node) {
     write(node.assertToken.value);
     write('(');
     visit(node.condition);
     if (node.hasMessage) {
@@ skipping 19 matching lines @@
         visit(link.head);
       }
       indentLess();
       newline();
     }
     if (statements.endToken != null) {
       write(statements.endToken.value);
     }
   }
 
-
   visitCascade(Cascade node) {
     visit(node.expression);
   }
 
   visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
   }
 
   unparseClassWithBody(ClassNode node, members) {
     if (!node.modifiers.nodes.isEmpty) {
@@ skipping 100 matching lines @@
     visit(node.function);
   }
 
   void unparseFunctionName(Node name) {
     // TODO(antonm): that's a workaround as currently FunctionExpression
     // names are modelled with Send and it emits operator[] as only
     // operator, without [] which are expected to be emitted with
     // arguments.
     if (name is Send) {
       Send send = name;
-      assert(send is !SendSet);
+      assert(send is! SendSet);
       if (!send.isOperator) {
         // Looks like a factory method.
         visit(send.receiver);
         write('.');
       } else {
         visit(send.receiver);
         Identifier identifier = send.selector.asIdentifier();
         if (identical(identifier.token.kind, Tokens.KEYWORD_TOKEN)) {
           write(' ');
         } else if (identifier.source == 'negate') {
@@ skipping 58 matching lines @@
   visitIf(If node) {
     write(node.ifToken.value);
     space();
     visit(node.condition);
     space();
     visit(node.thenPart);
     if (node.hasElsePart) {
       space();
       write(node.elseToken.value);
       space();
-      if (node.elsePart is !Block && minify) write(' ');
+      if (node.elsePart is! Block && minify) write(' ');
       visit(node.elsePart);
     }
   }
 
   visitLiteralBool(LiteralBool node) {
     write(node.token.value);
   }
 
   visitLiteralDouble(LiteralDouble node) {
     write(node.token.value);
@@ skipping 110 matching lines @@
   visitYield(Yield node) {
     write(node.yieldToken.value);
     if (node.starToken != null) {
       write(node.starToken.value);
     }
     write(' ');
     visit(node.expression);
     write(node.endToken.value);
   }
 
-
   unparseSendReceiver(Send node, {bool spacesNeeded: false}) {
     if (node.receiver == null) return;
     visit(node.receiver);
     CascadeReceiver asCascadeReceiver = node.receiver.asCascadeReceiver();
     if (asCascadeReceiver != null) {
       newline();
       indentMore();
       indentMore();
       write(asCascadeReceiver.cascadeOperator.value);
       indentLess();
       indentLess();
     } else if (node.selector.asOperator() == null) {
       write(node.isConditional ? '?.' : '.');
     } else if (spacesNeeded) {
       write(' ');
     }
   }
 
   unparseSendArgument(Send node, {bool spacesNeeded: false}) {
     if (node.argumentsNode == null) return;
 
-    if(node.isIsNotCheck) {
+    if (node.isIsNotCheck) {
       Send argNode = node.arguments.head;
       visit(argNode.selector);
       space();
       visit(argNode.receiver);
     } else {
       if (spacesNeeded) write(' ');
       visit(node.argumentsNode);
     }
   }
 
   visitSend(Send node) {
     Operator op = node.selector.asOperator();
     String opString = op != null ? op.source : null;
     bool spacesNeeded = minify
         ? identical(opString, 'is') || identical(opString, 'as')
         : (opString != null && !node.isPrefix && !node.isIndex);
 
     void minusMinusSpace(Node other) {
       if (other != null && opString == '-') {
         Token beginToken = other.getBeginToken();
-        if (beginToken != null && beginToken.stringValue != null && beginToken.stringValue.startsWith('-')) {
+        if (beginToken != null &&
+            beginToken.stringValue != null &&
+            beginToken.stringValue.startsWith('-')) {
           sb.write(' ');
           spacesNeeded = false;
         }
       }
     }
 
     if (node.isPrefix) {
       visit(node.selector);
       // Add a space for sequences like - -x (double unary minus).
       minusMinusSpace(node.receiver);
@@ skipping 86 matching lines @@
     // it if the 'type; is var.
     if (node.type != null) {
       visit(node.type);
       write(' ');
     }
     visit(node.definitions);
   }
 
   visitDoWhile(DoWhile node) {
     write(node.doKeyword.value);
-    if (node.body is !Block) {
+    if (node.body is! Block) {
       write(' ');
     } else {
       space();
     }
     visit(node.body);
     space();
     write(node.whileKeyword.value);
     space();
     visit(node.condition);
     write(node.endToken.value);
@@ skipping 54 matching lines @@
     write('(');
     visit(node.declaredIdentifier);
     write(' ');
     addToken(node.inToken);
     visit(node.expression);
     write(')');
     space();
     visit(node.body);
   }
 
-
   visitSyncForIn(SyncForIn node) {
     write(node.forToken.value);
     space();
     write('(');
     visit(node.declaredIdentifier);
     write(' ');
     addToken(node.inToken);
     visit(node.expression);
     write(')');
     space();
     visit(node.body);
   }
 
   visitLabel(Label node) {
     visit(node.identifier);
     write(node.colonToken.value);
-   }
+  }
 
   visitLabeledStatement(LabeledStatement node) {
     visit(node.labels);
     visit(node.statement);
   }
 
   visitLiteralMap(LiteralMap node) {
     if (node.constKeyword != null) write(node.constKeyword.value);
     if (node.typeArguments != null) visit(node.typeArguments);
     visit(node.entries);
@@ skipping 29 matching lines @@
     }
     unparseBlockStatements(node.statements);
     indentLess();
   }
 
   unparseLibraryName(String libraryName) {
     write('library $libraryName;');
     newline();
   }
 
-  unparseImportTag(String uri, {String prefix,
-                                List<String> shows: const <String>[],
-                                bool isDeferred: false}) {
+  unparseImportTag(String uri,
+      {String prefix,
+      List<String> shows: const <String>[],
+      bool isDeferred: false}) {
     String deferredString = isDeferred ? ' deferred' : '';
     String prefixString = prefix == null ? '' : ' as $prefix';
     String showString = shows.isEmpty ? '' : ' show ${shows.join(", ")}';
     write('import "$uri"$deferredString$prefixString$showString;');
     newline();
   }
 
   unparseExportTag(String uri, {List<String> shows: const []}) {
     String suffix = shows.isEmpty ? '' : ' show ${shows.join(", ")}';
     write('export "$uri"$suffix;');
@@ skipping 164 matching lines @@
   }
 
   visitStatement(Statement node) {
     throw 'internal error'; // Should not be called.
   }
 
   visitStringNode(StringNode node) {
     throw 'internal error'; // Should not be called.
   }
 }