Line-breaking plumbing and bits and pieces.

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 348 matching lines @@
   /// A counter for spaces that should be emitted preceding the next token.
   int leadingSpaces = 0;
 
   /// A flag to specify whether line-leading spaces should be preserved (and
   /// addded to the indent level).
   bool allowLineLeadingSpaces;
 
   /// Used for matching EOL comments
   final twoSlashes = new RegExp(r'//[^/]');
 
+  /// A weight for potential breakpoints.
+  int breakWeight = null;
+
   /// Original pre-format selection information (may be null).
   final Selection preSelection;
 
   final bool codeTransforms;
 
   /// Post format selection information.
   Selection selection;
 
 
   /// Initialize a newly created visitor to write source code representing
@@ skipping 609 matching lines @@
 
   visitLibraryIdentifier(LibraryIdentifier node) {
     append(node.name);
   }
 
   visitListLiteral(ListLiteral node) {
     modifier(node.constKeyword);
     visit(node.typeArguments);
     token(node.leftBracket);
     indent();
-    visitCommaSeparatedNodes(node.elements);
+    visitCommaSeparatedNodes(node.elements /*, followedBy: breakableSpace*/);
     optionalTrailingComma(node.rightBracket);
     unindent();
     token(node.rightBracket);
   }
 
   visitMapLiteral(MapLiteral node) {
     modifier(node.constKeyword);
     visitNode(node.typeArguments, followedBy: space);
     token(node.leftBracket);
     newlines();
@@ skipping 439 matching lines @@
       checkForSelectionUpdate(token);
       append(token.lexeme);
       if (followedBy != null) {
         followedBy();
       }
       previousToken = token;
     }
   }
 
   emitSpaces() {
-    while (leadingSpaces > 0) {
-      if (!writer.currentLine.isWhitespace() || allowLineLeadingSpaces) {
-        writer.print(' ');
+    if (leadingSpaces > 0) {
+      if (allowLineLeadingSpaces || !writer.currentLine.isWhitespace()) {
+        writer.spaces(leadingSpaces, breakWeight: breakWeight);
       }
+      leadingSpaces = 0;
       allowLineLeadingSpaces = false;
-      leadingSpaces--;
+      breakWeight = null;
     }
   }
 
   checkForSelectionUpdate(Token token) {
     // Cache the first token on or AFTER the selection offset
     if (preSelection != null && selection == null) {
       // Check for overshots
       var overshot = token.offset - preSelection.offset;
       if (overshot >= 0) {
         //TODO(pquitslund): update length (may need truncating)
         selection = new Selection(
             writer.toString().length + leadingSpaces - overshot,
             preSelection.length);
       }
     }
   }
 
   /// Emit a non-breakable 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}) {
     //TODO(pquitslund): replace with a proper space token
     leadingSpaces+=n;
     allowLineLeadingSpaces = allowLineLeading;
   }
 
-  /// Emit a breakable space
+  /// Mark a breakable space
   breakableSpace() {
-    //Implement
+    space();
+    breakWeight =
+        countNewlinesBetween(previousToken, previousToken.next) > 0 ? 1 : 0;
   }
 
   /// Append the given [string] to the source writer if it's non-null.
   append(String string) {
     if (string != null && !string.isEmpty) {
       emitSpaces();
       writer.print(string);
     }
   }
 
@@ skipping 169 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }