Speed up record inclusion check.

[cristianoc]

Speed up record inclusion check.
Fixes #6284

Record inclusion check (between implementation and interface) is quadratic.

Example:

module M : {
  type t<'a, 'b, 'c> = {x:int, y:list<('a, 'b)>, z:int}
} = {
  type t<'a, 'b, 'c> = {x:int, y:list<('a, 'c)>, z:int}
}

The existing algorithm tries to instantiate type parameters. It only reports an error if there is an inconsistency. This requires solving type equations involving many types at once.

To give an accurate error message, the first problematic field is reported (in this case y). So the type equations are checked again and again with size 1, 2, ...n where n is the number of fields. (Plus the type parameters).

This is quadratic and is problematic for records of ~1K fields.

This PR provides a fast path which just checks if there is an error, without blaming a specific field. The fast path is linear.
Only if an error is detected, the quadratic path is take to blame precisely which field is involved.

[mununki]

Very clever!
This PR actually makes me wonder why upstream does Ctype.equal nested. Obviously, for a record with many fields, it would be very slow.

[cknitt]

Great work! 🎉

There is another place where compare_records is invoked (in compare_constructor_arguments). Should that be adapted, too?

[zth]

@mununki could you check what https://github.com/mununki/benchmark-rescript-records gives when running this PR?

[mununki]

@mununki could you check what mununki/benchmark-rescript-records gives when running this PR?

It's clear that performance has improved under the same conditions.

# before
Normal record x 7.29 ops/sec ±0.96% (23 runs sampled)
Record with spread x 5.30 ops/sec ±1.20% (18 runs sampled)
Record with optional x 5.08 ops/sec ±3.61% (17 runs sampled)
Record with spread and optional x 3.37 ops/sec ±0.96% (13 runs sampled)

# after
Normal record x 8.55 ops/sec ±0.83% (26 runs sampled)
Record with spread x 6.57 ops/sec ±2.79% (21 runs sampled)
Record with optional x 7.97 ops/sec ±1.18% (25 runs sampled)
Record with spread and optional x 6.40 ops/sec ±0.46% (20 runs sampled)

[cristianoc]

Great work! 🎉

There is another place where compare_records is invoked (in compare_constructor_arguments). Should that be adapted, too?

Refactored so there's a single function now.

[cristianoc]

One alternative would be to make this internal function incremental:

let eqtype_list rename type_pairs subst env tl1 tl2 =
  univar_pairs := [];
  let snap = Btype.snapshot () in
  try eqtype_list rename type_pairs subst env tl1 tl2; backtrack snap
  with exn -> backtrack snap; raise exn

so it would not slow down even for the error case. However it would be more complicated.