Improve formatting of variable declarations/assignments.

pkg/analyzer/lib/src/services/writer.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 source_writer;
 
 import 'dart:math' as math;
 
 class Line {
 
@@ skipping 83 matching lines @@
     return buf.toString();
   }
 
   String indent(Chunk chunk, int level) {
     return '\n' + indenter(level) + chunk.toString();
   }
 
   List<Chunk> breakLine(Line line) {
     List<LineToken> tokens = preprocess(line.tokens);
     List<Chunk> chunks = <Chunk>[new Chunk(line.indentLevel, maxLength, tokens)];
+    // try SINGLE_SPACE_WEIGHT
+    {
+      Chunk chunk = chunks[0];
+      if (chunk.length > maxLength) {
+        for (int i = 0; i < tokens.length; i++) {
+          LineToken token = tokens[i];
+          if (token is SpaceToken && token.breakWeight == SINGLE_SPACE_WEIGHT) {
+            var beforeChunk = chunk.subChunk(chunk.indent, 0, i);
+            var restChunk = chunk.subChunk(chunk.indent + 2, i + 1);
+            // check if 'init' in 'var v = init;' fits a line
+            if (restChunk.length < maxLength) {
+              return [beforeChunk, restChunk];
+            }
+            // check if 'var v = method(' in 'var v = method(args)' does not fit
+            int weight = chunk.findMinSpaceWeight();
+            if (chunk.getLengthToSpaceWithWeight(weight) > maxLength) {
+              chunks = [beforeChunk, restChunk];
+            }
+            // done anyway
+            break;
+          }
+        }
+      }
+    }
+    // other spaces
     while (true) {
       List<Chunk> newChunks = <Chunk>[];
       bool hasChanges = false;
       for (Chunk chunk in chunks) {
         tokens = chunk.tokens;
         if (chunk.length > maxLength) {
           if (chunk.hasAnySpace()) {
             int weight = chunk.findMinSpaceWeight();
             int newIndent = chunk.indent;
             if (weight == DEFAULT_SPACE_WEIGHT) {
               int start = 0;
               int length = 0;
               for (int i = 0; i < tokens.length; i++) {
                 LineToken token = tokens[i];
-                if (token is SpaceToken && token.breakWeight == weight
-                    && i < tokens.length - 1) {
+                if (token is SpaceToken && token.breakWeight == weight &&
+                    i < tokens.length - 1) {
                   LineToken nextToken = tokens[i + 1];
                   if (length + token.length + nextToken.length > maxLength) {
                     newChunks.add(chunk.subChunk(newIndent, start, i));
                     newIndent = chunk.indent + 2;
                     start = i + 1;
                     length = 0;
                     continue;
                   }
                 }
                 length += token.length;
@@ skipping 74 matching lines @@
 }
 
 /// Test if this [string] contains only whitespace characters
 bool isWhitespace(String string) => string.codeUnits.every(
       (c) => c == 0x09 || c == 0x20 || c == 0x0A || c == 0x0D);
 
 /// Special token indicating a line start
 final LINE_START = new SpaceToken(0);
 
 const DEFAULT_SPACE_WEIGHT = UNBREAKABLE_SPACE_WEIGHT - 1;
+/// The weight of a space after '=' in variable declaration or assignment
+const SINGLE_SPACE_WEIGHT = UNBREAKABLE_SPACE_WEIGHT - 2;
 const UNBREAKABLE_SPACE_WEIGHT = 100000000;
 
 /// Simple non-breaking printer
 class SimpleLinePrinter extends LinePrinter {
 
   const SimpleLinePrinter();
 
   String printLine(Line line) {
     var buffer = new StringBuffer();
     line.tokens.forEach((tok) => buffer.write(tok.toString()));
@@ skipping 12 matching lines @@
 /// A working piece of text used in calculating line breaks
 class Chunk {
   final int indent;
   final int maxLength;
   final List<LineToken> tokens = <LineToken>[];
 
   Chunk(this.indent, this.maxLength, [List<LineToken> tokens]) {
     this.tokens.addAll(tokens);
   }
 
-  int get length => tokens.fold(0, (len, token) => len + token.length);
+  int get length {
+    return tokens.fold(0, (len, token) => len + token.length);
+  }
+
+  int getLengthToSpaceWithWeight(int weight) {
+    int length = 0;
+    for (LineToken token in tokens) {
+      if (token is SpaceToken && token.breakWeight == weight) {
+        break;
+      }
+      length += token.length;
+    }
+    return length;
+  }
 
   bool fits(LineToken a, LineToken b) {
     return length + a.length + a.length <= maxLength;
   }
 
   void add(LineToken token) {
     tokens.add(token);
   }
 
+  bool hasInitializerSpace() {
+    return tokens.any((token) {
+      return token is SpaceToken && token.breakWeight == SINGLE_SPACE_WEIGHT;
+    });
+  }
+
   bool hasAnySpace() {
     return tokens.any((token) => token is SpaceToken);
   }
 
   int findMinSpaceWeight() {
     int minWeight = UNBREAKABLE_SPACE_WEIGHT;
     for (var token in tokens) {
       if (token is SpaceToken) {
         minWeight = math.min(minWeight, token.breakWeight);
       }
@@ skipping 197 matching lines @@
 
 String getTabs(int n) => n < TABS.length ? TABS[n] : repeat('\t', n);
 
 String repeat(String ch, int times) {
   var sb = new StringBuffer();
   for (var i = 0; i < times; ++i) {
     sb.write(ch);
   }
   return sb.toString();
 }