Improve how we report unittest failures by stripping out the commented input code

Improve how we report unittest failures by stripping out the commented input code

R=asgerf@google.com

Committed: https://github.com/dart-lang/sdk/commit/7fbd3c5f35b24846911830282026cb73d50a9381

[Siggi Cherem (dart-lang), 2016-02-18 18:35:55]

sigmund@google.com changed reviewers:
+ asgerf@google.com, het@google.com

[Siggi Cherem (dart-lang), 2016-02-18 18:35:55]

This changes from an error message to avoid repeating the input 3 times. So
instead of an error like (A), you'd get one one like (B):

(A):

Unhandled exception:
Expect.fail('Unexpected output for test:
  // Method to test: function(test)
  import 'package:expect/expect.dart';
  
  // This example illustrates a case we wish to do better in terms of inlining
and
  // code generation.
  //
  // Naively this function would be compiled without inlining Wrapper.[],
  // JSArray.[] and Wrapper.[]= because:
  // JSArray.[] is too big (14 nodes)
  // Wrapper.[] is too big if we force inlining of JSArray (15 nodes)
  // Wrapper.[]= is even bigger (46 nodes)
  //
  // We now do specialization of [] and []= by adding guards and injecting
builtin
  // operators. This made it possible to inline []. We still don't see []=
inlined
  // yet, that might require that we improve the inlining counting heuristics a
  // bit.
  @NoInline()
  test(data, x) {
    data[x + 1] = data[x];
  }
  
  main() {
    var wrapper = new Wrapper();
    wrapper[33] = wrapper[1]; // make Wrapper.[]= and [] used more than once.
    print(test(new Wrapper(), int.parse('2')));
  }
  
  class Wrapper {
    final List arr = <bool>[true, false, false, true];
    operator[](int i) => this.arr[i];
    operator[]=(int i, v) {
      if (i > arr.length - 1) arr.length = i + 1;
      return arr[i] = v;
    }
  }
  
Expected:
  // Expectation for test: 
  // // Method to test: function(test)
  // import 'package:expect/expect.dart';
  // 
  // // This example illustrates a case we wish to do better in terms of
inlining and
  // // code generation.
  // //
  // // Naively this function would be compiled without inlining Wrapper.[],
  // // JSArray.[] and Wrapper.[]= because:
  // // JSArray.[] is too big (14 nodes)
  // // Wrapper.[] is too big if we force inlining of JSArray (15 nodes)
  // // Wrapper.[]= is even bigger (46 nodes)
  // //
  // // We now do specialization of [] and []= by adding guards and injecting
builtin
  // // operators. This made it possible to inline []. We still don't see []=
inlined
  // // yet, that might require that we improve the inlining counting heuristics
a
  // // bit.
  // @NoInline()
  // test(data, x) {
  //   data[x + 1] = data[x];
  // }
  // 
  // main() {
  //   var wrapper = new Wrapper();
  //   wrapper[33] = wrapper[1]; // make Wrapper.[]= and [] used more than once.
  //   print(test(new Wrapper(), int.parse('2')));
  // }
  // 
  // class Wrapper {
  //   final List arr = <bool>[true, false, false, true];
  //   operator[](int i) => this.arr[i];
  //   operator[]=(int i, v) {
  //     if (i > arr.length - 1) arr.length = i + 1;
  //     return arr[i] = v;
  //   }
  // }
  
  function(data, x) {
    var v1 = J.$add$ns(x, 1), v1 = data.arr;
    if (x >>> 0 !== x || x >= v1.length)
      return H.ioore(v1, x);
    data.$indexSet(0, v0, v1[x]);
  }

but found:
  // Expectation for test: 
  // // Method to test: function(test)
  // import 'package:expect/expect.dart';
  // 
  // // This example illustrates a case we wish to do better in terms of
inlining and
  // // code generation.
  // //
  // // Naively this function would be compiled without inlining Wrapper.[],
  // // JSArray.[] and Wrapper.[]= because:
  // // JSArray.[] is too big (14 nodes)
  // // Wrapper.[] is too big if we force inlining of JSArray (15 nodes)
  // // Wrapper.[]= is even bigger (46 nodes)
  // //
  // // We now do specialization of [] and []= by adding guards and injecting
builtin
  // // operators. This made it possible to inline []. We still don't see []=
inlined
  // // yet, that might require that we improve the inlining counting heuristics
a
  // // bit.
  // @NoInline()
  // test(data, x) {
  //   data[x + 1] = data[x];
  // }
  // 
  // main() {
  //   var wrapper = new Wrapper();
  //   wrapper[33] = wrapper[1]; // make Wrapper.[]= and [] used more than once.
  //   print(test(new Wrapper(), int.parse('2')));
  // }
  // 
  // class Wrapper {
  //   final List arr = <bool>[true, false, false, true];
  //   operator[](int i) => this.arr[i];
  //   operator[]=(int i, v) {
  //     if (i > arr.length - 1) arr.length = i + 1;
  //     return arr[i] = v;
  //   }
  // }

  function(data, x) {
    var v0 = J.$add$ns(x, 1), v1 = data.arr;
    if (x >>> 0 !== x || x >= v1.length)
      return H.ioore(v1, x);
    data.$indexSet(0, v0, v1[x]);
  }




(B):

Unhandled exception:
Expect.fail('Unexpected output for test:
  // Method to test: function(test)
  import 'package:expect/expect.dart';
  
  // This example illustrates a case we wish to do better in terms of inlining
and
  // code generation.
  //
  // Naively this function would be compiled without inlining Wrapper.[],
  // JSArray.[] and Wrapper.[]= because:
  // JSArray.[] is too big (14 nodes)
  // Wrapper.[] is too big if we force inlining of JSArray (15 nodes)
  // Wrapper.[]= is even bigger (46 nodes)
  //
  // We now do specialization of [] and []= by adding guards and injecting
builtin
  // operators. This made it possible to inline []. We still don't see []=
inlined
  // yet, that might require that we improve the inlining counting heuristics a
  // bit.
  @NoInline()
  test(data, x) {
    data[x + 1] = data[x];
  }
  
  main() {
    var wrapper = new Wrapper();
    wrapper[33] = wrapper[1]; // make Wrapper.[]= and [] used more than once.
    print(test(new Wrapper(), int.parse('2')));
  }
  
  class Wrapper {
    final List arr = <bool>[true, false, false, true];
    operator[](int i) => this.arr[i];
    operator[]=(int i, v) {
      if (i > arr.length - 1) arr.length = i + 1;
      return arr[i] = v;
    }
  }
  
Expected:
  function(data, x) {
    var v1 = J.$add$ns(x, 1), v1 = data.arr;
    if (x >>> 0 !== x || x >= v1.length)
      return H.ioore(v1, x);
    data.$indexSet(0, v0, v1[x]);
  }

but found:
  function(data, x) {
    var v0 = J.$add$ns(x, 1), v1 = data.arr;
    if (x >>> 0 !== x || x >= v1.length)
      return H.ioore(v1, x);
    data.$indexSet(0, v0, v1[x]);
  }

[asgerf, 2016-02-19 13:07:23]

lgtm

[Siggi Cherem (dart-lang), 2016-02-19 16:32:24]

Description was changed from

==========
Improve how we report unittest failures by stripping out the commented input
code
==========

to

==========
Improve how we report unittest failures by stripping out the commented input
code

R=asgerf@google.com

Committed:
https://github.com/dart-lang/sdk/commit/7fbd3c5f35b24846911830282026cb73d50a9381
==========

[Siggi Cherem (dart-lang), 2016-02-19 16:32:25]

Committed patchset #2 (id:20001) manually as
7fbd3c5f35b24846911830282026cb73d50a9381 (presubmit successful).