Formatter line continuation awareness hooks.

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/java_core.dart' show CharSequence;
@@ skipping 404 matching lines @@
     token(node.leftParenthesis);
     visit(node.condition);
     token(node.rightParenthesis);
     token(node.semicolon);
   }
 
   visitAssignmentExpression(AssignmentExpression node) {
     visit(node.leftHandSide);
     space();
     token(node.operator);
-    space();
-    visit(node.rightHandSide);
+    allowContinuedLines((){
+      space();
+      visit(node.rightHandSide);
+    });
   }
 
   visitBinaryExpression(BinaryExpression node) {
     visit(node.leftOperand);
     space();
     token(node.operator);
     space();
     visit(node.rightOperand);
   }
 
@@ skipping 48 matching lines @@
       space();
     }
     visit(node.body);
   }
 
   visitClassDeclaration(ClassDeclaration node) {
     modifier(node.abstractKeyword);
     token(node.classKeyword);
     space();
     visit(node.name);
-    visit(node.typeParameters);
-    visitNode(node.extendsClause, precededBy: space);
-    visitNode(node.withClause, precededBy: space);
-    visitNode(node.implementsClause, precededBy: space);
-    space();
+    allowContinuedLines((){
+      visit(node.typeParameters);
+      visitNode(node.extendsClause, precededBy: space);
+      visitNode(node.withClause, precededBy: space);
+      visitNode(node.implementsClause, precededBy: space);
+      space();
+    });
     token(node.leftBracket);
     indent();
     visitNodes(node.members, precededBy: newlines, separatedBy: newlines);
     unindent();
     newlines();
     token(node.rightBracket);
   }
 
   visitClassTypeAlias(ClassTypeAlias node) {
     token(node.keyword);
@@ skipping 37 matching lines @@
     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);
+    allowContinuedLines((){
+      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);
@@ skipping 83 matching lines @@
   }
 
   visitDoStatement(DoStatement node) {
     token(node.doKeyword);
     space();
     visit(node.body);
     space();
     token(node.whileKeyword);
     space();
     token(node.leftParenthesis);
-    visit(node.condition);
-    token(node.rightParenthesis);
+    allowContinuedLines((){
+      visit(node.condition);
+      token(node.rightParenthesis);
+    });
     token(node.semicolon);
   }
 
   visitDoubleLiteral(DoubleLiteral node) {
     token(node.literal);
   }
 
   visitEmptyFunctionBody(EmptyFunctionBody node) {
     token(node.semicolon);
   }
 
   visitEmptyStatement(EmptyStatement node) {
     token(node.semicolon);
   }
 
   visitExportDirective(ExportDirective node) {
     token(node.keyword);
     space();
     visit(node.uri);
-    visitNodes(node.combinators, precededBy: space, separatedBy: space);
+    allowContinuedLines((){
+      visitNodes(node.combinators, precededBy: space, separatedBy: space);
+    });
     token(node.semicolon);
   }
 
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
     token(node.functionDefinition);
     space();
     visit(node.expression);
     token(node.semicolon);
   }
 
@@ skipping 132 matching lines @@
 
   visitHideCombinator(HideCombinator node) {
     token(node.keyword);
     space();
     visitCommaSeparatedNodes(node.hiddenNames);
   }
 
   visitIfStatement(IfStatement node) {
     var hasElse = node.elseStatement != null;
     token(node.ifKeyword);
-    space();
-    token(node.leftParenthesis);
-    visit(node.condition);
-    token(node.rightParenthesis);
+    allowContinuedLines((){
+      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();
     visitCommaSeparatedNodes(node.interfaces);
   }
 
   visitImportDirective(ImportDirective node) {
     token(node.keyword);
     space();
     visit(node.uri);
     token(node.asToken, precededBy: space, followedBy: space);
-    visit(node.prefix);
-    visitNodes(node.combinators, precededBy: space, separatedBy: space);
+    allowContinuedLines((){
+      visit(node.prefix);
+      visitNodes(node.combinators, precededBy: space, separatedBy: space);
+    });
     token(node.semicolon);
   }
 
   visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
       token(node.period);
     } else {
       visit(node.target);
     }
     token(node.leftBracket);
@@ skipping 187 matching lines @@
     token(node.keyword);
   }
 
   visitReturnStatement(ReturnStatement node) {
     var expression = node.expression;
     if (expression == null) {
       token(node.keyword);
       token(node.semicolon);
     } else {
       token(node.keyword);
-      space();
-      expression.accept(this);
-      token(node.semicolon);
+      allowContinuedLines((){
+        space();
+        expression.accept(this);
+        token(node.semicolon);
+      });
     }
   }
 
   visitScriptTag(ScriptTag node) {
     token(node.scriptTag);
   }
 
   visitShowCombinator(ShowCombinator node) {
     token(node.keyword);
     space();
@@ skipping 113 matching lines @@
     token(node.leftBracket);
     visitCommaSeparatedNodes(node.typeParameters);
     token(node.rightBracket);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     visit(node.name);
     if (node.initializer != null) {
       space();
       token(node.equals);
-      space();
-      visit(node.initializer);
+      var initializer = node.initializer;
+      if (initializer is! ListLiteral && initializer is! MapLiteral) {
+        allowContinuedLines((){
+          space();
+          visit(initializer);
+        });
+      } else {
+        space();
+        visit(initializer);
+      }
     }
   }
 
   visitVariableDeclarationList(VariableDeclarationList node) {
     modifier(node.keyword);
     visitNode(node.type, followedBy: space);
     visitCommaSeparatedNodes(node.variables);
   }
 
   visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     visit(node.variables);
     token(node.semicolon);
   }
 
   visitWhileStatement(WhileStatement node) {
     token(node.keyword);
     space();
     token(node.leftParenthesis);
-    visit(node.condition);
-    token(node.rightParenthesis);
+    allowContinuedLines((){
+      visit(node.condition);
+      token(node.rightParenthesis);
+    });
     if (node.body is! EmptyStatement) {
       space();
     }
     visit(node.body);
   }
 
   visitWithClause(WithClause node) {
     token(node.withKeyword);
     space();
     visitCommaSeparatedNodes(node.mixinTypes);
@@ skipping 65 matching lines @@
       if (precededBy != null) {
         precededBy();
       }
       node.accept(this);
       if (followedBy != null) {
         followedBy();
       }
     }
   }
 
+  /// Allow [code] to be continued across lines.
+  allowContinuedLines(code()) {
+    //TODO(pquitslund): add before
+    code();
+    //TODO(pquitslund): add after
+  }
 
   /// Emit the given [modifier] if it's non null, followed by non-breaking
   /// whitespace.
   modifier(Token modifier) {
     token(modifier, followedBy: space);
   }
 
   /// Indicate that at least one newline should be emitted and possibly more
   /// if the source has them.
   newlines() {
@@ skipping 111 matching lines @@
     var currentToken = comment != null ? comment : token;
 
     //Handle EOLs before newlines
     if (isAtEOL(comment)) {
       emitComment(comment, previousToken);
       comment = comment.next;
       currentToken = comment != null ? comment : token;
     }
 
     var lines = max(min, countNewlinesBetween(previousToken, currentToken));
-    writer.newlines(lines);
+    emitNewlines(lines);
 
     previousToken =
         currentToken.previous != null ? currentToken.previous : token.previous;
 
     while (comment != null) {
 
       emitComment(comment, previousToken);
 
       var nextToken = comment.next != null ? comment.next : token;
       var newlines = calculateNewlinesBetweenComments(comment, nextToken);
       if (newlines > 0) {
-        writer.newlines(newlines);
+        emitNewlines(newlines);
         lines += newlines;
       } else {
         var spaces = countSpacesBetween(comment, nextToken);
         if (spaces > 0) {
           space();
         }
       }
 
       previousToken = comment;
       comment = comment.next;
     }
 
     previousToken = token;
     return lines;
   }
 
+  void emitNewlines(lines) {
+    writer.newlines(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) &&
@@ skipping 76 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }