Support external implementations of FileSpan.

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;
-
-import 'colors.dart' as colors;
 import 'location.dart';
 import 'span.dart';
 import 'span_mixin.dart';
 import 'span_with_context.dart';
 import 'utils.dart';
 
 // Constants to determine end-of-lines.
 const int _LF = 10;
 const int _CR = 13;
 
@@ skipping 44 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, start, 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, offset, offset);
+  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 implements SourceSpanWithContext {
+abstract class FileSpan implements SourceSpanWithContext {
   /// The [file] that [this] belongs to.
+  SourceFile get file;
+
+  /// 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);
+}
+
+/// The implementation of [FileSpan].
+///
+/// This is split into a separate class so that `is _FileSpan` checks can be run
+/// to make certain operations more efficient. If we used `is FileSpan`, that
+/// would break if external classes implemented the interface.
+class _FileSpan extends SourceSpanMixin implements FileSpan {
   final SourceFile file;
 
   /// 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;
 
   Uri get sourceUrl => file.url;
   int get length => _end - _start;
   FileLocation get start => new FileLocation._(file, _start);
   FileLocation get end => new FileLocation._(file, _end);
   String get text => file.getText(_start, _end);
   String get context => file.getText(file.getOffset(start.line),
       end.line == file.lines - 1 ? null : file.getOffset(end.line + 1));
 
-  FileSpan._(this.file, this._start, this._end) {
+  _FileSpan(this.file, this._start, this._end) {
     if (_end < _start) {
       throw new ArgumentError('End $_end must come after start $_start.');
     } else if (_end > file.length) {
       throw new RangeError("End $_end must not be greater than the number "
           "of characters in the file, ${file.length}.");
     } else if (_start < 0) {
       throw new RangeError("Start may not be negative, was $_start.");
     }
   }
 
   int compareTo(SourceSpan other) {
-    if (other is! FileSpan) return super.compareTo(other);
+    if (other is! _FileSpan) return super.compareTo(other);
 
-    FileSpan otherFile = other;
+    _FileSpan otherFile = other;
     var result = _start.compareTo(otherFile._start);
     return result == 0 ? _end.compareTo(otherFile._end) : result;
   }
 
   SourceSpan union(SourceSpan other) {
     if (other is! FileSpan) return super.union(other);
 
-    var span = expand(other);
+    _FileSpan span = expand(other);
     var beginSpan = span._start == _start ? this : other;
     var endSpan = span._end == _end ? this : other;
 
     if (beginSpan._end < endSpan._start) {
       throw new ArgumentError("Spans $this and $other are disjoint.");
     }
 
     return span;
   }
 
   bool operator ==(other) {
     if (other is! FileSpan) return super == other;
+    if (other is! _FileSpan) {
+      return super == other && sourceUrl == other.sourceUrl;
+    }
+
     return _start == other._start && _end == other._end &&
         sourceUrl == other.sourceUrl;
   }
 
-  int get hashCode => _start.hashCode + 5 * _end.hashCode +
-      7 * sourceUrl.hashCode;
-
   /// 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 = math.min(this._start, other._start);
-    var end = math.max(this._end, other._end);
-    return new FileSpan._(file, start, end);
+    if (other is _FileSpan) {
+      var start = math.min(this._start, other._start);
+      var end = math.max(this._end, other._end);
+      return new _FileSpan(file, start, end);
+    } else {
+      var start = math.min(this._start, other.start.offset);
+      var end = math.max(this._end, other.end.offset);
+      return new _FileSpan(file, start, end);
+    }
   }
 }