Use a more compact internal representation for FileSpan.

pkg/source_span/lib/src/file.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 source_span.file;
 
 import 'dart:math' as math;
 import 'dart:typed_data';
 
 import 'package:path/path.dart' as p;
@@ skipping 55 matching lines @@
       }
       if (c == _LF) _lineStarts.add(i + 1);
     }
   }
 
   /// Returns a span in [this] from [start] to [end] (exclusive).
   ///
   /// If [end] isn't passed, it defaults to the end of the file.
   FileSpan span(int start, [int end]) {
     if (end == null) end = length - 1;
-    return new FileSpan._(this, location(start), location(end));
+    return new FileSpan._(this, start, end);
   }
 
   /// Returns a location in [this] at [offset].
   FileLocation location(int offset) => new FileLocation._(this, offset);
 
   /// Gets the 0-based line corresponding to [offset].
   int getLine(int offset) {
     if (offset < 0) {
       throw new RangeError("Offset may not be negative, was $offset.");
     } else if (offset > length) {
@@ skipping 78 matching lines @@
   int get column => file.getColumn(offset);
 
   FileLocation._(this.file, int offset)
       : super(offset) {
     if (offset > file.length) {
       throw new RangeError("Offset $offset must not be greater than the number "
           "of characters in the file, ${file.length}.");
     }
   }
 
-  FileSpan pointSpan() => new FileSpan._(file, this, this);
+  FileSpan pointSpan() => new FileSpan._(file, offset, offset);
 }
 
 /// A [SourceSpan] within a [SourceFile].
 ///
 /// Unlike the base [SourceSpan], [FileSpan] lazily computes its line and column
 /// values based on its offset and the contents of [file]. [FileSpan.message] is
 /// also able to provide more context then [SourceSpan.message], and
 /// [FileSpan.union] will return a [FileSpan] if possible.
 ///
 /// A [FileSpan] can be created using [SourceFile.span].
 class FileSpan extends SourceSpanMixin {
   /// The [file] that [this] belongs to.
   final SourceFile file;
 
-  final FileLocation start;
-  final FileLocation end;
+  /// The offset of the beginning of the span.
+  ///
+  /// [start] is lazily generated from this to avoid allocating unnecessary
+  /// objects.
+  final int _start;
+
+  /// The offset of the end of the span.
+  ///
+  /// [end] is lazily generated from this to avoid allocating unnecessary
+  /// objects.
+  final int _end;
+
+  FileLocation get start => new FileLocation._(file, _start);
+  FileLocation get end => new FileLocation._(file, _end);
 
   String get text => file.getText(start.offset, end.offset);
 
-  FileSpan._(this.file, this.start, this.end) {
-    if (end.offset < start.offset) {
-      throw new ArgumentError('End $end must come after start $start.');
+  FileSpan._(this.file, this._start, this._end) {
+    if (_end < _start) {
+      throw new ArgumentError('End $_end must come after start $_start.');
     }
   }
 
   SourceSpan union(SourceSpan other) {
     if (other is! FileSpan) return super.union(other);
 
     var span = expand(other);
     var beginSpan = span.start == this.start ? this : other;
     var endSpan = span.end == this.end ? this : other;
 
     if (beginSpan.end.compareTo(endSpan.start) < 0) {
       throw new ArgumentError("Spans $this and $other are disjoint.");
     }
 
     return span;
   }
 
   /// Returns a new span that covers both [this] and [other].
   ///
   /// Unlike [union], [other] may be disjoint from [this]. If it is, the text
   /// between the two will be covered by the returned span.
   FileSpan expand(FileSpan other) {
     if (sourceUrl != other.sourceUrl) {
       throw new ArgumentError("Source URLs \"${sourceUrl}\" and "
           " \"${other.sourceUrl}\" don't match.");
     }
 
-    var start = min(this.start, other.start);
-    var end = max(this.end, other.end);
+    var start = math.min(this._start, other._start);
+    var end = math.max(this._end, other._end);
     return new FileSpan._(file, start, end);    
   }
 
   String message(String message, {color}) {
     if (color == true) color = colors.RED;
     if (color == false) color = null;
 
     var line = start.line;
     var column = start.column;
 
@@ skipping 20 matching lines @@
     }
     if (!textLine.endsWith('\n')) buffer.write('\n');
 
     buffer.write(' ' * column);
     if (color != null) buffer.write(color);
     buffer.write('^' * math.max(toColumn - column, 1));
     if (color != null) buffer.write(colors.NONE);
     return buffer.toString();
   }
 }