Eat some dogfood!

lib/src/source_visitor.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 dart_style.src.source_visitor;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
@@ skipping 254 matching lines @@
 
     builder.unnest();
     builder.endSpan();
     builder.endRule();
   }
 
   visitBlock(Block node) {
     // Format function bodies as separate blocks.
     if (node.parent is BlockFunctionBody) {
       _writeBlockLiteral(node.leftBracket, node.rightBracket,
-            forceRule: node.statements.isNotEmpty, block: () {
-        visitNodes(node.statements, between: oneOrTwoNewlines, after: newline);
-      });
+          forceRule: node.statements.isNotEmpty,
+          block: () {
+            visitNodes(node.statements,
+                between: oneOrTwoNewlines, after: newline);
+          });
       return;
     }
 
     // For everything else, just bump the indentation and keep it in the current
     // block.
     _writeBody(node.leftBracket, node.rightBracket, body: () {
       visitNodes(node.statements, between: oneOrTwoNewlines, after: newline);
     });
   }
 
@@ skipping 379 matching lines @@
   }
 
   visitEnumDeclaration(EnumDeclaration node) {
     visitDeclarationMetadata(node.metadata);
 
     token(node.enumKeyword);
     space();
     visit(node.name);
     space();
 
-    _writeBody(node.leftBracket, node.rightBracket, space: true, body: () {
-      visitCommaSeparatedNodes(node.constants, between: split);
-    });
+    _writeBody(node.leftBracket, node.rightBracket,
+        space: true,
+        body: () {
+          visitCommaSeparatedNodes(node.constants, between: split);
+        });
   }
 
   visitExportDirective(ExportDirective node) {
     visitDeclarationMetadata(node.metadata);
 
     _simpleStatement(node, () {
       token(node.keyword);
       space();
       visit(node.uri);
 
@@ skipping 87 matching lines @@
       token(node.leftParenthesis);
 
       // If there is a comment, do allow splitting before it.
       if (node.rightParenthesis.precedingComments != null) soloZeroSplit();
 
       token(node.rightParenthesis);
       return;
     }
 
     var requiredParams = node.parameters
-        .where((param) => param is! DefaultFormalParameter).toList();
+        .where((param) => param is! DefaultFormalParameter)
+        .toList();
     var optionalParams = node.parameters
-        .where((param) => param is DefaultFormalParameter).toList();
+        .where((param) => param is DefaultFormalParameter)
+        .toList();
 
     builder.nestExpression();
     token(node.leftParenthesis);
 
     // If this parameter list is for a lambda argument that we want to avoid
     // splitting, close the span that sticks it to the beginning of the
     // argument list.
     if (_firstFunctionSpan != null) {
       builder.endSpan(_firstFunctionSpan);
       _firstFunctionSpan = null;
@@ skipping 32 matching lines @@
       builder.endSpan();
       builder.endRule();
     }
 
     if (optionalParams.isNotEmpty) {
       var namedRule = new NamedRule(null);
       if (rule != null) rule.setNamedArgsRule(namedRule);
 
       builder.startRule(namedRule);
 
-      namedRule.beforeArguments(
-          builder.split(space: requiredParams.isNotEmpty));
+      namedRule
+          .beforeArguments(builder.split(space: requiredParams.isNotEmpty));
 
       // "[" or "{" for optional parameters.
       token(node.leftDelimiter);
 
       for (var param in optionalParams) {
         visit(param);
 
         // Write the trailing comma.
         if (param != node.parameters.last) token(param.endToken.next);
         if (param != optionalParams.last) split();
@@ skipping 432 matching lines @@
   }
 
   visitStringInterpolation(StringInterpolation node) {
     // Since we output the interpolated text manually, ensure we include any
     // preceding stuff first.
     writePrecedingCommentsAndNewlines(node.beginToken);
 
     // Right now, the formatter does not try to do any reformatting of the
     // contents of interpolated strings. Instead, it treats the entire thing as
     // a single (possibly multi-line) chunk of text.
-     _writeStringLiteral(
+    _writeStringLiteral(
         _source.text.substring(node.beginToken.offset, node.endToken.end),
         node.offset);
   }
 
   visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     builder.startSpan();
 
     token(node.superKeyword);
     token(node.period);
     visit(node.constructorName);
@@ skipping 306 matching lines @@
       visit(node);
 
       // The comma after the node.
       if (node.endToken.next.lexeme == ",") token(node.endToken.next);
     }
   }
 
   /// Visits the collection literal [node] whose body starts with [leftBracket],
   /// ends with [rightBracket] and contains [elements].
   void _visitCollectionLiteral(TypedLiteral node, Token leftBracket,
-      Iterable<AstNode> elements, Token rightBracket, [int cost]) {
+      Iterable<AstNode> elements, Token rightBracket,
+      [int cost]) {
     modifier(node.constKeyword);
     visit(node.typeArguments);
 
     // Don't allow splitting in an empty collection.
     if (elements.isEmpty && rightBracket.precedingComments == null) {
       token(leftBracket);
       token(rightBracket);
       return;
     }
 
-    _writeBlockLiteral(leftBracket, rightBracket, forceRule: false, block: () {
-      // Always use a hard rule to split the elements. The parent chunk of the
-      // collection will handle the unsplit case, so this only comes into play
-      // when the collection is split.
-      var elementSplit = new HardSplitRule();
-      builder.startRule(elementSplit);
+    _writeBlockLiteral(leftBracket, rightBracket,
+        forceRule: false,
+        block: () {
+          // Always use a hard rule to split the elements. The parent chunk of the

[kevmoo, 2015/06/15 20:55:45]

long lines

[Bob Nystrom, 2015/06/15 21:04:54]

Done.

+          // collection will handle the unsplit case, so this only comes into play
+          // when the collection is split.
+          var elementSplit = new HardSplitRule();
+          builder.startRule(elementSplit);
 
-      for (var element in elements) {
-        if (element != elements.first) builder.blockSplit(space: true);
+          for (var element in elements) {
+            if (element != elements.first) builder.blockSplit(space: true);
 
-        builder.nestExpression();
+            builder.nestExpression();
 
-        visit(element);
+            visit(element);
 
-        // The comma after the element.
-        if (element.endToken.next.lexeme == ",") token(element.endToken.next);
+            // The comma after the element.
+            if (element.endToken.next.lexeme ==
+                ",") token(element.endToken.next);
 
-        builder.unnest();
-      }
+            builder.unnest();
+          }
 
-      return elementSplit;
-    });
+          return elementSplit;
+        });
   }
 
   /// Writes a block literal (function, list, or map), handling indentation
   /// when the literal appears in an argument list.
   ///
   /// if [forceRule] is `true`, then the block will always split.
   ///
   /// The [block] callback should write the contents of the literal. It may
   /// optionally return a Rule. If it does, that rule will be ignored when
   /// determining if the contents of the block should split.
@@ skipping 90 matching lines @@
       // Split before the closing bracket character.
       builder.unindent();
       builder.blockSplit(space: space);
     });
 
     builder.endRule();
   }
 
   /// Returns `true` if [node] is immediately contained within an anonymous
   /// [FunctionExpression].
-  bool _isInLambda(AstNode node) =>
-      node.parent is FunctionExpression &&
+  bool _isInLambda(AstNode node) => node.parent is FunctionExpression &&
       node.parent.parent is! FunctionDeclaration;
 
   /// Writes the string literal [string] to the output.
   ///
   /// Splits multiline strings into separate chunks so that the line splitter
   /// can handle them correctly.
   void _writeStringLiteral(String string, int offset) {
     // Split each line of a multiline string into separate chunks.
     var lines = string.split(_formatter.lineEnding);
 
@@ skipping 269 matching lines @@
   /// Gets the 1-based line number that the beginning of [token] lies on.
   int _startLine(Token token) => _lineInfo.getLocation(token.offset).lineNumber;
 
   /// Gets the 1-based line number that the end of [token] lies on.
   int _endLine(Token token) => _lineInfo.getLocation(token.end).lineNumber;
 
   /// Gets the 1-based column number that the beginning of [token] lies on.
   int _startColumn(Token token) =>
       _lineInfo.getLocation(token.offset).columnNumber;
 }