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

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.source_writer;
 
 import 'dart_formatter.dart';
 import 'chunk.dart';
 import 'debug.dart';
 import 'line_splitter.dart';
 import 'multisplit.dart';
 import 'whitespace.dart';
 
-/// A comment in the source, with a bit of information about the surrounding
-/// whitespace.
-class SourceComment {
-  /// 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});
-}
-
 /// Takes the incremental serialized output of [SourceVisitor]--the source text
 /// along with any comments and preserved whitespace--and produces a coherent
 /// series 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 LineWriter {
   final DartFormatter _formatter;
 
-  final StringBuffer _buffer;
+  final SourceCode _source;
+
+  final _buffer = new StringBuffer();
 
   final _chunks = <Chunk>[];
 
   /// The whitespace that should be written to [_chunks] before the next
   ///  non-whitespace token or `null` if no whitespace is pending.
   ///
   /// This ensures that changes to indentation and nesting also apply to the
   /// most recent split, even if the visitor "creates" the split before changing
   /// indentation or nesting.
   Whitespace _pendingWhitespace;
@@ skipping 93 matching lines @@
   /// The index of the "current" chunk being written.
   ///
   /// If the last chunk is still being appended to, this is its index.
   /// Otherwise, it is the index of the next chunk which will be created.
   int get _currentChunkIndex {
     if (_chunks.isEmpty) return 0;
     if (_chunks.last.canAddText) return _chunks.length - 1;
     return _chunks.length;
   }
 
+  /// The offset in [_buffer] where the selection starts in the formatted code.
+  ///
+  /// This will be `null` if there is no selection or the writer hasn't reached
+  /// the beginning of the selection yet.
+  int _selectionStart;
+
+  /// The length in [_buffer] of the selection in the formatted code.
+  ///
+  /// This will be `null` if there is no selection or the writer hasn't reached
+  /// the end of the selection yet.
+  int _selectionLength;
+
   /// 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;
 
   /// The number of characters of code that can fit in a single line.
   int get pageWidth => _formatter.pageWidth;
 
-  LineWriter(this._formatter, this._buffer) {
+  LineWriter(this._formatter, this._source) {
     indent(_formatter.indent);
     _beginningIndent = _formatter.indent;
   }
 
   /// Writes [string], the text for a single token, to the output.
   ///
   /// By default, this also implicitly adds one level of nesting if we aren't
   /// currently nested at all. We do this here so that if a comment appears
   /// after any token within a statement or top-level form and that comment
   /// leads to splitting, we correctly nest. Even pathological cases like:
@@ skipping 103 matching lines @@
           _writeText(" ");
         }
       } else {
         // The comment starts a line, so make sure it stays on its own line.
         _writeHardSplit(nest: true, allowIndent: !comment.isStartOfLine,
             double: comment.linesBefore > 1);
       }
 
       _writeText(comment.text);
 
+      if (comment.selectionStart != null) {
+        startSelectionFromEnd(comment.text.length - comment.selectionStart);
+      }
+
+      if (comment.selectionEnd != null) {
+        endSelectionFromEnd(comment.text.length - comment.selectionEnd);
+      }
+
       // Make sure there is at least one newline after a line comment and allow
       // one or two after a block comment that has nothing after it.
       var linesAfter;
       if (i < comments.length - 1) {
         linesAfter = comments[i + 1].linesBefore;
       } else {
         linesAfter = linesBeforeToken;
 
         // Always force a newline after multi-line block comments. Prevents
         // mistakes like:
@@ skipping 134 matching lines @@
   /// Expressions that are more nested will get increased indentation when split
   /// if the previous line has a lower level of nesting.
   void unnest() {
     // By the time the nesting is done, it should have emitted some text and
     // not be pending anymore.
     assert(_pendingNesting == null);
 
     _nesting--;
   }
 
-  /// Finish writing the last line.
-  void end() {
+  /// 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);
+  }
+
+  /// Marks the selection ending 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 endSelectionFromEnd(int fromEnd) {
+    assert(_chunks.isNotEmpty);
+    _chunks.last.endSelectionFromEnd(fromEnd);
+  }
+
+  /// Finishes writing and returns a [SourceCode] containing the final output
+  /// and updated selection, if any.
+  SourceCode end() {
     if (_chunks.isNotEmpty) _completeLine();
+
+    // Be a good citizen, end with a newline.
+    if (_source.isCompilationUnit) _buffer.write(_formatter.lineEnding);
+
+    // If we haven't hit the beginning and/or end of the selection yet, they
+    // must be at the very end of the code.
+    if (_source.selectionStart != null) {
+      if (_selectionStart == null) {
+        _selectionStart = _buffer.length;
+      }
+
+      if (_selectionLength == null) {
+        _selectionLength = _buffer.length - _selectionStart;
+      }
+    }
+
+    return new SourceCode(_buffer.toString(),
+        uri: _source.uri,
+        isCompilationUnit: _source.isCompilationUnit,
+        selectionStart: _selectionStart,
+        selectionLength: _selectionLength);
   }
 
   /// Writes the current pending [Whitespace] to the output, if any.
   ///
   /// This should only be called after source lines have been preserved to turn
   /// any ambiguous whitespace into a concrete choice.
   void _emitPendingWhitespace() {
     if (_pendingWhitespace == null) return;
     // Output any pending whitespace first now that we know it won't be
     // trailing.
@@ skipping 173 matching lines @@
     if (debugFormatter) {
       dumpChunks(_chunks);
       print(_spans.join("\n"));
     }
 
     // Write the newlines required by the previous line.
     for (var i = 0; i < _bufferedNewlines; i++) {
       _buffer.write(_formatter.lineEnding);
     }
 
-    var splitter = new LineSplitter(_formatter.lineEnding,
-        _formatter.pageWidth, _chunks, _spans, _beginningIndent);
-    splitter.apply(_buffer);
+    var splitter = new LineSplitter(_formatter.lineEnding, _formatter.pageWidth,
+        _chunks, _spans, _beginningIndent);
+    var selection = splitter.apply(_buffer);
+
+    if (selection[0] != null) _selectionStart = selection[0];
+    if (selection[1] != null) _selectionLength = selection[1] - _selectionStart;
   }
 
   /// Handles multisplits when a hard line occurs.
   ///
   /// Any active separable multisplits will get split in two at this point.
   /// Other multisplits are forced into the "hard" state. All of their previous
   /// splits are turned into explicit hard splits and any new splits for that
   /// multisplit become hard splits too.
   void _splitMultisplits() {
     if (_multisplits.isEmpty) return;
@@ skipping 25 matching lines @@
       if (splitParams.contains(chunk.param)) {
         chunk.harden();
       } else {
         // If the chunk isn't hardened, but implies something that is, we can
         // discard the implication since it is always satisfied now.
         chunk.param.implies.removeWhere(splitParams.contains);
       }
     }
   }
 }