Roll Observatory deps (charted -> ^0.3.0)

packages/dart_style/lib/src/line_writer.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.line_writer;
 
 import 'chunk.dart';
 import 'dart_formatter.dart';
 import 'debug.dart' as debug;
 import 'line_splitting/line_splitter.dart';
@@ skipping 64 matching lines @@
   ///
   /// When we format the anonymous lambda, [column] will be 2, not 4.
   FormatResult formatBlock(Chunk chunk, int column) {
     var key = new _BlockKey(chunk, column);
 
     // Use the cached one if we have it.
     var cached = _blockCache[key];
     if (cached != null) return cached;
 
     var writer = new LineWriter._(
-        chunk.blockChunks, _lineEnding, pageWidth, column, _blockCache);
+        chunk.block.chunks, _lineEnding, pageWidth, column, _blockCache);
 
     // TODO(rnystrom): Passing in an initial indent here is hacky. The
     // LineWriter ensures all but the first chunk have a block indent, and this
     // handles the first chunk. Do something cleaner.
     var result = writer.writeLines(Indent.block, flushLeft: chunk.flushLeft);
     return _blockCache[key] = result;
   }
 
   /// Takes all of the chunks and divides them into sublists and line splits
   /// each list.
@@ skipping 28 matching lines @@
           flushLeft: flushLeft);
     }
 
     // Be a good citizen, end with a newline.
     if (isCompilationUnit) _buffer.write(_lineEnding);
 
     return new FormatResult(
         _buffer.toString(), totalCost, _selectionStart, _selectionEnd);
   }
 
-  /// Takes the first [length] of the chunks with leading [indent], removes
+  /// Takes the chunks from [start] to [end] with leading [indent], removes
   /// them, and runs the [LineSplitter] on them.
   int _completeLine(int newlines, int indent, int start, int end,
       {bool flushLeft}) {
     // Write the newlines required by the previous line.
     for (var j = 0; j < newlines; j++) {
       _buffer.write(_lineEnding);
     }
 
     var chunks = _chunks.sublist(start, end);
 
     if (debug.traceLineWriter) {
       debug.log(debug.green("\nWriting:"));
-      debug.dumpChunks(start, chunks);
+      debug.dumpChunks(0, chunks);
       debug.log();
     }
 
     // Run the line splitter.
     var splitter = new LineSplitter(this, chunks, _blockIndentation, indent,
         flushLeft: flushLeft);
     var splits = splitter.apply();
 
     // Write the indentation of the first line.
     if (!flushLeft) {
       _buffer.write(" " * (indent + _blockIndentation));
     }
 
     // Write each chunk with the appropriate splits between them.
     for (var i = 0; i < chunks.length; i++) {
       var chunk = chunks[i];
       _writeChunk(chunk);
 
-      if (chunk.blockChunks.isNotEmpty) {
+      if (chunk.isBlock) {
         if (!splits.shouldSplitAt(i)) {
           // This block didn't split (which implies none of the child blocks
           // of that block split either, recursively), so write them all inline.
-          _writeChunksUnsplit(chunk.blockChunks);
+          _writeChunksUnsplit(chunk);
         } else {
           // Include the formatted block contents.
           var block = formatBlock(chunk, splits.getColumn(i));
 
           // If this block contains one of the selection markers, tell the
           // writer where it ended up in the final output.
           if (block.selectionStart != null) {
             _selectionStart = length + block.selectionStart;
           }
 
@@ skipping 13 matching lines @@
 
         _buffer.write(" " * (splits.getColumn(i)));
       } else {
         if (chunk.spaceWhenUnsplit) _buffer.write(" ");
       }
     }
 
     return splits.cost;
   }
 
-  /// Writes [chunks] (and any child chunks of them, recursively) without any
-  /// splitting.
-  void _writeChunksUnsplit(List<Chunk> chunks) {
-    for (var chunk in chunks) {
-      _writeChunk(chunk);
+  /// Writes the block chunks of [chunk] (and any child chunks of them,
+  /// recursively) without any splitting.
+  void _writeChunksUnsplit(Chunk chunk) {
+    if (!chunk.isBlock) return;
 
-      if (chunk.spaceWhenUnsplit) _buffer.write(" ");
+    for (var blockChunk in chunk.block.chunks) {
+      _writeChunk(blockChunk);
+
+      if (blockChunk.spaceWhenUnsplit) _buffer.write(" ");
 
       // Recurse into the block.
-      _writeChunksUnsplit(chunk.blockChunks);
+      _writeChunksUnsplit(blockChunk);
     }
   }
 
   /// Writes [chunk] to the output and updates the selection if the chunk
   /// contains a selection marker.
   void _writeChunk(Chunk chunk) {
     if (chunk.selectionStart != null) {
       _selectionStart = length + chunk.selectionStart;
     }
 
@@ skipping 44 matching lines @@
   final int selectionStart;
 
   /// Where in the resulting buffer the selection end point should appear if it
   /// was contained within this split list of chunks.
   ///
   /// Otherwise, this is `null`.
   final int selectionEnd;
 
   FormatResult(this.text, this.cost, this.selectionStart, this.selectionEnd);
 }