Remove function converter.

Author: cristianoc

jscomp/gentype/Converter.ml

@@ -2,7 +2,6 @@ open GenTypeCommon
 
 type t =
   | CircularC of string * t
-  | FunctionC of functionC
   | IdentC
   | OptionC of t
   | PromiseC of t
@@ -12,41 +11,9 @@ and groupedArgConverter =
   | ArgConverter of t
   | GroupConverter of (string * optional * t) list
 
-and functionC = {
-  funArgConverters: groupedArgConverter list;
-  componentName: string option;
-  isHook: bool;
-  retConverter: t;
-  typeVars: string list;
-  uncurried: bool;
-}
-
 let rec toString converter =
   match converter with
   | CircularC (s, c) -> "circular(" ^ s ^ " " ^ toString c ^ ")"
-  | FunctionC {funArgConverters; retConverter; uncurried} ->
-    "fn"
-    ^ (match uncurried with
-      | true -> "Uncurried"
-      | false -> "")
-    ^ "("
-    ^ (funArgConverters
-      |> List.map (fun groupedArgConverter ->
-             match groupedArgConverter with
-             | ArgConverter conv -> "(" ^ "_" ^ ":" ^ toString conv ^ ")"
-             | GroupConverter groupConverters ->
-               "{|"
-               ^ (groupConverters
-                 |> List.map (fun (s, optional, argConverter) ->
-                        s
-                        ^ (match optional = Optional with
-                          | true -> "?"
-                          | false -> "")
-                        ^ ":" ^ toString argConverter)
-                 |> String.concat ", ")
-               ^ "|}")
-      |> String.concat ", ")
-    ^ " -> " ^ toString retConverter ^ ")"
   | IdentC -> "id"
   | OptionC c -> "option(" ^ toString c ^ ")"
   | PromiseC c -> "promise(" ^ toString c ^ ")"
@@ -63,29 +30,12 @@ let typeGetConverterNormalized ~config ~inline ~lookupId ~typeNameIsInterface
       let _, tNormalized = t |> visit ~visited in
       (IdentC, Array (tNormalized, mutable_))
     | Dict _ -> (IdentC, normalized_)
-    | Function
-        ({argTypes; componentName; retType; typeVars; uncurried} as function_)
-      ->
+    | Function ({argTypes; retType} as function_) ->
       let argConverted =
         argTypes |> List.map (argTypeToGroupedArgConverter ~visited)
       in
-      let funArgConverters = argConverted |> List.map fst in
-      let retConverter, retNormalized = retType |> visit ~visited in
-      let isHook =
-        match argTypes with
-        | [{aType = Object (_, fields)}] ->
-          retType |> EmitType.isTypeFunctionComponent ~fields
-        | _ -> false
-      in
-      ( FunctionC
-          {
-            funArgConverters;
-            componentName;
-            isHook;
-            retConverter;
-            typeVars;
-            uncurried;
-          },
+      let _, retNormalized = retType |> visit ~visited in
+      ( IdentC,
         Function
           {
             function_ with
@@ -215,15 +165,6 @@ let typeGetNormalized ~config ~inline ~lookupId ~typeNameIsInterface type_ =
 let rec converterIsIdentity ~config ~toJS converter =
   match converter with
   | CircularC (_, c) -> c |> converterIsIdentity ~config ~toJS
-  | FunctionC {funArgConverters; retConverter; uncurried} ->
-    retConverter |> converterIsIdentity ~config ~toJS
-    && ((not toJS) || uncurried || funArgConverters |> List.length <= 1)
-    && funArgConverters
-       |> List.for_all (fun groupedArgConverter ->
-              match groupedArgConverter with
-              | ArgConverter argConverter ->
-                argConverter |> converterIsIdentity ~config ~toJS:(not toJS)
-              | GroupConverter _ -> false)
   | IdentC -> true
   | OptionC c -> c |> converterIsIdentity ~config ~toJS
   | PromiseC c -> c |> converterIsIdentity ~config ~toJS
@@ -240,106 +181,6 @@ let rec apply ~(config : Config.t) ~converter ~indent ~nameGen ~toJS
          ~comment:
            ("WARNING: circular type " ^ s ^ ". Only shallow converter applied.")
     |> apply ~config ~converter:c ~indent ~nameGen ~toJS ~variantTables
-  | FunctionC
-      {
-        funArgConverters;
-        componentName;
-        isHook;
-        retConverter;
-        typeVars;
-        uncurried;
-      } ->
-    let resultName = EmitText.resultName ~nameGen in
-    let indent1 = indent |> Indent.more in
-    let indent2 = indent1 |> Indent.more in
-    let mkReturn x =
-      "const " ^ resultName ^ " = " ^ x ^ ";"
-      ^ Indent.break ~indent:indent1
-      ^ "return "
-      ^ (resultName
-        |> apply ~config ~converter:retConverter ~indent:indent2 ~nameGen ~toJS
-             ~variantTables)
-    in
-    let convertArg i groupedArgConverter =
-      match groupedArgConverter with
-      | ArgConverter argConverter ->
-        let varName = i + 1 |> EmitText.argi ~nameGen in
-        let notToJS = not toJS in
-        ( [varName],
-          [
-            varName
-            |> apply ~config ~converter:argConverter ~indent:indent2 ~nameGen
-                 ~toJS:notToJS ~variantTables;
-          ] )
-      | GroupConverter groupConverters ->
-        let notToJS = not toJS in
-        if toJS then
-          let varName = i + 1 |> EmitText.argi ~nameGen in
-          ( [varName],
-            groupConverters
-            |> List.map (fun (label, optional, argConverter) ->
-                   varName
-                   |> EmitText.fieldAccess ~label
-                   |> apply ~config
-                        ~converter:
-                          (match
-                             optional = Optional
-                             && not
-                                  (argConverter
-                                  |> converterIsIdentity ~config ~toJS:notToJS)
-                           with
-                          | true -> OptionC argConverter
-                          | false -> argConverter)
-                        ~indent:indent2 ~nameGen ~toJS:notToJS ~variantTables)
-          )
-        else
-          let varNames =
-            groupConverters
-            |> List.map (fun (s, _optional, _argConverter) ->
-                   s |> EmitText.arg ~nameGen)
-          in
-          let varNamesArr = varNames |> Array.of_list in
-          let fieldValues =
-            groupConverters
-            |> List.mapi (fun i (s, _optional, argConverter) ->
-                   s ^ ":"
-                   ^ ((varNamesArr.(i) [@doesNotRaise])
-                     |> apply ~config ~converter:argConverter ~indent:indent2
-                          ~nameGen ~toJS:notToJS ~variantTables))
-            |> String.concat ", "
-          in
-          (varNames, ["{" ^ fieldValues ^ "}"])
-    in
-    let mkBody bodyArgs =
-      let useCurry = (not uncurried) && toJS && List.length bodyArgs > 1 in
-      config.emitImportCurry <- config.emitImportCurry || useCurry;
-      let functionName =
-        match isHook with
-        | true -> "React.createElement"
-        | false -> value
-      in
-      if isHook then config.emitImportReact <- true;
-      let declareProps, args =
-        match bodyArgs with
-        | [props] when isHook ->
-          let propsName = "$props" |> EmitText.name ~nameGen in
-          ( Indent.break ~indent:indent1
-            ^ "const " ^ propsName ^ " = " ^ props ^ ";",
-            [value; propsName] )
-        | _ -> ("", bodyArgs)
-      in
-      declareProps
-      ^ Indent.break ~indent:indent1
-      ^ (functionName |> EmitText.funCall ~args ~useCurry |> mkReturn)
-    in
-    let convertedArgs = funArgConverters |> List.mapi convertArg in
-    let args = convertedArgs |> List.map fst |> List.concat in
-    let funParams =
-      args |> List.map (fun v -> v |> EmitType.ofTypeAny ~config)
-    in
-    let bodyArgs = convertedArgs |> List.map snd |> List.concat in
-    EmitText.funDef ~bodyArgs ~functionName:componentName ~funParams ~indent
-      ~mkBody ~typeVars
   | IdentC -> value
   | OptionC c ->
     EmitText.parens

jscomp/gentype/EmitText.ml

@@ -10,41 +10,18 @@ let name ~nameGen s =
     s
 
 let parens xs = "(" ^ (xs |> String.concat ", ") ^ ")"
-let arg ~nameGen x = "Arg" ^ x |> name ~nameGen
-let argi ~nameGen i = "Arg" ^ (i |> string_of_int) |> name ~nameGen
-let array xs = "[" ^ (xs |> String.concat ", ") ^ "]"
 let comment x = "/* " ^ x ^ " */"
 
-let curry ~args ~numArgs name =
-  match numArgs with
-  | 0 | 1 -> name ^ parens args
-  | (2 | 3 | 4 | 5 | 6 | 7 | 8) as n ->
-    "Curry._" ^ (n |> string_of_int) ^ parens ([name] @ args)
-  | _ -> "Curry.app" ^ parens [name; args |> array]
-
-let funCall ~args ~useCurry name =
-  match useCurry with
-  | true -> name |> curry ~args ~numArgs:(args |> List.length)
-  | false -> name ^ parens args
 
 let genericsString ~typeVars =
   match typeVars == [] with
   | true -> ""
   | false -> "<" ^ String.concat "," typeVars ^ ">"
 
-let funDef ~bodyArgs ~functionName ~funParams ~indent ~mkBody ~typeVars =
-  "function "
-  ^ (match functionName with
-    | None -> ""
-    | Some name -> name)
-  ^ genericsString ~typeVars ^ (funParams |> parens) ^ " {"
-  ^ (bodyArgs |> mkBody) ^ Indent.break ~indent ^ "}"
 
 let newNameGen () = Hashtbl.create 1
 let quotes x = "\"" ^ x ^ "\""
 
-let resultName ~nameGen = "result" |> name ~nameGen
-
 let addComment ~comment x = "\n/* " ^ comment ^ " */\n  " ^ x
 let arrayAccess ~index value = value ^ "[" ^ string_of_int index ^ "]"
 let fieldAccess ~label value = value ^ "." ^ label

jscomp/gentype/GenTypeCommon.ml

@@ -97,22 +97,6 @@ and variant = {
 
 and payload = {case: case; inlineRecord: bool; numArgs: int; t: type_}
 
-let typeIsObject type_ =
-  match type_ with
-  | Array _ -> true
-  | Dict _ -> true
-  | Function _ -> false
-  | GroupOfLabeledArgs _ -> false
-  | Ident _ -> false
-  | Null _ -> false
-  | Nullable _ -> false
-  | Object _ -> true
-  | Option _ -> false
-  | Promise _ -> true
-  | Tuple _ -> true
-  | TypeVar _ -> false
-  | Variant _ -> false
-
 type label = Nolabel | Label of string | OptLabel of string
 
 type dep =

jscomp/gentype_tests/typescript-react-example/src/Docstrings.gen.tsx

@@ -2,10 +2,6 @@
 /* eslint-disable import/first */
 
 
-// @ts-ignore: Implicit any on import
-import * as Curry__Es6Import from 'rescript/lib/es6/curry.js';
-const Curry: any = Curry__Es6Import;
-
 // @ts-ignore: Implicit any on import
 import * as DocstringsBS__Es6Import from './Docstrings.bs';
 const DocstringsBS: any = DocstringsBS__Es6Import;
@@ -21,15 +17,9 @@ export const signMessage: (message:string, key:number) => string = DocstringsBS.
 
 export const one: (a:number) => number = DocstringsBS.one;
 
-export const two: (a:number, b:number) => number = function (Arg1: any, Arg2: any) {
-  const result = Curry._2(DocstringsBS.two, Arg1, Arg2);
-  return result
-};
+export const two: (a:number, b:number) => number = DocstringsBS.two;
 
-export const tree: (a:number, b:number, c:number) => number = function (Arg1: any, Arg2: any, Arg3: any) {
-  const result = Curry._3(DocstringsBS.tree, Arg1, Arg2, Arg3);
-  return result
-};
+export const tree: (a:number, b:number, c:number) => number = DocstringsBS.tree;
 
 export const oneU: (a:number) => number = DocstringsBS.oneU;
 
@@ -45,17 +35,11 @@ export const unnamed1: (param:number) => number = DocstringsBS.unnamed1;
 
 export const unnamed1U: (param:number) => number = DocstringsBS.unnamed1U;
 
-export const unnamed2: (param_0:number, param_1:number) => number = function (Arg1: any, Arg2: any) {
-  const result = Curry._2(DocstringsBS.unnamed2, Arg1, Arg2);
-  return result
-};
+export const unnamed2: (param_0:number, param_1:number) => number = DocstringsBS.unnamed2;
 
 export const unnamed2U: (param_0:number, param_1:number) => number = DocstringsBS.unnamed2U;
 
-export const grouped: (_1:{ readonly x: number; readonly y: number }, a:number, b:number, c:number, _5:{ readonly z: number }) => number = function (Arg1: any, Arg2: any, Arg3: any, Arg4: any, Arg5: any) {
-  const result = Curry._6(DocstringsBS.grouped, Arg1.x, Arg1.y, Arg2, Arg3, Arg4, Arg5.z);
-  return result
-};
+export const grouped: (_1:{ readonly x: number; readonly y: number }, a:number, b:number, c:number, _5:{ readonly z: number }) => number = DocstringsBS.grouped;
 
 export const unitArgWithoutConversion: () => string = DocstringsBS.unitArgWithoutConversion;
 

jscomp/gentype_tests/typescript-react-example/src/Hooks.gen.tsx

@@ -4,10 +4,6 @@
 
 import * as React from 'react';
 
-// @ts-ignore: Implicit any on import
-import * as Curry__Es6Import from 'rescript/lib/es6/curry.js';
-const Curry: any = Curry__Es6Import;
-
 // @ts-ignore: Implicit any on import
 import * as HooksBS__Es6Import from './Hooks.bs';
 const HooksBS: any = HooksBS__Es6Import;
@@ -79,13 +75,7 @@ export const functionWithRenamedArgs: (_1:{
   readonly to: vehicle; 
   readonly Type: vehicle; 
   readonly cb: cb
-}) => string = function (Arg1: any) {
-  const result = Curry._3(HooksBS.functionWithRenamedArgs, Arg1.to, Arg1.Type, function (Argto: any) {
-      const result1 = Arg1.cb({to:Argto});
-      return result1
-    });
-  return result
-};
+}) => string = HooksBS.functionWithRenamedArgs;
 
 // tslint:disable-next-line:interface-over-type-literal
 export type WithRename_componentWithRenamedArgs_Props = {
@@ -100,10 +90,7 @@ export const WithRename_componentWithRenamedArgs: React.ComponentType<{
   readonly cb: cb
 }> = HooksBS.WithRename.componentWithRenamedArgs;
 
-export const WithRef_makeWithRef: (_1:{ readonly vehicle: vehicle }, _2:(null | undefined | any)) => JSX.Element = function (Arg1: any, Arg2: any) {
-  const result = Curry._2(HooksBS.WithRef.makeWithRef, Arg1, Arg2);
-  return result
-};
+export const WithRef_makeWithRef: (_1:{ readonly vehicle: vehicle }, _2:(null | undefined | any)) => JSX.Element = HooksBS.WithRef.makeWithRef;
 
 // tslint:disable-next-line:interface-over-type-literal
 export type testForwardRef_Props = { readonly vehicle: vehicle };
@@ -175,6 +162,8 @@ export const ForwardRef: { input: React.ComponentType<{ readonly r: r }> } = Hoo
 
 export const Fun: { functionReturningReactElement: React.ComponentType<{ readonly name: string }> } = HooksBS.Fun
 
+export const WithRef: { makeWithRef: (_1:{ readonly vehicle: vehicle }, _2:(null | undefined | any)) => JSX.Element } = HooksBS.WithRef
+
 export const WithChildren: { aComponentWithChildren: React.ComponentType<{ readonly children: React.ReactNode; readonly vehicle: vehicle }> } = HooksBS.WithChildren
 
 export const DD: { make: React.ComponentType<{ readonly array: Js_TypedArray2_Uint8Array_t; readonly name: string }> } = HooksBS.DD

jscomp/gentype_tests/typescript-react-example/src/ImportHooks.gen.tsx

@@ -26,10 +26,7 @@ export const makeRenamed: unknown = makeRenamedTypeChecked as React.ComponentTyp
 export const fooTypeChecked: (_1:{ readonly person: person }) => string = fooNotChecked;
 
 // Export 'foo' early to allow circular import from the '.bs.js' file.
-export const foo: unknown = function (Argperson: any) {
-  const result = fooTypeChecked({person:Argperson});
-  return result
-} as (_1:{ readonly person: person }) => string;
+export const foo: unknown = fooTypeChecked as (_1:{ readonly person: person }) => string;
 
 // tslint:disable-next-line:interface-over-type-literal
 export type person = { readonly name: string; readonly age: number };