revert unrelated changes

Author: zth

compiler/gentype/Annotation.ml

@@ -7,7 +7,6 @@ type attribute_payload =
   | IntPayload of string
   | StringPayload of string
   | TuplePayload of attribute_payload list
-  | RecordPayload of (string * attribute_payload) list
   | UnrecognizedPayload
 
 type t = GenType | GenTypeOpaque | NoGenType
@@ -29,14 +28,12 @@ let tag_is_tag s = s = "tag"
 let tag_is_unboxed s = s = "unboxed" || s = "ocaml.unboxed"
 let tag_is_gentype_import s = s = "genType.import" || s = "gentype.import"
 let tag_is_gentype_opaque s = s = "genType.opaque" || s = "gentype.opaque"
-let tag_is_gentype_satisfies s = s = "genType.satisfies" || s = "gentype.satisfies"
+let tag_is_gentype_satisfies s =
+  s = "genType.satisfies" || s = "gentype.satisfies"
 
 let tag_is_one_of_the_gentype_annotations s =
-  tag_is_gentype s
-  || tag_is_gentype_as s
-  || tag_is_gentype_import s
-  || tag_is_gentype_opaque s
-  || tag_is_gentype_satisfies s
+  tag_is_gentype s || tag_is_gentype_as s || tag_is_gentype_import s
+  || tag_is_gentype_opaque s || tag_is_gentype_satisfies s
 
 let tag_is_gentype_ignore_interface s =
   s = "genType.ignoreInterface" || s = "gentype.ignoreInterface"
@@ -68,26 +65,6 @@ let rec get_attribute_payload check_text (attributes : Typedtree.attributes) =
              []
       in
       Some (TuplePayload payloads)
-    | {pexp_desc = Pexp_record (fields, _)} ->
-      let items =
-        fields
-        |> List.fold_left
-             (fun acc
-                  ({Parsetree.lid; x; _} :
-                    Parsetree.expression Parsetree.record_element) ->
-               let key_opt =
-                 match lid.Location.txt with
-                 | Longident.Lident s -> Some s
-                 | Longident.Ldot (_, s) -> Some s
-                 | _ -> None
-               in
-               match (key_opt, from_expr x) with
-               | Some key, Some v -> (key, v) :: acc
-               | _ -> acc)
-             []
-        |> List.rev
-      in
-      Some (RecordPayload items)
     | {pexp_desc = Pexp_ident {txt}} -> Some (IdentPayload txt)
     | _ -> None
   in
@@ -163,15 +140,14 @@ let get_attribute_import_renaming attributes =
   let gentype_as_renaming = attributes |> get_gentype_as_renaming in
   match (attribute_import, gentype_as_renaming) with
   | Some (_, StringPayload import_string), _ ->
-    (Some import_string, gentype_as_renaming, None, None)
+    (Some import_string, gentype_as_renaming)
   | ( Some
         ( _,
           TuplePayload
             [StringPayload import_string; StringPayload rename_string] ),
       _ ) ->
-    (* Tuple form encodes (importPath, remoteExportName). Keep remote name separate. *)
-    (Some import_string, gentype_as_renaming, None, Some rename_string)
-  | _ -> (None, gentype_as_renaming, None, None)
+    (Some import_string, Some rename_string)
+  | _ -> (None, gentype_as_renaming)
 
 let get_attribute_satisfies attributes =
   match attributes |> get_attribute_payload tag_is_gentype_satisfies with

compiler/gentype/EmitJs.ml

@@ -601,7 +601,7 @@ let propagate_annotation_to_sub_types ~code_items
   in
   (new_type_map, !annotated_set)
 
-let emit_translation_as_string ~(config : Config.t) ~file_name
+let emit_translation_as_string ~config ~file_name
     ~input_cmt_translate_type_declarations ~output_file_relative ~resolver
     (translation : Translation.t) =
   let initial_env =
@@ -649,33 +649,8 @@ let emit_translation_as_string ~(config : Config.t) ~file_name
   and env = initial_env in
   let env, emitters =
     (* imports from type declarations go first to build up type tables *)
-    let all_import_types =
-      import_types_from_type_declarations @ translation.import_types
-      |> List.sort_uniq Translation.import_type_compare
-    in
-    (* Prefer direct imports of an alias name over aliased imports from other modules.
-       Use a single pass map: keep first direct (no alias) for a given name,
-       otherwise keep the first seen. *)
-    let chosen_by_name =
-      List.fold_left
-        (fun acc (it : CodeItem.import_type) ->
-          let key =
-            match it.as_type_name with
-            | Some alias -> alias
-            | None -> it.type_name
-          in
-          match StringMap.find key acc with
-          | (prev : CodeItem.import_type) -> (
-            match (prev.as_type_name, it.as_type_name) with
-            | None, Some _ -> acc (* keep direct over aliased *)
-            | _ -> acc)
-          | exception Not_found -> StringMap.add key it acc)
-        StringMap.empty all_import_types
-    in
-    let filtered_import_types =
-      chosen_by_name |> StringMap.to_seq |> Seq.map snd |> List.of_seq
-    in
-    filtered_import_types
+    import_types_from_type_declarations @ translation.import_types
+    |> List.sort_uniq Translation.import_type_compare
     |> emit_import_types ~config ~emitters ~env
          ~input_cmt_translate_type_declarations ~output_file_relative ~resolver
          ~type_name_is_interface

compiler/gentype/EmitType.ml

@@ -426,7 +426,8 @@ let emit_import_react ~emitters =
 
 let emit_satisfies_helper ~emitters =
   let alias =
-    "export type $RescriptTypeSatisfiesTypeScriptType<RescriptType, TypeScriptType extends RescriptType> = TypeScriptType;"
+    "export type $RescriptTypeSatisfiesTypeScriptType<RescriptType, \
+     TypeScriptType extends RescriptType> = TypeScriptType;"
   in
   Emitters.export_early ~emitters alias
 

compiler/gentype/GentypeTypeFold.ml

@@ -59,7 +59,7 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
     | false -> None
     (* one means don't know *)
   in
-  let import_string_opt, name_as, _import_exact_opt, remote_export_name_opt =
+  let import_string_opt, name_as =
     type_attributes |> Annotation.get_attribute_import_renaming
   in
   let satisfies_opt = type_attributes |> Annotation.get_attribute_satisfies in
@@ -99,9 +99,8 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
       (translation : TranslateTypeExprFromTypes.translation) =
     let export_from_type_declaration =
       type_name
-      |> create_export_type_from_type_declaration ~annotation:annotation_for_export
-           ~loc ~name_as
-           ~opaque
+      |> create_export_type_from_type_declaration
+           ~annotation:annotation_for_export ~loc ~name_as ~opaque
            ~type_:(apply_satisfies_wrapper translation.type_)
            ~type_env ~doc_string ~type_vars
     in
@@ -173,35 +172,31 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
     let name_with_module_path =
       typeName_ |> TypeEnv.add_module_path ~type_env |> ResolvedName.to_string
     in
-    (* Use the remote export name (if provided) to build the import and alias.
-       Preserve casing from the TS source exactly. *)
-    let remote_type_name =
-      match remote_export_name_opt with
-      | Some s -> s
-      | None -> name_with_module_path
+    let type_name, as_type_name =
+      match name_as with
+      | Some as_string -> (as_string, "$$" ^ name_with_module_path)
+      | None -> (name_with_module_path, "$$" ^ name_with_module_path)
     in
-    let type_name = remote_type_name in
-    let as_type_name = remote_type_name ^ "$TypeScript" in
-    let import_path = import_string |> ImportPath.from_string_unsafe in
-    let base_import =
-      {CodeItem.type_name; as_type_name = Some as_type_name; import_path}
+    let import_types =
+      [
+        {
+          CodeItem.type_name;
+          as_type_name = Some as_type_name;
+          import_path = import_string |> ImportPath.from_string_unsafe;
+        };
+      ]
     in
-    (* Only import the aliased TypeScript type; no wrappers or extra aliases. *)
-    let import_types = [base_import] in
     let export_from_type_declaration =
       (* Make the imported type usable from other modules by exporting it too. *)
-      let export_type_body =
-        as_type_name
-        |> ident ~type_args:(type_vars |> List.map (fun s -> TypeVar s))
-      in
       typeName_
       |> create_export_type_from_type_declaration ~doc_string
            ~annotation:GenType ~loc ~name_as:None ~opaque:(Some false)
-           ~type_:export_type_body ~type_env ~type_vars
+           ~type_:
+             (as_type_name
+             |> ident ~type_args:(type_vars |> List.map (fun s -> TypeVar s)))
+           ~type_env ~type_vars
     in
-    [
-      {CodeItem.import_types; export_from_type_declaration};
-    ]
+    [{CodeItem.import_types; export_from_type_declaration}]
   | (GeneralDeclarationFromTypes None | GeneralDeclaration None), None ->
     {
       CodeItem.import_types = [];
@@ -248,8 +243,7 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
       | _ -> translation.type_
     in
     {translation with type_ = apply_satisfies_wrapper type_}
-    |> handle_general_declaration
-    |> return_type_declaration
+    |> handle_general_declaration |> return_type_declaration
   | RecordDeclarationFromTypes label_declarations, None ->
     let {TranslateTypeExprFromTypes.dependencies; type_} =
       label_declarations |> translate_label_declarations
@@ -264,8 +258,8 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
       export_from_type_declaration =
         type_name
         |> create_export_type_from_type_declaration ~doc_string
-             ~annotation:annotation_for_export ~loc
-             ~name_as ~opaque ~type_:(apply_satisfies_wrapper type_)
+             ~annotation:annotation_for_export ~loc ~name_as ~opaque
+             ~type_:(apply_satisfies_wrapper type_)
              ~type_env ~type_vars;
     }
     |> return_type_declaration

compiler/gentype/TranslateTypeDeclarations.ml

@@ -118,48 +118,6 @@ let translate_constr ~config ~params_translation ~(path : Path.t) ~type_env =
     }
   | (["Js"; "Re"; "t"] | ["RegExp"; "t"] | ["Stdlib"; "RegExp"; "t"]), [] ->
     {dependencies = []; type_ = regexp_t}
-  | ["Stdlib"; "ArrayBuffer"; "t"], [] ->
-    {dependencies = []; type_ = ident "ArrayBuffer"}
-  | ["Stdlib"; "DataView"; "t"], [] ->
-    {dependencies = []; type_ = ident "DataView"}
-  | ["Stdlib"; "Int8Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "Int8Array"}
-  | ["Stdlib"; "Uint8Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "Uint8Array"}
-  | ["Stdlib"; "Uint8ClampedArray"; "t"], [] ->
-    {dependencies = []; type_ = ident "Uint8ClampedArray"}
-  | ["Stdlib"; "Int16Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "Int16Array"}
-  | ["Stdlib"; "Uint16Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "Uint16Array"}
-  | ["Stdlib"; "Int32Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "Int32Array"}
-  | ["Stdlib"; "Uint32Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "Uint32Array"}
-  | ["Stdlib"; "Float32Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "Float32Array"}
-  | ["Stdlib"; "Float64Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "Float64Array"}
-  | ["Stdlib"; "BigInt64Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "BigInt64Array"}
-  | ["Stdlib"; "BigUint64Array"; "t"], [] ->
-    {dependencies = []; type_ = ident "BigUint64Array"}
-  | ["Stdlib"; "Symbol"; "t"], [] -> {dependencies = []; type_ = ident "symbol"}
-  | ["Stdlib"; "Intl"; intl_module; "t"], [] ->
-    {dependencies = []; type_ = ident ("Intl." ^ intl_module)}
-  | (["Stdlib"; "Error"; "t"] | ["Stdlib"; "JsError"; "t"]), [] ->
-    {dependencies = []; type_ = ident "Error"}
-  | ["Stdlib"; "Iterator"; "t"], [param_translation] ->
-    {
-      dependencies = param_translation.dependencies;
-      type_ = ident ~type_args:[param_translation.type_] "Iterator";
-    }
-  | ["Stdlib"; "AsyncIterator"; "t"], [param_translation] ->
-    {
-      dependencies = param_translation.dependencies;
-      type_ = ident ~type_args:[param_translation.type_] "AsyncIterator";
-    }
-  | ["Stdlib"; "Ordering"; "t"], [] -> {dependencies = []; type_ = number_t}
   | ["unit"], [] -> {dependencies = []; type_ = unit_t}
   | (["array"] | ["Js"; ("Array" | "Array2"); "t"]), [param_translation] ->
     {param_translation with type_ = Array (param_translation.type_, Mutable)}

compiler/gentype/TranslateTypeExprFromTypes.ml

@@ -138,10 +138,7 @@ let translate_primitive ~config ~output_file_relative ~resolver ~type_env
     value_description.val_desc
     |> TranslateCoreType.translate_core_type ~config ~type_env
   in
-  let ( attribute_import,
-        attribute_renaming,
-        _import_exact_opt,
-        _remote_export_name_opt ) =
+  let attribute_import, attribute_renaming =
     value_description.val_attributes |> Annotation.get_attribute_import_renaming
   in
   match (type_expr_translation.type_, attribute_import) with
@@ -208,7 +205,6 @@ let add_type_declarations_from_module_equations ~type_env (translation : t) =
                             .annotation;
                       };
                     import_types = [];
-                    
                   }))
     |> List.concat
   in

compiler/gentype/Translation.ml

@@ -3,7 +3,7 @@
 /* eslint-disable */
 /* tslint:disable */
 
-import {make as makeNotChecked} from './hookExample';
+import {default as makeNotChecked} from './hookExample';
 
 import {default as defaultNotChecked} from './hookExample';
 

tests/gentype_tests/typescript-react-example/src/ImportHookDefault.gen.tsx

@@ -77,35 +77,37 @@ export const $$default: unknown = defaultTypeChecked as number as any;
 
 const ImportJsValueJS = require('./ImportJsValue.res.js');
 
-import type {AbsoluteValue as AbsoluteValue$TypeScript} from './MyMath';
+import type {AbsoluteValue as $$AbsoluteValue_t} from './MyMath';
 
-import type {num as num$TypeScript} from './MyMath';
+import type {num as $$myNum} from './MyMath';
 
-import type {numberOrString as numberOrString$TypeScript} from './MyMath';
+import type {num as $$num} from './MyMath';
 
-import type {polyType as polyType$TypeScript} from './MyMath';
+import type {numberOrString as $$numberOrString} from './MyMath';
 
-import type {stringFunction as stringFunction$TypeScript} from './MyMath';
+import type {polyType as $$polyType} from './MyMath';
+
+import type {stringFunction as $$stringFunction} from './MyMath';
 
 export type point = { readonly x: number; readonly y: (undefined | number) };
 
-export type numberOrString = numberOrString$TypeScript;
+export type numberOrString = $$numberOrString;
 
-export type AbsoluteValue_t = AbsoluteValue$TypeScript;
+export type AbsoluteValue_t = $$AbsoluteValue_t;
 
-export type stringFunction = stringFunction$TypeScript;
+export type stringFunction = $$stringFunction;
 
 export type color = "tomato" | "gray";
 
 export type variant = 
     { TAG: "I"; _0: number }
   | { TAG: "S"; _0: string };
 
-export type num = num$TypeScript;
+export type num = $$num;
 
-export type myNum = num$TypeScript;
+export type myNum = $$myNum;
 
-export type polyType<a> = polyType$TypeScript<a>;
+export type polyType<a> = $$polyType<a>;
 
 export const roundedNumber: number = ImportJsValueJS.roundedNumber as any;
 

tests/gentype_tests/typescript-react-example/src/ImportJsValue.gen.tsx

@@ -11,9 +11,9 @@ export const defaultTypeChecked: React.ComponentType<{ readonly onFocus?: (_1:in
 // Export '$$default' early to allow circular import from the '.bs.js' file.
 export const $$default: unknown = defaultTypeChecked as React.ComponentType<{ readonly onFocus?: (_1:inputFocusEvent) => void }> as any;
 
-import type {inputFocusEvent as inputFocusEvent$TypeScript} from './shims/JsxEvent.shim';
+import type {inputFocusEvent as $$inputFocusEvent} from './shims/JsxEvent.shim';
 
-export type inputFocusEvent = inputFocusEvent$TypeScript;
+export type inputFocusEvent = $$inputFocusEvent;
 
 export type props<onFocus> = { readonly onFocus?: onFocus };