Improve handling of locations not from the uris the source map is for.

lib/parser.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.
 
 /// Contains the top-level function to parse source maps version 3.
 library source_maps.parser;
 
 import 'dart:collection';
 import 'dart:convert';
 
@@ skipping 195 matching lines @@
       throw new ArgumentError.notNull('uri');
     }
     if (_mappings.containsKey(uri)) {
       return _mappings[uri].spanFor(line, column, files: files, uri: uri);
     }
     // Fall back to looking up the source map on just the basename.
     var name = path.basename(uri.toString());
     if (_mappings.containsKey(name)) {
       return _mappings[name].spanFor(line, column, files: files, uri: name);
     }
-    return null;
+    // The uri doesn't have a source map so create a SourceMapSpan matching
+    // the input location as well as possible. Fake the file offset because

[Siggi Cherem (dart-lang), 2016/12/09 16:38:38]

nits:
- input and output is a bit confusing here. it's the input to this function, but
normally we refer to is as the output file.
- consider splitting the discussion of fake offsets to a separate paragraph.

One possible suggestion:

// Note: when there is no source map for an uri, this behaves like an
// identity function, returning the requested location as the result.

// Create a mock offset for the output location. We compute it in terms
// of the input line and column to minimize the chances that two different
// line and column locations are mapped to the same offset.

[Jacob, 2016/12/09 17:18:03]

Done.

+    // we don't really know it. This fake offset avoids locations with the
+    // same offset but different lines and columns.
+    var offset = line * 1000000000 + column;

[Siggi Cherem (dart-lang), 2016/12/09 16:38:38]

wow, 1 billion! that's a very long line :)

Can we make it smaller? I think the chances of this being an issue are pretty
low if you use something like 1000. It would be nice to use a number that is
likely going to fit in 32 bit.

[Jacob, 2016/12/09 17:18:03]

Switched to a million. Note that SourceMapSpan does identity comparisons based
on just the offset so it is a bit scary that there could be collisions.

+    var location = new SourceLocation(offset,
+        line: line, column: column, sourceUrl: Uri.parse(uri));
+    return new SourceMapSpan(location, location, "");
   }
 }
 
 /// A map containing direct source mappings.
 class SingleMapping extends Mapping {
   /// Source urls used in the mapping, indexed by id.
   final List<String> urls;
 
   /// Source names used in the mapping, indexed by id.
   final List<String> names;
@@ skipping 374 matching lines @@
   static const _TokenKind EOF = const _TokenKind(isEof: true);
   static const _TokenKind VALUE = const _TokenKind();
   final bool isNewLine;
   final bool isNewSegment;
   final bool isEof;
   bool get isValue => !isNewLine && !isNewSegment && !isEof;
 
   const _TokenKind(
       {this.isNewLine: false, this.isNewSegment: false, this.isEof: false});
 }