Roll Observatory deps (charted -> ^0.3.0)

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';
@@ skipping 43 matching lines @@
   /// rules may not have all of their constraints fully wired up until after
   /// the hard split appears. For example, a hard split in a positional
   /// argument list needs to force the named arguments to split too, but we
   /// don't create that rule until after the positional arguments are done.
   final _hardSplitRules = new Set<Rule>();
 
   /// The list of rules that are waiting until the next whitespace has been
   /// written before they start.
   final _lazyRules = <Rule>[];
 
-  /// The indexes of the chunks owned by each rule (except for hard splits).
-  final _ruleChunks = <Rule, List<int>>{};
-
   /// The nested stack of spans that are currently being written.
   final _openSpans = <OpenSpan>[];
 
   /// The current state.
   final _nesting = new NestingBuilder();
 
   /// The stack of nesting levels where block arguments may start.
   ///
   /// A block argument's contents will nest at the last level in this stack.
   final _blockArgumentNesting = <NestingLevel>[];
@@ skipping 17 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;
+      _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,
         _chunks = [] {
@@ skipping 28 matching lines @@
     _nesting.commitNesting();
   }
 
   /// Writes a [WhitespaceChunk] of [type].
   void writeWhitespace(Whitespace type) {
     _pendingWhitespace = type;
   }
 
   /// Write a split owned by the current innermost rule.
   ///
-  /// If [nesting] is given, uses that. Otherwise, uses the current nesting
-  /// level. If unsplit, it expands to a space if [space] is `true`.
-  ///
   /// If [flushLeft] is `true`, then forces the next line to start at column
   /// one regardless of any indentation or nesting.
   ///
   /// If [isDouble] is passed, forces the split to either be a single or double
   /// newline. Otherwise, leaves it indeterminate.
-  Chunk split({bool space, bool isDouble, bool flushLeft}) =>
-      _writeSplit(_rules.last, null,
-          flushLeft: flushLeft, isDouble: isDouble, spaceWhenUnsplit: space);
-
-  /// Write a split owned by the current innermost rule.
   ///
-  /// Unlike [split()], this ignores any current expression nesting. It always
-  /// indents the next line at the statement level.
-  Chunk blockSplit({bool space, bool isDouble}) =>
-      _writeSplit(_rules.last, _nesting.blockNesting,
-          isDouble: isDouble, spaceWhenUnsplit: space);
+  /// If [nest] is `false`, ignores any current expression nesting. Otherwise,
+  /// uses the current nesting level. If unsplit, it expands to a space if
+  /// [space] is `true`.
+  Chunk split({bool flushLeft, bool isDouble, bool nest, bool space}) =>
+      _writeSplit(_rules.last,
+          flushLeft: flushLeft, isDouble: isDouble, nest: nest, space: space);
 
   /// 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(
@@ skipping 67 matching lines @@
         }
 
         // 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(" ");
         }
       } else {
         // The comment starts a line, so make sure it stays on its own line.
         _writeHardSplit(
-            nest: true,
             flushLeft: comment.flushLeft,
-            double: comment.linesBefore > 1);
+            isDouble: comment.linesBefore > 1,
+            nest: true);
       }
 
       _writeText(comment.text);
 
       if (comment.selectionStart != null) {
         startSelectionFromEnd(comment.text.length - comment.selectionStart);
       }
 
       if (comment.selectionEnd != null) {
         endSelectionFromEnd(comment.text.length - comment.selectionEnd);
@@ skipping 11 matching lines @@
         // mistakes like:
         //
         //     /**
         //      * Some doc comment.
         //      */ someFunction() { ... }
         if (linesAfter == 0 && comments.last.text.contains("\n")) {
           linesAfter = 1;
         }
       }
 
-      if (linesAfter > 0) _writeHardSplit(nest: true, double: linesAfter > 1);
+      if (linesAfter > 0) _writeHardSplit(isDouble: linesAfter > 1, nest: true);
     }
 
     // If the comment has text following it (aside from a grouping character),
     // it needs a trailing space.
     if (_needsSpaceAfterLastComment(comments, token)) {
       _pendingWhitespace = Whitespace.space;
     }
 
     preserveNewlines(linesBeforeToken);
   }
@@ skipping 56 matching lines @@
     var openSpan = _openSpans.removeLast();
 
     // A span that just covers a single chunk can't be split anyway.
     var end = _currentChunkIndex;
     if (openSpan.start == end) return;
 
     // Add the span to every chunk that can split it.
     var span = new Span(openSpan.cost);
     for (var i = openSpan.start; i < end; i++) {
       var chunk = _chunks[i];
-      if (!chunk.isHardSplit) chunk.spans.add(span);
+      if (!chunk.rule.isHardened) chunk.spans.add(span);
     }
   }
 
   /// Starts a new [Rule].
   ///
-  /// If omitted, defaults to a new [SimpleRule].
+  /// If omitted, defaults to a new [Rule].
   void startRule([Rule rule]) {
-    if (rule == null) rule = new SimpleRule();
+    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.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
   /// entire expression.
   ///
-  /// If [rule] is omitted, defaults to a new [SimpleRule].
+  /// If [rule] is omitted, defaults to a new [Rule].
   void startLazyRule([Rule rule]) {
-    if (rule == null) rule = new SimpleRule();
+    if (rule == null) rule = new Rule();
 
     _lazyRules.add(rule);
   }
 
   /// Ends the innermost rule.
   void endRule() {
     _rules.removeLast();
   }
 
   /// Pre-emptively forces all of the current rules to become hard splits.
@@ skipping 18 matching lines @@
     if (now == null) now = false;
 
     _nesting.nest(indent);
     if (now) _nesting.commitNesting();
   }
 
   /// Discards the most recent level of expression nesting.
   ///
   /// Expressions that are more nested will get increased indentation when split
   /// if the previous line has a lower level of nesting.
-  void unnest() {
+  ///
+  /// If [now] is `false`, does not commit the nesting change until after the
+  /// next chunk of text is written.
+  void unnest({bool now}) {
+    if (now == null) now = true;
+
     _nesting.unnest();
+    if (now) _nesting.commitNesting();
   }
 
   /// Marks the selection starting point as occurring [fromEnd] characters to
   /// the left of the end of what's currently been written.
   ///
   /// It counts backwards from the end because this is called *after* the chunk
   /// of text containing the selection has been output.
   void startSelectionFromEnd(int fromEnd) {
     assert(_chunks.isNotEmpty);
     _chunks.last.startSelectionFromEnd(fromEnd);
@@ skipping 16 matching lines @@
   }
 
   /// Releases the last nesting level captured by [startBlockArgumentNesting].
   void endBlockArgumentNesting() {
     _blockArgumentNesting.removeLast();
   }
 
   /// Starts a new block as a child of the current chunk.
   ///
   /// Nested blocks are handled using their own independent [LineWriter].
-  ChunkBuilder startBlock() {
+  ChunkBuilder startBlock(Chunk argumentChunk) {
+    var chunk = _chunks.last;
+    chunk.makeBlock(argumentChunk);
+
     var builder =
-        new ChunkBuilder._(this, _formatter, _source, _chunks.last.blockChunks);
+        new ChunkBuilder._(this, _formatter, _source, chunk.block.chunks);
 
     // A block always starts off indented one level.
     builder.indent();
 
     return builder;
   }
 
   /// Ends this [ChunkBuilder], which must have been created by [startBlock()].
   ///
   /// Forces the chunk that owns the block to split if it can tell that the
   /// block contents will always split. It does that by looking for hard splits
   /// in the block. If [ignoredSplit] is given, that rule will be ignored
   /// when determining if a block contains a hard split. If [forceSplit] is
   /// `true`, the block is considered to always split.
   ///
   /// Returns the previous writer for the surrounding block.
-  ChunkBuilder endBlock(HardSplitRule ignoredSplit, {bool forceSplit}) {
+  ChunkBuilder endBlock(Rule ignoredSplit, {bool forceSplit}) {
     _divideChunks();
 
     // If we don't already know if the block is going to split, see if it
     // contains any hard splits or is longer than a page.
     if (!forceSplit) {
       var length = 0;
       for (var chunk in _chunks) {
         length += chunk.length + chunk.unsplitBlockLength;
         if (length > _formatter.pageWidth) {
           forceSplit = true;
           break;
         }
 
-        if (chunk.isHardSplit && chunk.rule != ignoredSplit) {
+        if (chunk.rule != null &&
+            chunk.rule.isHardened &&
+            chunk.rule != ignoredSplit) {
           forceSplit = true;
           break;
         }
       }
     }
 
-    // If there is a hard newline within the block, force the surrounding rule
-    // for it so that we apply that constraint.
-    if (forceSplit) _parent.forceRules();
+    _parent._endChildBlock(
+        firstFlushLeft: _firstFlushLeft, forceSplit: forceSplit);
 
-    // Write the split for the block contents themselves.
-    _parent._writeSplit(_parent._rules.last, _parent._blockArgumentNesting.last,
-        flushLeft: _firstFlushLeft);
     return _parent;
   }
 
+  /// Finishes off the last chunk in a child block of this parent.
+  void _endChildBlock({bool firstFlushLeft, bool forceSplit}) {
+    // If there is a hard newline within the block, force the surrounding rule
+    // for it so that we apply that constraint.
+    if (forceSplit) forceRules();
+
+    // Write the split for the block contents themselves.
+    var chunk = _chunks.last;
+    chunk.applySplit(rule, _nesting.indentation, _blockArgumentNesting.last,
+        flushLeft: firstFlushLeft);
+
+    if (chunk.rule.isHardened) _handleHardSplit();
+  }
+
   /// Finishes writing and returns a [SourceCode] containing the final output
   /// and updated selection, if any.
   SourceCode end() {
     _writeHardSplit();
     _divideChunks();
 
     if (debug.traceChunkBuilder) {
       debug.log(debug.green("\nBuilt:"));
       debug.dumpChunks(0, _chunks);
       debug.log();
@@ skipping 38 matching lines @@
 
       case Whitespace.newline:
         _writeHardSplit();
         break;
 
       case Whitespace.nestedNewline:
         _writeHardSplit(nest: true);
         break;
 
       case Whitespace.newlineFlushLeft:
-        _writeHardSplit(nest: true, flushLeft: true);
+        _writeHardSplit(flushLeft: true, nest: true);
         break;
 
       case Whitespace.twoNewlines:
-        _writeHardSplit(double: true);
+        _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;
     }
 
@@ skipping 59 matching lines @@
         token != "]" &&
         token != "}" &&
         token != "," &&
         token != ";" &&
         token != "";
   }
 
   /// Appends a hard split with the current indentation and nesting (the latter
   /// only if [nest] is `true`).
   ///
-  /// If [double] is `true` or `false`, forces a since or double line to be
+  /// If [double] is `true` or `false`, forces a single or double line to be
   /// output. Otherwise, it is left indeterminate.
   ///
   /// If [flushLeft] is `true`, then the split will always cause the next line
   /// to be at column zero. Otherwise, it uses the normal indentation and
   /// nesting behavior.
-  void _writeHardSplit({bool nest: false, bool double, bool flushLeft}) {
+  void _writeHardSplit({bool isDouble, bool flushLeft, bool nest: false}) {
     // A hard split overrides any other whitespace.
     _pendingWhitespace = null;
-    _writeSplit(new HardSplitRule(), nest ? null : _nesting.blockNesting,
-        flushLeft: flushLeft, isDouble: double);
+    _writeSplit(new Rule.hard(),
+        flushLeft: flushLeft, isDouble: isDouble, nest: nest);
   }
 
   /// Ends the current chunk (if any) with the given split information.
   ///
   /// Returns the chunk.
-  Chunk _writeSplit(Rule rule, NestingLevel nesting,
-      {bool flushLeft, bool isDouble, bool spaceWhenUnsplit}) {
+  Chunk _writeSplit(Rule rule,
+      {bool flushLeft, bool isDouble, bool nest, bool space}) {
+    if (nest == null) nest = true;
+
     if (_chunks.isEmpty) {
       if (flushLeft != null) _firstFlushLeft = flushLeft;
 
       return null;
     }
 
-    if (nesting == null) nesting = _nesting.nesting;
+    _chunks.last.applySplit(rule, _nesting.indentation,
+        nest ? _nesting.nesting : new NestingLevel(),
+        flushLeft: flushLeft, isDouble: isDouble, space: space);
 
-    var chunk = _chunks.last;
-    chunk.applySplit(rule, _nesting.indentation, nesting,
-        flushLeft: flushLeft,
-        isDouble: isDouble,
-        spaceWhenUnsplit: spaceWhenUnsplit);
-
-    // Keep track of which chunks are owned by the rule.
-    if (rule is! HardSplitRule) {
-      _ruleChunks.putIfAbsent(rule, () => []).add(_chunks.length - 1);
-    }
-
-    if (chunk.isHardSplit) _handleHardSplit();
-
-    return chunk;
+    if (_chunks.last.rule.isHardened) _handleHardSplit();
+    return _chunks.last;
   }
 
   /// Writes [text] to either the current chunk or a new one if the current
   /// chunk is complete.
   void _writeText(String text) {
     if (_chunks.isNotEmpty && _chunks.last.canAddText) {
       _chunks.last.appendText(text);
     } else {
       _chunks.add(new Chunk(text));
     }
   }
 
   /// Returns true if we can divide the chunks at [index] and line split the
   /// ones before and after that separately.
   bool _canDivideAt(int i) {
+    // Don't divide after the last chunk.
+    if (i == _chunks.length - 1) return false;
+
     var chunk = _chunks[i];
-    if (!chunk.isHardSplit) return false;
+    if (!chunk.rule.isHardened) return false;
     if (chunk.nesting.isNested) return false;
-    if (chunk.blockChunks.isNotEmpty) return false;
-
-    // Make sure we don't split the line in the middle of a rule.
-    var chunks = _ruleChunks[chunk.rule];
-    if (chunks != null && chunks.any((other) => other > i)) return false;
+    if (chunk.isBlock) return false;
 
     return true;
   }
 
   /// Pre-processes the chunks after they are done being written by the visitor
   /// but before they are run through the line splitter.
   ///
   /// Marks ranges of chunks that can be line split independently to keep the
   /// batches we send to [LineSplitter] small.
   void _divideChunks() {
@@ skipping 21 matching lines @@
     _hardSplitRules.add(_rules.last);
   }
 
   /// Replaces all of the previously hardened rules with hard splits, along
   /// with every rule that those constrain to also split.
   ///
   /// This should only be called after all chunks have been written.
   void _hardenRules() {
     if (_hardSplitRules.isEmpty) return;
 
-    // Harden all of the rules that are constrained by [rules] as well.
-    var hardenedRules = new Set();
     walkConstraints(rule) {
-      if (hardenedRules.contains(rule)) return;
-      hardenedRules.add(rule);
+      rule.harden();
 
       // Follow this rule's constraints, recursively.
-      for (var other in _ruleChunks.keys) {
+      for (var other in rule.constrainedRules) {
         if (other == rule) continue;
 
-        if (rule.constrain(rule.fullySplitValue, other) ==
-            other.fullySplitValue) {
+        if (!other.isHardened &&
+            rule.constrain(rule.fullySplitValue, other) ==
+                other.fullySplitValue) {
           walkConstraints(other);
         }
       }
     }
 
     for (var rule in _hardSplitRules) {
       walkConstraints(rule);
     }
 
-    // Harden every chunk that uses one of these rules.
+    // Discard spans in hardened chunks since we know for certain they will
+    // split anyway.
     for (var chunk in _chunks) {
-      if (hardenedRules.contains(chunk.rule)) {
-        chunk.harden();
+      if (chunk.rule != null && chunk.rule.isHardened) {
+        chunk.spans.clear();
       }
     }
   }
 }