Using `JsxDOM.domProps` in a type spread seems to be slow (discovered in playground)

[ryyppy]

When spreading JsxDOM.domProps in a record, the compilation is perceivably slower on the playground due to its blocking UI on slow compilation.

Here's a minimal example (v11.0.0-beta.1):

type divProps = {
  ...JsxDOM.domProps,
  foo: string
}

// Start typing here and you'll notice some considerable lag

Playground link

Not sure if this is a real issue, but I'd say it's a good indication that this language construct may break our performance goals in bigger codebases.

[fhammerschmidt]

As I am currently working on bindings for MUI v5 I just tried this in its example project.

When I built it with JsxProps spread (in only three components!)
full: 5,85s user 4,05s system
incremental: 0,58s user 0,24s system

whereas if I use only a small subset (see below) of the JsxProps I get
full: 1,40s user 0,91s system
incremental: 0,98s user 0,55s system

type jsxProps = {
   id?: string,
   className?: string,
   style?: ReactDOM.Style.t,
   ref?: ReactDOM.domRef,
}

[ryyppy]

Related benchmark suite by @mununki for more extensive performance testing.

https://github.com/mununki/benchmark-rescript-records

[cristianoc]

Did a litle digging: the time is spent here:

and compare_records ~loc env params1 params2 n
    (labels1 : Types.label_declaration list)
    (labels2 : Types.label_declaration list) =
  match labels1, labels2 with
    [], []           -> []
  | [], l::_ -> [Field_missing (true, l.Types.ld_id)]
  | l::_, [] -> [Field_missing (false, l.Types.ld_id)]
  | ld1::rem1, ld2::rem2 ->
      if Ident.name ld1.ld_id <> Ident.name ld2.ld_id
      then [Field_names (n, ld1.ld_id.name, ld2.ld_id.name)]
      else if ld1.ld_mutable <> ld2.ld_mutable then [Field_mutable ld1.ld_id] else begin
        Builtin_attributes.check_deprecated_mutable_inclusion
          ~def:ld1.ld_loc
          ~use:ld2.ld_loc
          loc
          ld1.ld_attributes ld2.ld_attributes
          (Ident.name ld1.ld_id);
        let field_mismatch = !Builtin_attributes.check_bs_attributes_inclusion  
          ld1.ld_attributes ld2.ld_attributes
          (Ident.name ld1.ld_id) in 
        match field_mismatch with
        | Some (a,b) -> [Field_names (n,a,b)]
        | None ->
        if Ctype.equal env true (ld1.ld_type::params1)(ld2.ld_type::params2)
        then (* add arguments to the parameters, cf. PR#7378 *)
          compare_records ~loc env
            (ld1.ld_type::params1) (ld2.ld_type::params2)
            (n+1)
            rem1 rem2
        else
          [Field_type ld1.ld_id]
      end

[cristianoc]

To repro: this doubles the compile time:

    | (Type_record(labels1,rep1), Type_record(labels2,rep2)) ->
        let _err = compare_records ~loc env decl1.type_params decl2.type_params
            1 labels1 labels2 in
        let err = compare_records ~loc env decl1.type_params decl2.type_params
            1 labels1 labels2 in

[cristianoc]

Specifically, this line is where all the time goes:

        if Ctype.equal env true (ld1.ld_type::params1)(ld2.ld_type::params2)

[cristianoc]

Test file:

// tst.res
type divProps = {
  ...JsxDOM.domProps,
}

type divProps2 = {
  ...JsxDOM.domProps,
}

type divProps3 = {
  ...JsxDOM.domProps,
}

type divProps4 = {
  ...JsxDOM.domProps,
}

type divProps5 = {
  ...JsxDOM.domProps,
}

type divProps6 = {
  ...JsxDOM.domProps,
}

type divProps7 = {
  ...JsxDOM.domProps,
}

type divProps8 = {
  ...JsxDOM.domProps,
}

type divProps9 = {
  ...JsxDOM.domProps,
}

type divProps10 = {
  ...JsxDOM.domProps,
}