Improve wrapping during formatting.

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/parser.dart';
@@ skipping 367 matching lines @@
 
   /// A flag to specify whether zero-length spaces should be emmitted.
   bool emitEmptySpaces = false;
 
   /// Used for matching EOL comments
   final twoSlashes = new RegExp(r'//[^/]');
 
   /// A weight for potential breakpoints.
   int currentBreakWeight = DEFAULT_SPACE_WEIGHT;
 
+  /// A weight of a potential breakpoint of the current level.
+  int levelBreakWeight = 0;
+
   /// Original pre-format selection information (may be null).
   final Selection preSelection;
 
   final bool codeTransforms;
 
 
   /// The source being formatted (used in interpolation handling)
   final String source;
 
   /// Post format selection information.
@@ skipping 18 matching lines @@
   visitAnnotation(Annotation node) {
     token(node.atSign);
     visit(node.name);
     token(node.period);
     visit(node.constructorName);
     visit(node.arguments);
   }
 
   visitArgumentList(ArgumentList node) {
     token(node.leftParenthesis);
-    breakableNonSpace();
-    visitCommaSeparatedNodes(node.arguments);
+    if (node.arguments.isNotEmpty) {
+      withBreakLevel(() {
+        levelSpace(0);
+        visitCommaSeparatedNodes(
+            node.arguments,
+            followedBy: () => levelSpace());
+      });
+    }
     token(node.rightParenthesis);
   }
 
   visitAsExpression(AsExpression node) {
     visit(node.expression);
     space();
     token(node.asOperator);
     space();
     visit(node.type);
   }
@@ skipping 10 matching lines @@
     visit(node.leftHandSide);
     space();
     token(node.operator);
     allowContinuedLines((){
       space();
       visit(node.rightHandSide);
     });
   }
 
   visitBinaryExpression(BinaryExpression node) {
-    visit(node.leftOperand);
-    space();
-    token(node.operator);
-    space();
-    visit(node.rightOperand);
+    withBreakLevel(() {
+      Token operator = node.operator;
+      TokenType operatorType = operator.type;
+      int addOperands(List<Expression> operands, Expression e, int i) {
+        if (e is BinaryExpression && e.operator.type == operatorType) {
+          i = addOperands(operands, e.leftOperand, i);
+          i = addOperands(operands, e.rightOperand, i);
+        } else {
+          operands.insert(i++, e);
+        }
+        return i;
+      }
+      List<Expression> operands = [];
+      addOperands(operands, node.leftOperand, 0);
+      addOperands(operands, node.rightOperand, operands.length);
+      for (int i = 0; i < operands.length; i++) {
+        if (i != 0) {
+          space();
+          token(operator);
+          levelSpace();
+        }
+        visit(operands[i]);
+      }
+    });
   }
 
   visitBlock(Block node) {
     token(node.leftBracket);
     indent();
     if (!node.statements.isEmpty) {
       visitNodes(node.statements, precededBy: newlines, separatedBy: newlines);
       newlines();
     } else {
       preserveLeadingNewlines();
@@ skipping 115 matching lines @@
     preserveLeadingNewlines();
 
     // 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);
-    allowContinuedLines((){
+    withBreakLevel(() {
+      visit(node.condition);
       space();
-      visit(node.thenExpression);
-      space();
-      token(node.colon);
-      space();
-      visit(node.elseExpression);
+      token(node.question);
+      allowContinuedLines((){
+        levelSpace();
+        visit(node.thenExpression);
+        space();
+        token(node.colon);
+        levelSpace();
+        visit(node.elseExpression);
+      });
     });
   }
 
   visitConstructorDeclaration(ConstructorDeclaration node) {
     visitMemberMetadata(node.metadata);
     modifier(node.externalKeyword);
     modifier(node.constKeyword);
     modifier(node.factoryKeyword);
     visit(node.returnType);
     token(node.period);
@@ skipping 123 matching lines @@
     token(node.keyword);
     space();
     visit(node.uri);
     allowContinuedLines((){
       visitNodes(node.combinators, precededBy: space, separatedBy: space);
     });
     token(node.semicolon);
   }
 
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
-    token(node.functionDefinition);
-    space();
-    visit(node.expression);
-    token(node.semicolon);
+    withBreakLevel(() {
+      token(node.functionDefinition);
+      levelSpace();
+      visit(node.expression);
+      token(node.semicolon);
+    });
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visit(node.expression);
     token(node.semicolon);
   }
 
   visitExtendsClause(ExtendsClause node) {
     token(node.keyword);
     space();
@@ skipping 251 matching lines @@
 
   visitLibraryIdentifier(LibraryIdentifier node) {
     append(node.name);
   }
 
   visitListLiteral(ListLiteral node) {
     modifier(node.constKeyword);
     visit(node.typeArguments);
     token(node.leftBracket);
     indent();
-    visitCommaSeparatedNodes(node.elements /*, followedBy: breakableSpace*/);
+    withBreakLevel(() {
+      levelSpace(0);
+      visitCommaSeparatedNodes(node.elements, followedBy: levelSpace);
+    });
     optionalTrailingComma(node.rightBracket);
     token(node.rightBracket, precededBy: unindent);
   }
 
   visitMapLiteral(MapLiteral node) {
     modifier(node.constKeyword);
     visitNode(node.typeArguments);
     token(node.leftBracket);
     if (!node.entries.isEmpty) {
       newlines();
@@ skipping 529 matching lines @@
       }
     }
   }
 
   /// Emit a breakable 'non' (zero-length) space
   breakableNonSpace() {
     space(n: 0);
     emitEmptySpaces = true;
   }
 
+  /// Emit level spaces, even if empty (works as a break point).
+  levelSpace([int n = 1]) {
+    space(n: n, breakWeight: levelBreakWeight);
+    emitEmptySpaces = true;
+  }
+
+  void withBreakLevel(process()) {
+    levelBreakWeight++;
+    process();
+    levelBreakWeight--;
+  }
+
   /// Emit a non-breakable space.
   nonBreakingSpace() {
     space(breakWeight: UNBREAKABLE_SPACE_WEIGHT);
   }
 
   /// Emit a space. If [allowLineLeading] is specified, spaces
   /// will be preserved at the start of a line (in addition to the
   /// indent-level), otherwise line-leading spaces will be ignored.
   space({n: 1, allowLineLeading: false, breakWeight: DEFAULT_SPACE_WEIGHT}) {
     //TODO(pquitslund): replace with a proper space token
-    leadingSpaces+=n;
+    leadingSpaces += n;

[Brian Wilkerson, 2014/07/09 19:47:15]

Looks like we need to format this code :-)

     allowLineLeadingSpaces = allowLineLeading;
     currentBreakWeight = breakWeight;
   }
 
   /// Append the given [string] to the source writer if it's non-null.
   append(String string) {
     if (string != null && !string.isEmpty) {
       emitSpaces();
       writer.write(string);
     }
@@ skipping 180 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }