Add inference test functionality based on code point id.

tests/compiler/dart2js/sourcemaps/stacktrace_test.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/compiler_new.dart';
 import 'package:compiler/src/apiimpl.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/dart2js.dart' as entry;
 import 'package:expect/expect.dart';
 import 'package:source_maps/source_maps.dart';
 import 'package:source_maps/src/utils.dart';
 
+import '../annotated_code_helper.dart';
 import '../source_map_validator_helper.dart';
 
 const String EXCEPTION_MARKER = '>ExceptionMarker<';
 const String INPUT_FILE_NAME = 'in.dart';
 
 const List<String> TESTS = const <String>[
   '''
 main() {
   @{1:main}throw '$EXCEPTION_MARKER';
 }
@@ skipping 149 matching lines @@
   final List<StackTraceLine> unexpectedLines;
 
   Test(this.code, this.expectedLines, this.unexpectedLines);
 }
 
 const int _LF = 0x0A;
 const int _CR = 0x0D;
 const int _LBRACE = 0x7B;
 
 Test processTestCode(String code) {
-  StringBuffer codeBuffer = new StringBuffer();
   Map<int, StackTraceLine> stackTraceMap = <int, StackTraceLine>{};
   List<StackTraceLine> unexpectedLines = <StackTraceLine>[];
-  int index = 0;
-  int lineNo = 1;
-  int columnNo = 1;
-  while (index < code.length) {
-    int charCode = code.codeUnitAt(index);
-    switch (charCode) {
-      case _LF:
-        codeBuffer.write('\n');
-        lineNo++;
-        columnNo = 1;
-        break;
-      case _CR:
-        if (index + 1 < code.length && code.codeUnitAt(index + 1) == _LF) {
-          index++;
-        }
-        codeBuffer.write('\n');
-        lineNo++;
-        columnNo = 1;
-        break;
-      case 0x40:
-        if (index + 1 < code.length && code.codeUnitAt(index + 1) == _LBRACE) {
-          int colonIndex = code.indexOf(':', index);
-          int endIndex = code.indexOf('}', index);
-          String methodName = code.substring(colonIndex + 1, endIndex);
-          String indexText = code.substring(index + 2, colonIndex);
-          StackTraceLine stackTraceLine =
-              new StackTraceLine(methodName, INPUT_FILE_NAME, lineNo, columnNo);
-          if (indexText == '') {
-            unexpectedLines.add(stackTraceLine);
-          } else {
-            int stackTraceIndex = int.parse(indexText);
-            assert(!stackTraceMap.containsKey(stackTraceIndex));
-            stackTraceMap[stackTraceIndex] = stackTraceLine;
-          }
-          index = endIndex;
-        } else {
-          codeBuffer.writeCharCode(charCode);
-          columnNo++;
-        }
-        break;
-      default:
-        codeBuffer.writeCharCode(charCode);
-        columnNo++;
+  AnnotatedCode annotatedCode = new AnnotatedCode(code);
+  for (Annotation annotation in annotatedCode.annotations) {
+    int colonIndex = annotation.text.indexOf(':');
+    String indexText = annotation.text.substring(0, colonIndex);
+    String methodName = annotation.text.substring(colonIndex + 1);
+    StackTraceLine stackTraceLine = new StackTraceLine(
+        methodName, INPUT_FILE_NAME, annotation.lineNo, annotation.columnNo);
+    if (indexText == '') {
+      unexpectedLines.add(stackTraceLine);
+    } else {
+      int stackTraceIndex = int.parse(indexText);
+      assert(!stackTraceMap.containsKey(stackTraceIndex));
+      stackTraceMap[stackTraceIndex] = stackTraceLine;
     }
-    index++;
   }
   List<StackTraceLine> expectedLines = <StackTraceLine>[];
   for (int stackTraceIndex in (stackTraceMap.keys.toList()..sort()).reversed) {
     expectedLines.add(stackTraceMap[stackTraceIndex]);
   }
-  return new Test(codeBuffer.toString(), expectedLines, unexpectedLines);
+  return new Test(annotatedCode.sourceCode, expectedLines, unexpectedLines);
 }
 
 void main(List<String> arguments) {
   bool verbose = false;
   bool printJs = false;
   List<int> indices;
   for (String arg in arguments) {
     if (arg == '-v') {
       verbose = true;
     } else if (arg == '--print-js') {
@@ skipping 244 matching lines @@
 String get d8executable {
   if (Platform.isWindows) {
     return 'third_party/d8/windows/d8.exe';
   } else if (Platform.isLinux) {
     return 'third_party/d8/linux/d8';
   } else if (Platform.isMacOS) {
     return 'third_party/d8/macos/d8';
   }
   throw new UnsupportedError('Unsupported platform.');
 }