Refactor resolver errors to provide better fallbacking and return errors out of formatting

[zbraniecki]

This is a pretty major refactor of the Resolver, in a pretty POC state of work.

It aims to achieve three main goals:

• Improve error handling, accumulate errors and report them to the user in a consistent manner (#74)
• Improve the test coverage by porting tests from the reference resolver to Rust (#87)
• Use Cow<str> to lower the CPU and memory cost of simple resolutions

The code is far from being completed, but it already renders really promising performance wins:

master:

Benchmarking resolve/"simple": Collecting 100 samples in estimated 5.0014                                                                         resolve/"simple"
                        time:   [423.91 ns 427.41 ns 431.49 ns]
                        change: [+307.52% +312.14% +317.44%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 3 outliers among 100 measurements (3.00%)
  2 (2.00%) high mild
  1 (1.00%) high severe
Benchmarking resolve/"menubar": Collecting 100 samples in estimated 5.007                                                                         resolve/"menubar"
                        time:   [98.715 us 99.508 us 100.49 us]
                        change: [+188.03% +193.45% +199.59%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 3 outliers among 100 measurements (3.00%)
  1 (1.00%) high mild
  2 (2.00%) high severe
Benchmarking resolve/"unescape": Collecting 100 samples in estimated 5.00                                                                         resolve/"unescape"
                        time:   [2.0391 us 2.0608 us 2.0865 us]
                        change: [+174.65% +179.37% +183.55%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 2 outliers among 100 measurements (2.00%)
  2 (2.00%) high mild

bundle-tests branch:

Benchmarking resolve/"simple": Collecting 100 samples in estimated 5.0002                                                                         resolve/"simple"
                        time:   [99.838 ns 100.40 ns 101.05 ns]
                        change: [-76.878% -76.609% -76.357%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 1 outliers among 100 measurements (1.00%)
  1 (1.00%) high mild
Benchmarking resolve/"menubar": Collecting 100 samples in estimated 5.135                                                                         resolve/"menubar"
                        time:   [33.873 us 34.129 us 34.424 us]
                        change: [-66.651% -66.045% -65.508%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 1 outliers among 100 measurements (1.00%)
  1 (1.00%) high mild
Benchmarking resolve/"unescape": Collecting 100 samples in estimated 5.00                                                                         resolve/"unescape"
                        time:   [735.93 ns 740.36 ns 745.43 ns]
                        change: [-65.005% -64.488% -63.949%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 3 outliers among 100 measurements (3.00%)
  3 (3.00%) high mild

All three benchmarks put the branch at 60-70% faster, mostly due to lack of string copying for simple strings.

I'd like to consider this refactor for 0.6.

@stasm - this is likely too early for review, but the POC is complete enough for you to asses the general approach. Lmk!

[Pike]

Out of curiosity, have you considered the pre-evaluated algorithm we're using in the python resolver now?

The other thing we did in python was to move from dispatch to transformer pattern. That was merely because dispatch was slow. Is that a problem in rust?

Also, can we refer to the js resolver as the js resolver? We don't have a reference resolver yet ;-)

[zbraniecki]

This now passes all tests, retains all functionality, and maintains the performance win of ~60% in resolver tests. I still want to:

• [x] Clean up the code
• [x] Improve errors
• [ ] Port resolver tests from js
  • [ ] arguments_test.js
  • [ ] attributes_test.js
  • [x] constructor_test.js
  • [x] context_test.js
  • [x] functions_runtime_test.js
  • [x] functions_test.js
  • [ ] literals_test.js
  • [ ] macros_test.js
  • [ ] patterns_test.js
  • [x] primitives_test.js
  • [x] select_expressions_test.js
  • [x] values_format_test.js
  • [x] values_ref_test.js
• [ ] Improve coverage

but the code matures to a full PR now (so that I start getting CI results and coverage results on this branch) :)

[zbraniecki]

@stasm - I'm still working on porting resolver tests and improving coverage, but I believe this code is ready for preliminary review.

If you prefer me to first document it, I'll postpone the review, but it may be easier for me to know if you approve the general direction before I dive into details.

[zbraniecki]

I think that two interesting concepts that I introduced here, which may be useful to port back to JS are:

• I moved the tracking to be more "lazy", instead of eager. That means that when you reference a message, I'll only add this message to the stack if the message goes deeper :) This actually gives a nice perf boost.
• I introduced the DisplayableNode to unify where we turn nodes into displayable pieces and delay doing that until its needed.

[zbraniecki]

@manishearth - I'd love to get your feedback on this PR. Majority of the real action is in src/resolve.rs

[stasm]

If you prefer me to first document it, I'll postpone the review, but it may be easier for me to know if you approve the general direction before I dive into details.

Thanks for letting me know. I'll be away next week, so it might best to postpone the review until I'm back.

[zbraniecki]

Okay! I'll work on porting more tests, inline docs and getting review from Manish first then :)

[zbraniecki]

Gonna merge it, and continue working in separate issues.