Add API to provide a selection range, and return the updated selection after formatting.

lib/src/chunk.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;
 
 import 'debug.dart';
 
+/// Tracks where a selection start or end point may appear in some piece of
+/// text.
+abstract class Selection {
+  /// The chunk of text.
+  String get text;
+
+  /// The offset from the beginning of [text] where the selection starts, or
+  /// `null` if the selection does not start within this chunk.
+  int get selectionStart => _selectionStart;
+  int _selectionStart;
+
+  /// The offset from the beginning of [text] where the selection ends, or
+  /// `null` if the selection does not start within this chunk.
+  int get selectionEnd => _selectionEnd;
+  int _selectionEnd;
+
+  /// Sets [selectionStart] to be [start] characters into [text].
+  void startSelection(int start) {
+    _selectionStart = start;
+  }
+
+  /// Sets [selectionStart] to be [fromEnd] characters from the end of [text].
+  void startSelectionFromEnd(int fromEnd) {
+    _selectionStart = text.length - fromEnd;
+  }
+
+  /// Sets [selectionEnd] to be [end] characters into [text].
+  void endSelection(int end) {
+    _selectionEnd = end;
+  }
+
+  /// Sets [selectionEnd] to be [fromEnd] characters from the end of [text].
+  void endSelectionFromEnd(int fromEnd) {
+    _selectionEnd = text.length - fromEnd;
+  }
+}
+
 /// A chunk of non-breaking output text terminated by a hard or soft newline.
 ///
 /// Chunks are created by [LineWriter] and fed into [LineSplitter]. Each
 /// contains some text, along with the data needed to tell how the next line
 /// should be formatted and how desireable it is to split after the chunk.
 ///
 /// Line splitting after chunks comes in a few different forms.
 ///
 /// *   A "hard" split is a mandatory newline. The formatted output will contain
 ///     at least one newline after the chunk's text.
 /// *   A "soft" split is a discretionary newline. If a line doesn't fit within
 ///     the page width, one or more soft splits may be turned into newlines to
 ///     wrap the line to fit within the bounds. If a soft split is not turned
 ///     into a newline, it may instead appear as a space or zero-length string
 ///     in the output, depending on [spaceWhenUnsplit].
 /// *   A "double" split expands to two newlines. In other words, it leaves a
 ///     blank line in the output. Hard or soft splits may be doubled. This is
 ///     determined by [isDouble].
 ///
 /// A split controls the leading spacing of the subsequent line, both
 /// block-based [indent] and expression-wrapping-based [nesting].
-class Chunk {
+class Chunk extends Selection {
   /// The literal text output for the chunk.
   String get text => _text;
   String _text;
 
   /// The indentation level of the line following this chunk.
   ///
   /// Note that this is not a relative indentation *offset*. It's the full
   /// indentation. When a chunk is newly created from text, this is `null` to
   /// indicate that the chunk has no splitting information yet.
   int get indent => _indent;
@@ skipping 231 matching lines @@
       result += " - $end";
     } else {
       result += "...";
     }
 
     if (cost != null) result += " \$$cost";
 
     return result + ")";
   }
 }
+
+/// A comment in the source, with a bit of information about the surrounding
+/// whitespace.
+class SourceComment extends Selection {
+  /// The text of the comment, including `//`, `/*`, and `*/`.
+  final String text;
+
+  /// The number of newlines between the comment or token preceding this comment
+  /// and the beginning of this one.
+  ///
+  /// Will be zero if the comment is a trailing one.
+  final int linesBefore;
+
+  /// Whether this comment is a line comment.
+  final bool isLineComment;
+
+  /// Whether this comment starts at column one in the source.
+  ///
+  /// Comments that start at the start of the line will not be indented in the
+  /// output. This way, commented out chunks of code do not get erroneously
+  /// re-indented.
+  final bool isStartOfLine;
+
+  SourceComment(this.text, this.linesBefore,
+      {this.isLineComment, this.isStartOfLine});
+}