genType: treat option<t> as t | undefined and remove special treatment of record fields of option type.

[cristianoc]

Can be used to bind to functions with optional parameters, using option.

Before: option<t> maps to this TS null | undefined | t
Now: option<t> maps to this TS undefined | t

Before: {x:option<string>} maps to this TS {x?: string}.
Now: {x:option<string>} maps to this TS {x: (undefined | string)} (same for {x:Js.undefined<string>})
Unchanged: {x?: string} maps to this TS {x?: string}.

This also produces strictly fewer conversion functions, as it does not need to transform null to undefined.

[cristianoc]

Added examples. TS functions:

// CoreTS.ts
export declare function someFunWithNullThenOptionalArgs(
  nullable: null | string,
  app?: string
): string;

export declare function someFunWithNullUndefinedArg(
  nullUndefined: null | undefined | string,
  other: number
): string;

ReScript bindings:

@genType.import("./CoreTS")
external someFunWithNullThenOptionalArgs: (
  Null.t<string> /* Cannot be Nullable.t or option */,
  option<string> /* Cannot be Null.t or Nullable.t */,
) => string = "someFunWithNullThenOptionalArgs"

@genType.import("./CoreTS")
external someFunWithNullUndefinedArg: (
  Nullable.t<string> /* Can also be Null.t or option as they are subtypes */,
  int,
) => string = "someFunWithNullUndefinedArg"

Notice that out of the 3 choices: (null | string), (undefined | string), (null | undefined | string), there is no freedom at all for binding to someFunWithNullThenOptionalArgs: one must use the first and second one respectively.
What this means is that one needs to have a way to express each of the 3 choices.
With this PR, option can be used to bind to TS optional arguments, and Undefined.t becomes redundant.

[cristianoc]

Complete bindings for one firebase function (CC @jmagaram):

type firebaseOptions = {
  apiKey?: string,
  authDomain?: string,
  databaseURL?: string,
  projectId?: string,
  storageBucket?: string,
  messagingSenderId?: string,
  appId?: string,
  measurementId?: string,
}

type firebaseApp = {
  name: string,
  options: firebaseOptions,
  automaticDataCollectionEnabled: bool,
}
type analytics = {app: firebaseApp}
type analyticsCallOptions = {global: bool}

@genType.import("firebase/analytics")
external setUserId: (analytics, Null.t<string>, option<analyticsCallOptions>) => unit = "setUserId"

gives

/* TypeScript file generated from Core.res by genType. */
/* eslint-disable import/first */


import {setUserId as setUserIdNotChecked} from 'firebase/analytics';

// In case of type error, check the type of 'setUserId' in 'Core.res' and 'firebase/analytics'.
export const setUserIdTypeChecked: (_1:analytics, _2:(null | string), _3:(undefined | analyticsCallOptions)) => void = setUserIdNotChecked;

// Export 'setUserId' early to allow circular import from the '.bs.js' file.
export const setUserId: unknown = setUserIdTypeChecked as (_1:analytics, _2:(null | string), _3:(undefined | analyticsCallOptions)) => void;

// tslint:disable-next-line:interface-over-type-literal
export type firebaseOptions = {
  readonly apiKey?: string; 
  readonly authDomain?: string; 
  readonly databaseURL?: string; 
  readonly projectId?: string; 
  readonly storageBucket?: string; 
  readonly messagingSenderId?: string; 
  readonly appId?: string; 
  readonly measurementId?: string
};

// tslint:disable-next-line:interface-over-type-literal
export type firebaseApp = {
  readonly name: string; 
  readonly options: firebaseOptions; 
  readonly automaticDataCollectionEnabled: boolean
};

// tslint:disable-next-line:interface-over-type-literal
export type analytics = { readonly app: firebaseApp };

// tslint:disable-next-line:interface-over-type-literal
export type analyticsCallOptions = { readonly global: boolean };