Fix to ensure no breaks after new and general zero-length space support (dartbug.com/16379).

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 345 matching lines @@
   /// the next token.
   bool preserveNewlines = false;
 
   /// 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;
 
+  /// 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;
 
   /// Original pre-format selection information (may be null).
   final Selection preSelection;
 
   final bool codeTransforms;
@@ skipping 29 matching lines @@
     visit(node.arguments);
   }
 
   visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     token(node.question);
     visit(node.identifier);
   }
 
   visitArgumentList(ArgumentList node) {
     token(node.leftParenthesis);
+    breakableNonSpace();
     visitCommaSeparatedNodes(node.arguments);
+    breakableNonSpace();
     token(node.rightParenthesis);
   }
 
   visitAsExpression(AsExpression node) {
     visit(node.expression);
     space();
     token(node.asOperator);
     space();
     visit(node.type);
   }
@@ skipping 497 matching lines @@
     } else {
       visit(node.target);
     }
     token(node.leftBracket);
     visit(node.index);
     token(node.rightBracket);
   }
 
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     token(node.keyword);
-    space();
+    nonBreakingSpace();
     visit(node.constructorName);
     visit(node.argumentList);
   }
 
   visitIntegerLiteral(IntegerLiteral node) {
     token(node.literal);
   }
 
   visitInterpolationExpression(InterpolationExpression node) {
     if (node.rightBracket != null) {
@@ skipping 515 matching lines @@
         printToken(token);
       }
       if (followedBy != null) {
         followedBy();
       }
       previousToken = token;
     }
   }
 
   emitSpaces() {
-    if (leadingSpaces > 0) {
+    if (leadingSpaces > 0 || emitEmptySpaces) {
       if (allowLineLeadingSpaces || !writer.currentLine.isWhitespace()) {
         writer.spaces(leadingSpaces, breakWeight: currentBreakWeight);
       }
       leadingSpaces = 0;
       allowLineLeadingSpaces = false;
+      emitEmptySpaces = false;
       currentBreakWeight = DEFAULT_SPACE_WEIGHT;
     }
   }
 
   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 breakable 'non' (zero-length) space
+  breakableNonSpace() {
+    space(n: 0);
+    emitEmptySpaces = true;
+  }
+
   /// 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
@@ skipping 182 matching lines @@
     var lastLine =
         lineInfo.getLocation(lastOffset).lineNumber;
     var currentLine =
         lineInfo.getLocation(currentOffset).lineNumber;
     return currentLine - lastLine;
   }
 
   String toString() => writer.toString();
 
 }