Optimizations lost in uncurried mode

[cknitt]

• Inlining lost in jscomp/gentype_tests/typescript-react-example/src/Records.res
• Temporary variable introduced in jscomp/test/bs_poly_mutable_set_test.res
• Belt_SetString.fromArray/toArray example

---

This is a follow-up to my comments on the diffs in #6864.

Inlining lost in the output for jscomp/gentype_tests/typescript-react-example/src/Records.res:

let getOpt = (opt, default, foo) => opt->Option.mapWithDefault(default, foo)

Before (curried mode):

let getOpt = Belt_Option.mapWithDefault;

After (uncurried mode):

function getOpt(opt, $$default, foo) {
  return Belt_Option.mapWithDefault(opt, $$default, foo);
}

Temporary variable introduced in jscomp/test/bs_poly_mutable_set_test.res:

Input:

b(__LOC__, N.isEmpty(N.intersect(aa, bb)))

Before (curried mode):

b("File \"bs_poly_mutable_set_test.res\", line 96, characters 4-11", Belt_MutableSet.isEmpty(Belt_MutableSet.intersect(aa, bb)));

After (uncurried mode):

let d$1 = Belt_MutableSet.intersect(aa, bb);

b("File \"bs_poly_mutable_set_test.res\", line 96, characters 4-11", d$1.data === undefined);

(OTOH isEmpty is now inlined here which is good.)

[cknitt]

Related example: When Belt is compiled in uncurried mode, the following code

open RescriptSchema

let stringSet = S.array(S.string)->S.transform(_ => {
  parser: a => Belt.Set.String.fromArray(a),
  serializer: a => Belt.Set.String.toArray(a),
})

compiles to

let stringSet = S$RescriptSchema.transform(S$RescriptSchema.array(S$RescriptSchema.string), (function (param) {
  return {
    p: (function (a) {
      return Belt_SetString.fromArray(a);
    }),
    s: (function (a) {
      return Belt_SetString.toArray(a);
    })
  };
}));

whereas when Belt is compiled in curried mode, it compiles to

let stringSet = S$RescriptSchema.transform(S$RescriptSchema.array(S$RescriptSchema.string), (function (param) {
  return {
    p: Belt_SetString.fromArray,
    s: Belt_SetString.toArray
  };
}));

[cristianoc]

foo(1,2) is transformed to Js.Internal.opaqueFullApply(Internal.opaque(f), 1, 2).
This is used to prevent transformations that apply by default and assume curried semantics.
These in turn prevent certain optimisations.

It's probably worth investigating what transformations can be gradually removed so opaqueFullApplyand opaque are not needed anymore, and see what the consequences are.

[cristianoc]

It seems that opaque is not actually needed (at least at the moment after recent changes): #6892

[cristianoc]

Instead, here's the effect of removing opaqueFullApply: https://github.com/rescript-lang/rescript-compiler/pull/6893/files
A bunch of applications are considered curried applications.

[cristianoc]

This then blindly changes every application at the lambda level to use App_uncurry: https://github.com/rescript-lang/rescript-compiler/pull/6894/files
A lot of inlining is unlocked that way. Bunch of wrong code too, but the direction seems worth exploring.

[cknitt]

Everything resolved in current master.