Provide source map info for simple async methods.

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 '../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';
 }
 ''',
   '''
+import 'package:expect/expect.dart';
 main() {
   @{1:main}test();
 }
+@NoInline()
 test() {
   @{2:test}throw '$EXCEPTION_MARKER';
 }
 ''',
   '''
+import 'package:expect/expect.dart';
 main() {
   @{1:main}Class.test();
 }
 class Class {
+  @NoInline()
   static test() {
     @{2:Class.test}throw '$EXCEPTION_MARKER';
   }
 }
 ''',
   '''
+import 'package:expect/expect.dart';
 main() {
   var c = new Class();
   c.@{1:main}test();
 }
 class Class {
+  @NoInline()
   test() {
     @{2:Class.test}throw '$EXCEPTION_MARKER';
   }
 }
 ''',
   '''
 import 'package:expect/expect.dart';
 main() {
   var c = @{1:main}new Class();
 }
 class Class {
   @NoInline()
   Class() {
     @{2:Class}throw '$EXCEPTION_MARKER';
   }
 }
 ''',
+  '''
+import 'package:expect/expect.dart';
+main() {
+  @{1:main}test();
+}
+@NoInline()
+test() {
+  try {
+    @{2:test}throw '$EXCEPTION_MARKER';
+  } finally {
+  }
+}
+''',
+  '''
+import 'package:expect/expect.dart';
+main() {
+  @{1:main}test();
+}
+@NoInline()
+test() {
+  try {
+    @{2:test}throw '$EXCEPTION_MARKER';
+  } on Error catch (e) {
+  }
+}
+''',
+  '''
+import 'package:expect/expect.dart';
+main() {
+  @{1:main}test();
+}
+@NoInline()
+test() {
+  try {
+    @{2:test}throw '$EXCEPTION_MARKER';
+  } on String catch (e) {
+    rethrow;
+  }
+}
+''',
+  '''
+import 'package:expect/expect.dart';
+main() {
+  test(); // This call is no longer on the stack when the error is thrown.
+}
+@NoInline()
+test() async {
+  @{1:test}throw '$EXCEPTION_MARKER';
+}
+''',
+  '''
+import 'package:expect/expect.dart';
+main() {
+  test1();
+}
+@NoInline()
+test1() async {
+  // This call is no longer on the stack when the error is thrown.

[Siggi Cherem (dart-lang), 2016/11/17 15:20:54]

if you are relying on this, consider adding one extra async step just in case,
maybe a `await new Future(() {}))`.

The reason is that I believe Florian is experimenting with making async methods
return a sync future and not introduce an extra microtask. In that case, the
call to test2() will still be in the stack.

[Johnni Winther, 2016/11/18 08:22:08]

I'd rather have the test fail if this changes. Having the call test2 on the
stack would highly improve the quality of the stack trace.

[Siggi Cherem (dart-lang), 2016/11/18 15:31:38]

At that point we would be only testing exceptions that happen before we unwind
the stack, so it would be equivalent to a stack trace where test1/test2 are not
marked async, right?

Do you also want to test that the stack traces are good if the exception is
thrown after the stack has been unwound?

[Johnni Winther, 2016/11/21 08:44:20]

Yes. I realize that the test wouldn't break from some a change since we only
test existence of the annotated positions.
Not in itself, only boundary cases. I'll update the test to test for positions
expected not to be present.

+  await test2();
+}
+@NoInline()
+test2() async {
+  @{1:test2}throw '$EXCEPTION_MARKER';
+}
+''',
+  '''
+import 'package:expect/expect.dart';
+main() {
+  test1();
+}
+@NoInline()
+test1() async {
+  @{1:test1}test2();
+}
+@NoInline()
+test2() {
+  @{2:test2}throw '$EXCEPTION_MARKER';
+}
+''',
 ];
 
 class Test {
   final String code;
   final List<StackTraceLine> expectedLines;
 
   Test(this.code, this.expectedLines);
 }
 
 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>{};
   int index = 0;
   int lineNo = 1;
   int columnNo = 1;
   while (index < code.length) {
     int charCode = code.codeUnitAt(index);
     switch (charCode) {
       case _LF:
@@ skipping 34 matching lines @@
   List<StackTraceLine> expectedLines = <StackTraceLine>[];
   for (int stackTraceIndex in (stackTraceMap.keys.toList()..sort()).reversed) {
     expectedLines.add(stackTraceMap[stackTraceIndex]);
   }
   return new Test(codeBuffer.toString(), expectedLines);
 }
 
 void main(List<String> arguments) {
   asyncTest(() async {
     for (String code in TESTS) {
-      await runTest(processTestCode(code));
+      await runTest(processTestCode(code), verbose: arguments.contains('-v'));
     }
   });
 }
 
-Future runTest(Test test) async {
+Future runTest(Test test, {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("--------------------------------------------------------------------");
   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()));
 
   print("Running d8 $output");
-  ProcessResult runResult =
-      Process.runSync(d8executable, [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>[];
   bool seenMarker = false;
   for (String line in lines) {
     if (seenMarker) {
       line = line.trim();
       if (line.startsWith('at ')) {
         jsStackTrace.add(new StackTraceLine.fromText(line));
       }
     } else if (line == EXCEPTION_MARKER) {
@@ skipping 25 matching lines @@
   for (StackTraceLine line in dartStackTrace) {
     if (expectedIndex < test.expectedLines.length) {
       StackTraceLine expectedLine = test.expectedLines[expectedIndex];
       if (line.methodName == expectedLine.methodName &&
           line.lineNo == expectedLine.lineNo &&
           line.columnNo == expectedLine.columnNo) {
         expectedIndex++;
       }
     }
   }
+  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");
 
   print("Deleting '${tmpDir.path}'.");
   tmpDir.deleteSync(recursive: true);
 }
@@ skipping 111 matching lines @@
 /// Returns the path of the d8 executable.
 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.');
-}
+}