Fixes in sourcemaps discovered in csslib

pkg/source_maps/lib/span.dart

 // Copyright (c) 2013, 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.
 
 /// Dart classes representing the souce spans and source files.
 library source_maps.span;
 
 import 'dart:utf' show stringToCodepoints;
 import 'dart:math' show min, max;
 
@@ skipping 201 matching lines @@
   Span span(int start, [int end, bool isIdentifier = false]) =>
       new FileSpan(this, start, end, isIdentifier);
 
   /// Returns a location in this [SourceFile] with the given offset.
   Location location(int offset) => new FileLocation(this, offset);
 
   /// Gets the 0-based line corresponding to an offset.
   int getLine(int offset) => binarySearch(_lineStarts, (o) => o > offset) - 1;
 
   /// Gets the 0-based column corresponding to an offset.
-  int getColumn(int line, int offset) => offset - _lineStarts[line];
+  int getColumn(int line, int offset) {
+    if (line < 0 || line >= _lineStarts.length) return 0;
+    return offset - _lineStarts[line];
+  }
 
   /// Get the offset for a given line and column
-  int getOffset(int line, int column) =>
-      _lineStarts[max(min(line, _lineStarts.length - 1), 0)] + column;
+  int getOffset(int line, int column) {
+    if (line < 0) return getOffset(0, 0);
+    if (line < _lineStarts.length) {
+      return _lineStarts[line] + column;
+    } else {
+      return _decodedChars.length;
+    }
+  }
 
   /// Gets the text at the given offsets.
   String getText(int start, [int end]) =>
       new String.fromCharCodes(_decodedChars.sublist(max(start, 0), end));
 
   /// Create a pretty string representation from a span.
   String getLocationMessage(String message, int start, int end,
       {bool useColors: false, String color}) {
     // TODO(jmesserly): it would be more useful to pass in an object that
     // controls how the errors are printed. This method is a bit too smart.
     var line = getLine(start);
     var column = getColumn(line, start);
 
     var src = url == null ? '' : url;
     var msg = '$src:${line + 1}:${column + 1}: $message';
 
     if (_decodedChars == null) {
       // We don't have any text to include, so exit.
       return msg;
     }
 
     var buf = new StringBuffer(msg);
     buf.write('\n');
 
     // +1 for 0-indexing, +1 again to avoid the last line
     var textLine = getText(getOffset(line, 0), getOffset(line + 1, 0));
 
-
     column = min(column, textLine.length - 1);
     int toColumn = min(column + end - start, textLine.length);
     if (useColors) {
       if (color == null) {
         color = _RED_COLOR;
       }
       buf.write(textLine.substring(0, column));
       buf.write(color);
       buf.write(textLine.substring(column, toColumn));
       buf.write(_NO_COLOR);
       buf.write(textLine.substring(toColumn));
     } else {
       buf.write(textLine);
+      if (textLine != '' && !textLine.endsWith('\n')) buf.write('\n');
     }
 
     int i = 0;
     for (; i < column; i++) {
       buf.write(' ');
     }
 
     if (useColors) buf.write(color);
     for (; i < toColumn; i++) {
       buf.write('^');
     }
     if (useColors) buf.write(_NO_COLOR);
     return buf.toString();
   }
 }
 
 /// A convenience type to treat a code segment as if it were a separate
 /// [SourceFile]. A [SourceFileSegment] shifts all locations by an offset, which
 /// allows you to set source-map locations based on the locations relative to
 /// the start of the segment, but that get translated to absolute locations in
 /// the original source file.
 class SourceFileSegment extends SourceFile {
   final int _baseOffset;
   final int _baseLine;
   final int _baseColumn;
+  final int _maxOffset;
 
-  // TODO(sigmund): consider providing an end-offset to correctly truncate
-  // values passed the end of the segment.
   SourceFileSegment(String url, String textSegment, Location startOffset)
       : _baseOffset = startOffset.offset,
         _baseLine = startOffset.line,
         _baseColumn = startOffset.column,
+        _maxOffset = startOffset.offset + textSegment.length,
         super.text(url, textSegment);
 
   /// Craete a span, where [start] is relative to this segment's base offset.
   /// The returned span stores the real offset on the file, so that error
   /// messages are reported at the real location.
   Span span(int start, [int end, bool isIdentifier = false]) =>
       super.span(start + _baseOffset,
           end == null ? null : end + _baseOffset, isIdentifier);
 
   /// Create a location, where [offset] relative to this segment's base offset.
   /// The returned span stores the real offset on the file, so that error
   /// messages are reported at the real location.
   Location location(int offset) => super.location(offset + _baseOffset);
 
   /// Return the line on the underlying file associated with the [offset] of the
   /// underlying file. This method operates on the real offsets from the
-  /// original file, so that error messages can be reported accurately.
-  int getLine(int offset) =>
-      super.getLine(max(offset - _baseOffset, 0)) + _baseLine;
+  /// original file, so that error messages can be reported accurately. When the
+  /// requested offset is past the length of the segment, this returns the line
+  /// number after the end of the segment (total lines + 1).
+  int getLine(int offset) {
+    var res = super.getLine(max(offset - _baseOffset, 0)) + _baseLine;
+    return (offset > _maxOffset) ? res + 1 : res;
+  }
 
   /// Return the column on the underlying file associated with [line] and
   /// [offset], where [line] is absolute from the beginning of the underlying
   /// file. This method operates on the real offsets from the original file, so
   /// that error messages can be reported accurately.
   int getColumn(int line, int offset) {
     var col = super.getColumn(line - _baseLine, max(offset - _baseOffset, 0));
     return line == _baseLine ? col + _baseColumn : col;
   }
 
   /// Return the offset associated with a line and column. This method operates
   /// on the real offsets from the original file, so that error messages can be
   /// reported accurately.
   int getOffset(int line, int column) =>
-      super.getOffset(line - _baseLine,
-         line == _baseLine ? column - _baseColumn : column) + _baseOffset;
+    super.getOffset(line - _baseLine,
+        line == _baseLine ? column - _baseColumn : column) + _baseOffset;
 
   /// Retrieve the text associated with the specified range. This method
   /// operates on the real offsets from the original file, so that error
   /// messages can be reported accurately.
   String getText(int start, [int end]) =>
-      super.getText(start - _baseOffset,
-          end == null ? null : end - _baseOffset);
+    super.getText(start - _baseOffset, end == null ? null : end - _baseOffset);
 }