Create and test source mapping for invocations.

pkg/compiler/lib/src/io/source_file.dart

 // Copyright (c) 2012, 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 dart2js.io.source_file;
 
 import 'dart:math';
 import 'dart:convert' show UTF8;
 import 'dart:typed_data' show Uint8List;
 
@@ skipping 97 matching lines @@
   }
 
   /**
    * Returns the column number for the offset [position] in the string
    * representation of this source file.
    */
   int getColumn(int line, int position) {
     return position - lineStarts[line];
   }
 
+  /// Returns the offset for 0-based [line] and [column] numbers.
+  int getOffset(int line, int column) => lineStarts[line] + column;
+
   String slowSubstring(int start, int end);
 
   /**
    * Create a pretty string representation for [message] from a character
    * range `[start, end]` in this file.
    *
    * If [includeSourceLine] is `true` the first source line code line that
    * contains the range will be included as well as marker characters ('^')
    * underlining the range.
    *
@@ skipping 10 matching lines @@
     var column = getColumn(line, start);
 
     var buf = new StringBuffer('${filename}:');
     if (start != end || start != 0) {
       // Line/column info is relevant.
       buf.write('${line + 1}:${column + 1}:');
     }
     buf.write('\n$message\n');
 
     if (start != end && includeSourceLine) {
-      String textLine;
-      // +1 for 0-indexing, +1 again to avoid the last line of the file
-      if ((line + 2) < lineStarts.length) {
-        textLine = slowSubstring(lineStarts[line], lineStarts[line+1]);
-      } else {
-        textLine = '${slowSubstring(lineStarts[line], length)}\n';
-      }
+      String textLine = getLineText(line);
 
       int toColumn = min(column + (end-start), textLine.length);
       buf.write(textLine.substring(0, column));
       buf.write(colorize(textLine.substring(column, toColumn)));
       buf.write(textLine.substring(toColumn));
 
       int i = 0;
       for (; i < column; i++) {
         buf.write(' ');
       }
 
       for (; i < toColumn; i++) {
         buf.write(colorize('^'));
       }
     }
 
     return buf.toString();
   }
+
+  int get lines => lineStarts.length - 1;
+
+  /// Returns the text of line  at the 0-based [index] within this source file.
+  String getLineText(int index) {
+    // +1 for 0-indexing, +1 again to avoid the last line of the file
+    if ((index + 2) < lineStarts.length) {
+      return slowSubstring(lineStarts[index], lineStarts[index+1]);
+    } else if ((index + 1) < lineStarts.length) {
+      return '${slowSubstring(lineStarts[index], length)}\n';
+    } else {
+      throw new ArgumentError("Line index $index is out of bounds.");
+    }
+  }
 }
 
 List<int> _zeroTerminateIfNecessary(List<int> bytes) {
   if (bytes.length > 0 && bytes.last == 0) return bytes;
   List<int> result = new Uint8List(bytes.length + 1);
   result.setRange(0, bytes.length, bytes);
   result[result.length - 1] = 0;
   return result;
 }
 
@@ skipping 22 matching lines @@
 
   String slowSubstring(int start, int end) {
     // TODO(lry): to make this faster, the scanner could record the UTF-8 slack
     // for all positions of the source text. We could use [:content.sublist:].
     return slowText().substring(start, end);
   }
 
   int get length {
     if (lengthCache == -1) {
       // During scanning the length is not yet assigned, so we use a slow path.
-      length = slowText().length;
+      lengthCache = slowText().length;
     }
     return lengthCache;
   }
   set length(int v) => lengthCache = v;
   int lengthCache = -1;
 }
 
 class CachingUtf8BytesSourceFile extends Utf8BytesSourceFile {
   String cachedText;
   final String filename;
@@ skipping 26 matching lines @@
   set length(int v) { }
 
   String slowText() => text;
 
   List<int> slowUtf8ZeroTerminatedBytes() {
     return _zeroTerminateIfNecessary(UTF8.encode(text));
   }
 
   String slowSubstring(int start, int end) => text.substring(start, end);
 }