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 379 matching lines @@
     visit(node.arguments);
   }
 
   visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     token(node.question);
     visit(node.identifier);
   }
 
   visitArgumentList(ArgumentList node) {
     token(node.leftParenthesis);
-    visitCommaSeparatedNodes(node.arguments);
+    allowContinuedLines((){
+      visitCommaSeparatedNodes(node.arguments);
+    });
     token(node.rightParenthesis);
   }
 
   visitAsExpression(AsExpression node) {
     visit(node.expression);
     space();
     token(node.asOperator);
     space();
     visit(node.type);
   }
 
   visitAssertStatement(AssertStatement node) {
     token(node.keyword);
     space();
     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()) {
+    indent(2);

[Brian Wilkerson, 2013/12/13 22:38:03]

Do we want to increase the indentation if allowContinuedLines is called
recursively? For example, we call it both in an assignment expression and in a
conditional expression, so the indent will be N + 4 while processing the 'then'
and 'else' conditions in the following:

  a = b ? c : d;

+    code();
+    unindent(2);
+  }
 
   /// 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 236 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }