Removed fixed dependencies

packages/dart_style/lib/src/chunk_builder.dart

 // Copyright (c) 2014, 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 dart_style.src.chunk_builder;
 
 import 'chunk.dart';
 import 'dart_formatter.dart';
 import 'debug.dart' as debug;
 import 'line_writer.dart';
 import 'nesting_level.dart';
 import 'nesting_builder.dart';
 import 'rule/rule.dart';
 import 'source_code.dart';
 import 'whitespace.dart';
 
+/// Matches if the last character of a string is an identifier character.
+final _trailingIdentifierChar = new RegExp(r"[a-zA-Z0-9_]$");
+
 /// Takes the incremental serialized output of [SourceVisitor]--the source text
 /// along with any comments and preserved whitespace--and produces a coherent
 /// tree of [Chunk]s which can then be split into physical lines.
 ///
 /// Keeps track of leading indentation, expression nesting, and all of the hairy
 /// code required to seamlessly integrate existing comments into the pure
 /// output produced by [SourceVisitor].
 class ChunkBuilder {
   final DartFormatter _formatter;
 
@@ skipping 64 matching lines @@
   bool _firstFlushLeft = false;
 
   /// Whether there is pending whitespace that depends on the number of
   /// newlines in the source.
   ///
   /// This is used to avoid calculating the newlines between tokens unless
   /// actually needed since doing so is slow when done between every single
   /// token pair.
   bool get needsToPreserveNewlines =>
       _pendingWhitespace == Whitespace.oneOrTwoNewlines ||
-      _pendingWhitespace == Whitespace.spaceOrNewline ||
       _pendingWhitespace == Whitespace.splitOrNewline;
 
   /// The number of characters of code that can fit in a single line.
   int get pageWidth => _formatter.pageWidth;
 
   /// The current innermost rule.
   Rule get rule => _rules.last;
 
   ChunkBuilder(this._formatter, this._source)
       : _parent = null,
@@ skipping 52 matching lines @@
   /// Outputs the series of [comments] and associated whitespace that appear
   /// before [token] (which is not written by this).
   ///
   /// The list contains each comment as it appeared in the source between the
   /// last token written and the next one that's about to be written.
   ///
   /// [linesBeforeToken] is the number of lines between the last comment (or
   /// previous token if there are no comments) and the next token.
   void writeComments(
       List<SourceComment> comments, int linesBeforeToken, String token) {
-    // Corner case: if we require a blank line, but there exists one between
+    // Edge case: if we require a blank line, but there exists one between
     // some of the comments, or after the last one, then we don't need to
     // enforce one before the first comment. Example:
     //
     //     library foo;
     //     // comment
     //
     //     class Bar {}
     //
     // Normally, a blank line is required after `library`, but since there is
     // one after the comment, we don't need one before it. This is mainly so
     // that commented out directives stick with their preceding group.
     if (_pendingWhitespace == Whitespace.twoNewlines &&
         comments.first.linesBefore < 2) {
       if (linesBeforeToken > 1) {
         _pendingWhitespace = Whitespace.newline;
       } else {
         for (var i = 1; i < comments.length; i++) {
           if (comments[i].linesBefore > 1) {
             _pendingWhitespace = Whitespace.newline;
             break;
           }
         }
       }
     }
 
-    // Corner case: if the comments are completely inline (i.e. just a series
-    // of block comments with no newlines before, after, or between them), then
+    // Edge case: if the comments are completely inline (i.e. just a series of
+    // block comments with no newlines before, after, or between them), then
     // they will eat any pending newlines. Make sure that doesn't happen by
     // putting the pending whitespace before the first comment and moving them
     // to their own line. Turns this:
     //
     //     library foo; /* a */ /* b */ import 'a.dart';
     //
     // into:
     //
     //     library foo;
     //
@@ skipping 22 matching lines @@
 
       if (comment.linesBefore == 0) {
         // If we're sitting on a split, move the comment before it to adhere it
         // to the preceding text.
         if (_shouldMoveCommentBeforeSplit(comment.text)) {
           _chunks.last.allowText();
         }
 
         // The comment follows other text, so we need to decide if it gets a
         // space before it or not.
-        if (_needsSpaceBeforeComment(isLineComment: comment.isLineComment)) {
-          _writeText(" ");
-        }
+        if (_needsSpaceBeforeComment(comment)) _writeText(" ");
       } else {
         // The comment starts a line, so make sure it stays on its own line.
         _writeHardSplit(
             flushLeft: comment.flushLeft,
             isDouble: comment.linesBefore > 1,
             nest: true);
       }
 
       _writeText(comment.text);
 
@@ skipping 36 matching lines @@
     preserveNewlines(linesBeforeToken);
   }
 
   /// If the current pending whitespace allows some source discretion, pins
   /// that down given that the source contains [numLines] newlines at that
   /// point.
   void preserveNewlines(int numLines) {
     // If we didn't know how many newlines the user authored between the last
     // token and this one, now we do.
     switch (_pendingWhitespace) {
-      case Whitespace.spaceOrNewline:
-        if (numLines > 0) {
-          _pendingWhitespace = Whitespace.nestedNewline;
-        } else {
-          _pendingWhitespace = Whitespace.space;
-        }
-        break;
-
       case Whitespace.splitOrNewline:
         if (numLines > 0) {
           _pendingWhitespace = Whitespace.nestedNewline;
         } else {
           _pendingWhitespace = Whitespace.none;
           split(space: true);
         }
         break;
 
       case Whitespace.oneOrTwoNewlines:
@@ skipping 41 matching lines @@
     }
   }
 
   /// Starts a new [Rule].
   ///
   /// If omitted, defaults to a new [Rule].
   void startRule([Rule rule]) {
     if (rule == null) rule = new Rule();
 
     // See if any of the rules that contain this one care if it splits.
-    _rules.forEach((outer) => outer.contain(rule));
+    _rules.forEach((outer) {
+      if (!outer.splitsOnInnerRules) return;
+      rule.imply(outer);
+    });
     _rules.add(rule);
   }
 
   /// Starts a new [Rule] that comes into play *after* the next whitespace
   /// (including comments) is written.
   ///
-  /// This is used for binary operators who want to start a rule before the
-  /// first operand but not get forced to split if a comment appears before the
+  /// This is used for operators who want to start a rule before the first
+  /// operand but not get forced to split if a comment appears before the
   /// entire expression.
   ///
   /// If [rule] is omitted, defaults to a new [Rule].
   void startLazyRule([Rule rule]) {
     if (rule == null) rule = new Rule();
 
     _lazyRules.add(rule);
   }
 
   /// Ends the innermost rule.
   void endRule() {
-    _rules.removeLast();
+    if (_lazyRules.isNotEmpty) {
+      _lazyRules.removeLast();
+    } else {
+      _rules.removeLast();
+    }
   }
 
   /// Pre-emptively forces all of the current rules to become hard splits.
   ///
   /// This is called by [SourceVisitor] when it can determine that a rule will
   /// will always be split. Turning it (and the surrounding rules) into hard
   /// splits lets the writer break the output into smaller pieces for the line
   /// splitter, which helps performance and avoids failing on very large input.
   ///
   /// In particular, it's easy for the visitor to know that collections with a
@@ skipping 185 matching lines @@
         break;
 
       case Whitespace.newlineFlushLeft:
         _writeHardSplit(flushLeft: true, nest: true);
         break;
 
       case Whitespace.twoNewlines:
         _writeHardSplit(isDouble: true);
         break;
 
-      case Whitespace.spaceOrNewline:
       case Whitespace.splitOrNewline:
       case Whitespace.oneOrTwoNewlines:
         // We should have pinned these down before getting here.
         assert(false);
         break;
     }
 
     _pendingWhitespace = Whitespace.none;
   }
 
   /// Returns `true` if the last chunk is a split that should be moved after the
   /// comment that is about to be written.
   bool _shouldMoveCommentBeforeSplit(String comment) {
     // Not if there is nothing before it.
     if (_chunks.isEmpty) return false;
 
     // Multi-line comments are always pushed to the next line.
     if (comment.contains("\n")) return false;
 
-    // If the text before the split is an open grouping character, we don't
-    // want to adhere the comment to that.
     var text = _chunks.last.text;
+
+    // A block comment following a comma probably refers to the following item.
+    if (text.endsWith(",") && comment.startsWith("/*")) return false;
+
+    // If the text before the split is an open grouping character, it looks
+    // better to keep it with the elements than with the bracket itself.
     return !text.endsWith("(") && !text.endsWith("[") && !text.endsWith("{");
   }
 
+  /// Returns `true` if [comment] appears to be a magic generic method comment.
+  ///
+  /// Those get spaced a little differently to look more like real syntax:
+  ///
+  ///     int f/*<S, T>*/(int x) => 3;
+  bool _isGenericMethodComment(SourceComment comment) {
+    return comment.text.startsWith("/*<") || comment.text.startsWith("/*=");
+  }
+
   /// Returns `true` if a space should be output between the end of the current
   /// output and the subsequent comment which is about to be written.
   ///
   /// This is only called if the comment is trailing text in the unformatted
   /// source. In most cases, a space will be output to separate the comment
   /// from what precedes it. This returns false if:
   ///
   /// *   This comment does begin the line in the output even if it didn't in
   ///     the source.
   /// *   The comment is a block comment immediately following a grouping
   ///     character (`(`, `[`, or `{`). This is to allow `foo(/* comment */)`,
   ///     et. al.
-  bool _needsSpaceBeforeComment({bool isLineComment}) {
+  bool _needsSpaceBeforeComment(SourceComment comment) {
     // Not at the start of the file.
     if (_chunks.isEmpty) return false;
 
     // Not at the start of a line.
     if (!_chunks.last.canAddText) return false;
 
     var text = _chunks.last.text;
     if (text.endsWith("\n")) return false;
 
     // Always put a space before line comments.
-    if (isLineComment) return true;
+    if (comment.isLineComment) return true;
+
+    // Magic generic method comments like "Foo/*<T>*/" don't get spaces.
+    if (_isGenericMethodComment(comment) &&
+        _trailingIdentifierChar.hasMatch(text)) {
+      return false;
+    }
 
     // Block comments do not get a space if following a grouping character.
     return !text.endsWith("(") && !text.endsWith("[") && !text.endsWith("{");
   }
 
   /// Returns `true` if a space should be output after the last comment which
   /// was just written and the token that will be written.
   bool _needsSpaceAfterLastComment(List<SourceComment> comments, String token) {
     // Not if there are no comments.
     if (comments.isEmpty) return false;
 
     // Not at the beginning of a line.
     if (!_chunks.last.canAddText) return false;
 
+    // Magic generic method comments like "Foo/*<T>*/" don't get spaces.
+    if (_isGenericMethodComment(comments.last) && token == "(") {
+      return false;
+    }
+
     // Otherwise, it gets a space if the following token is not a delimiter or
     // the empty string, for EOF.
     return token != ")" &&
         token != "]" &&
         token != "}" &&
         token != "," &&
         token != ";" &&
         token != "";
   }
 
@@ skipping 116 matching lines @@
 
     // Discard spans in hardened chunks since we know for certain they will
     // split anyway.
     for (var chunk in _chunks) {
       if (chunk.rule != null && chunk.rule.isHardened) {
         chunk.spans.clear();
       }
     }
   }
 }