Improve precision of stacktrace_test

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';
@@ skipping 51 matching lines @@
   }
 }
 ''',
   '''
 import 'package:expect/expect.dart';
 main() {
   var c = @{1:main}new Class();
 }
 class Class {
   @NoInline()
-  Class() {
-    @{2:Class}throw '$EXCEPTION_MARKER';
+  @{2:Class}Class() {
+    @{3:Class}throw '$EXCEPTION_MARKER';
   }
 }
 ''',
   '''
 import 'package:expect/expect.dart';
 main() {
   @{1:main}test();
 }
 @NoInline()
 test() {
@@ skipping 38 matching lines @@
 @NoInline()
 test(c) {
   @{2:test}c.field.method();
 }
 class Class {
   var field;
 }
 ''',
   '''
 import 'package:expect/expect.dart';
+class MyType {
+  get length => 3; // ensures we build an interceptor for `.length`
+}
+
+main() {
+  confuse('').trim(); // includes some code above the interceptors
+  confuse([]).length;
+  confuse(new MyType()).length;
+  // TODO(johnniwinther): Intercepted access should point to 'length':
+  @{1:main}confuse(null).length; // called through the interceptor
+}
+
+@NoInline()
+confuse(x) => x;''',
+  '''
+import 'package:expect/expect.dart';
 main() {
   // This call is no longer on the stack when the error is thrown.
   @{:main}test();
 }
 @NoInline()
 test() async {
   @{1:test}throw '$EXCEPTION_MARKER';
 }
 ''',
   '''
@@ skipping 29 matching lines @@
 import 'package:expect/expect.dart';
 main() {
   // This call is no longer on the stack when the error is thrown.
   @{:main}test();
 }
 test() async {
   var c = @{1:test}new Class();
 }
 class Class {
   @NoInline()
-  Class() {
-    @{2:Class}throw '$EXCEPTION_MARKER';
+  @{2:Class}Class() {
+    @{3:Class}throw '$EXCEPTION_MARKER';
   }
 }
 ''',
 ];
 
 class Test {
   final String code;
   final List<StackTraceLine> expectedLines;
   final List<StackTraceLine> unexpectedLines;
 
@@ skipping 25 matching lines @@
   List<StackTraceLine> expectedLines = <StackTraceLine>[];
   for (int stackTraceIndex in (stackTraceMap.keys.toList()..sort()).reversed) {
     expectedLines.add(stackTraceMap[stackTraceIndex]);
   }
   return new Test(annotatedCode.sourceCode, expectedLines, unexpectedLines);
 }
 
 void main(List<String> arguments) {
   bool verbose = false;
   bool printJs = false;
+  bool writeJs = false;
   List<int> indices;
   for (String arg in arguments) {
     if (arg == '-v') {
       verbose = true;
     } else if (arg == '--print-js') {
       printJs = true;
+    } else if (arg == '--write-js') {
+      writeJs = true;
     } else {
       int index = int.parse(arg, onError: (_) => null);
       if (index != null) {
         indices ??= <int>[];
         if (index < 0 || index >= TESTS.length) {
           print('Index $index out of bounds: [0;${TESTS.length - 1}]');
         } else {
           indices.add(index);
         }
       }
     }
   }
   if (indices == null) {
     indices = new List<int>.generate(TESTS.length, (i) => i);
   }
   asyncTest(() async {
     for (int index in indices) {
       await runTest(index, processTestCode(TESTS[index]),
-          printJs: printJs, verbose: verbose);
+          printJs: printJs, writeJs: writeJs, verbose: verbose);
     }
   });
 }
 
 Future runTest(int index, Test test,
-    {bool printJs: false, bool verbose: false}) async {
+    {bool printJs: false, bool writeJs, bool verbose: false}) async {
   Directory tmpDir = await createTempDir();
   String input = '${tmpDir.path}/$INPUT_FILE_NAME';
   new File(input).writeAsStringSync(test.code);
   String output = '${tmpDir.path}/out.js';
   List<String> arguments = [
     '-o$output',
     '--library-root=sdk',
     '--packages=${Platform.packageConfig}',
     Flags.useNewSourceInfo,
     input,
   ];
   print("--$index------------------------------------------------------------");
   print("Compiling dart2js ${arguments.join(' ')}\n${test.code}");
   CompilationResult compilationResult = await entry.internalMain(arguments);
   Expect.isTrue(compilationResult.isSuccess,
       "Unsuccessful compilation of test:\n${test.code}");
-  CompilerImpl compiler = compilationResult.compiler;
-  SingleMapping sourceMap = new SingleMapping.fromJson(
-      JSON.decode(new File('$output.map').readAsStringSync()));
+  String sourceMapText = new File('$output.map').readAsStringSync();
+  SingleMapping sourceMap =
+      new SingleMapping.fromJson(JSON.decode(sourceMapText));

[Siggi Cherem (dart-lang), 2017/01/26 19:22:18]

nit: you should be able to do:

SingleMapping sourceMap = parse(sourceMapText);
// `parse` is defined in source_maps.dart

[Johnni Winther, 2017/01/27 08:08:13]

Done.

 
   if (printJs) {
     print('JavaScript output:');
     print(new File(output).readAsStringSync());
   }
+  if (writeJs) {
+    new File('out.js').writeAsStringSync(new File(output).readAsStringSync());
+    new File('out.js.map').writeAsStringSync(sourceMapText);
+  }
   print("Running d8 $output");
   ProcessResult runResult = Process.runSync(d8executable,
       ['sdk/lib/_internal/js_runtime/lib/preambles/d8.js', output]);
   String out = '${runResult.stderr}\n${runResult.stdout}';
   if (verbose) {
     print('d8 output:');
     print(out);
   }
   List<String> lines = out.split(new RegExp(r'(\r|\n|\r\n)'));
   List<StackTraceLine> jsStackTrace = <StackTraceLine>[];
@@ skipping 12 matching lines @@
     } else {
       String methodName;
       if (targetEntry.sourceNameId != null) {
         methodName = sourceMap.names[targetEntry.sourceNameId];
       }
       String fileName;
       if (targetEntry.sourceUrlId != null) {
         fileName = sourceMap.urls[targetEntry.sourceUrlId];
       }
       dartStackTrace.add(new StackTraceLine(methodName, fileName,
-          targetEntry.sourceLine + 1, targetEntry.sourceColumn + 1));
+          targetEntry.sourceLine + 1, targetEntry.sourceColumn + 1,
+          isMapped: true));
     }
   }
 
   int expectedIndex = 0;
   List<StackTraceLine> unexpectedLines = <StackTraceLine>[];
+  List<StackTraceLine> unexpectedBeforeLines = <StackTraceLine>[];
+  List<StackTraceLine> unexpectedAfterLines = <StackTraceLine>[];
   for (StackTraceLine line in dartStackTrace) {
+    bool found = false;
     if (expectedIndex < test.expectedLines.length) {
       StackTraceLine expectedLine = test.expectedLines[expectedIndex];
       if (line.methodName == expectedLine.methodName &&
           line.lineNo == expectedLine.lineNo &&
           line.columnNo == expectedLine.columnNo) {
+        found = true;
         expectedIndex++;
       }
     }
     for (StackTraceLine unexpectedLine in test.unexpectedLines) {
       if (line.methodName == unexpectedLine.methodName &&
           line.lineNo == unexpectedLine.lineNo &&
           line.columnNo == unexpectedLine.columnNo) {
         unexpectedLines.add(line);
       }
     }
+    if (line.isMapped && !found) {
+      List<LineException> exceptions =
+          expectedIndex == 0 ? beforeExceptions : afterExceptions;
+      for (LineException exception in exceptions) {
+        if (line.methodName == exception.methodName &&
+            line.fileName.endsWith(exception.fileName)) {
+          found = true;
+        }
+      }
+      if (!found) {
+        if (expectedIndex == 0) {
+          unexpectedBeforeLines.add(line);
+        } else {
+          unexpectedAfterLines.add(line);
+        }
+      }
+    }
   }
   if (verbose) {
     print('JavaScript stacktrace:');
     print(jsStackTrace.join('\n'));
     print('Dart stacktrace:');
     print(dartStackTrace.join('\n'));
   }
   Expect.equals(
       expectedIndex,
       test.expectedLines.length,
       "Missing stack trace lines for test:\n${test.code}\n"
       "Actual:\n${dartStackTrace.join('\n')}\n"
       "Expected:\n${test.expectedLines.join('\n')}\n");
   Expect.isTrue(
       unexpectedLines.isEmpty,
       "Unexpected stack trace lines for test:\n${test.code}\n"
       "Actual:\n${dartStackTrace.join('\n')}\n"
       "Unexpected:\n${test.unexpectedLines.join('\n')}\n");
+  Expect.isTrue(
+      unexpectedBeforeLines.isEmpty && unexpectedAfterLines.isEmpty,
+      "Unexpected stack trace lines:\n${test.code}\n"
+      "Actual:\n${dartStackTrace.join('\n')}\n"
+      "Unexpected before:\n${unexpectedBeforeLines.join('\n')}\n"
+      "Unexpected after:\n${unexpectedAfterLines.join('\n')}\n");
 
   print("Deleting '${tmpDir.path}'.");
   tmpDir.deleteSync(recursive: true);
 }
 
 class StackTraceLine {
   String methodName;
   String fileName;
   int lineNo;
   int columnNo;
+  bool isMapped;
 
-  StackTraceLine(this.methodName, this.fileName, this.lineNo, this.columnNo);
+  StackTraceLine(this.methodName, this.fileName, this.lineNo, this.columnNo,
+      {this.isMapped: false});
 
   /// Creates a [StackTraceLine] by parsing a d8 stack trace line [text]. The
   /// expected formats are
   ///
   ///     at <methodName>(<fileName>:<lineNo>:<columnNo>)
   ///     at <methodName>(<fileName>:<lineNo>)
   ///     at <methodName>(<fileName>)
   ///     at <fileName>:<lineNo>:<columnNo>
   ///     at <fileName>:<lineNo>
   ///     at <fileName>
@@ skipping 94 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.');
 }
+
+/// A line allowed in the mapped stack trace.
+class LineException {
+  final String methodName;
+  final String fileName;
+
+  const LineException(this.methodName, this.fileName);
+}
+
+/// Lines allowed before the intended stack trace. Typically from helper
+/// methods.
+const List<LineException> beforeExceptions = const [
+  const LineException('wrapException', 'js_helper.dart'),
+];
+
+/// Lines allowed after the intended stack trace. Typically from the event
+/// queue.
+const List<LineException> afterExceptions = const [
+  const LineException('_wrapJsFunctionForAsync', 'async_patch.dart'),
+  const LineException(
+      '_wrapJsFunctionForAsync.<anonymous function>', 'async_patch.dart'),
+  const LineException(
+      '_awaitOnObject.<anonymous function>', 'async_patch.dart'),
+  const LineException('_RootZone.runUnary', 'zone.dart'),
+  const LineException('_FutureListener.handleValue', 'future_impl.dart'),
+  const LineException(
+      '_Future._propagateToListeners.handleValueCallback', 'future_impl.dart'),
+  const LineException('_Future._propagateToListeners', 'future_impl.dart'),
+  const LineException(
+      '_Future._addListener.<anonymous function>', 'future_impl.dart'),
+];