exploration for

Author: zth

Makefile

@@ -43,6 +43,7 @@ test-syntax-roundtrip:
 test-gentype:
 	make -C tests/gentype_tests/typescript-react-example clean test
 	make -C tests/gentype_tests/stdlib-no-shims clean test
+	make -C tests/gentype_tests/genimport-single clean test
 
 test-rewatch:
 	./rewatch/tests/suite-ci.sh
@@ -82,6 +83,7 @@ checkformat:
 clean-gentype:
 	make -C tests/gentype_tests/typescript-react-example clean
 	make -C tests/gentype_tests/stdlib-no-shims clean
+	make -C tests/gentype_tests/genimport-single clean
 
 clean-rewatch:
 	cargo clean --manifest-path rewatch/Cargo.toml && rm -f rewatch/rewatch

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 ~file_name
+let emit_translation_as_string ~(config : Config.t) ~file_name
     ~input_cmt_translate_type_declarations ~output_file_relative ~resolver
     (translation : Translation.t) =
   let initial_env =
@@ -635,6 +635,17 @@ let emit_translation_as_string ~config ~file_name
     |> List.map (fun (type_declaration : CodeItem.type_declaration) ->
            type_declaration.export_from_type_declaration)
   in
+  (* Determine if we need to emit the helper alias for $GenTypeImport. *)
+  let needs_gentype_import_helper =
+    export_from_type_declarations
+    |> List.exists
+         (fun
+           ({CodeItem.export_type} : CodeItem.export_from_type_declaration) ->
+           match export_type.type_ with
+           | Ident {name; _} when String.equal name GentypeImportHelper.name ->
+             true
+           | _ -> false)
+  in
   let type_name_is_interface ~env =
     type_name_is_interface ~export_type_map
       ~export_type_map_from_other_files:env.export_type_map_from_other_files
@@ -648,8 +659,33 @@ let emit_translation_as_string ~config ~file_name
   and env = initial_env in
   let env, emitters =
     (* imports from type declarations go first to build up type tables *)
-    import_types_from_type_declarations @ translation.import_types
-    |> List.sort_uniq Translation.import_type_compare
+    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
     |> emit_import_types ~config ~emitters ~env
          ~input_cmt_translate_type_declarations ~output_file_relative ~resolver
          ~type_name_is_interface
@@ -702,6 +738,12 @@ let emit_translation_as_string ~config ~file_name
     module_items_emitter
     |> ExportModule.emit_all_module_items ~config ~emitters ~file_name
   in
+  (* If we used the $GenTypeImport wrapper, emit its helper alias early. *)
+  let emitters =
+    if needs_gentype_import_helper then
+      Emitters.export_early ~emitters GentypeImportHelper.alias
+    else emitters
+  in
   emitters
   |> emit_requires ~imported_value_or_component:false ~early:true ~config
        ~requires:final_env.requires_early

compiler/gentype/GentypeImportHelper.ml

@@ -0,0 +1,3 @@
+let name = "$GenTypeImport"
+
+let alias = "type $GenTypeImport<Expected, T extends Expected> = T;"

compiler/gentype/GentypeTypeFold.ml

@@ -0,0 +1,19 @@
+open GenTypeCommon
+
+let rec fold f acc (t : type_) =
+  let acc = f acc t in
+  match t with
+  | Ident _ | TypeVar _ -> acc
+  | Array (t1, _) | Dict t1 | Option t1 | Null t1 | Nullable t1 | Promise t1 ->
+    fold f acc t1
+  | Tuple ts -> List.fold_left (fold f) acc ts
+  | Object (_shape, fields) ->
+    List.fold_left (fun acc {type_} -> fold f acc type_) acc fields
+  | Function {arg_types; ret_type; _} ->
+    let acc =
+      List.fold_left (fun acc {a_type} -> fold f acc a_type) acc arg_types
+    in
+    fold f acc ret_type
+  | Variant {inherits; payloads; _} ->
+    let acc = List.fold_left (fold f) acc inherits in
+    List.fold_left (fun acc {t} -> fold f acc t) acc payloads

compiler/gentype/TranslateTypeDeclarations.ml

@@ -151,24 +151,61 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
       | Some as_string -> (as_string, "$$" ^ name_with_module_path)
       | None -> (name_with_module_path, "$$" ^ name_with_module_path)
     in
-    let import_types =
-      [
-        {
-          CodeItem.type_name;
-          as_type_name = Some as_type_name;
-          import_path = import_string |> ImportPath.from_string_unsafe;
-        };
-      ]
+    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}
+    in
+    (* If the declaration has a manifest type, capture its full translation
+       so we can both build the Expected type and import its dependencies. *)
+    let expected_translation_opt =
+      match declaration_kind with
+      | GeneralDeclaration (Some core_type) ->
+        Some
+          (core_type |> TranslateCoreType.translate_core_type ~config ~type_env)
+      | GeneralDeclarationFromTypes (Some type_expr) ->
+        Some
+          (type_expr
+          |> TranslateTypeExprFromTypes.translate_type_expr_from_types ~config
+               ~type_env)
+      | _ -> None
+    in
+
+    (* Import any referenced non-builtin identifiers from the same module as
+       the base imported type. This ensures shims work (e.g. mapping ReactEvent
+       types to a local shim module), matching previous behavior. *)
+    let extra_type_imports =
+      match expected_translation_opt with
+      | Some tr ->
+        GentypeTypeFold.fold
+          (fun acc (t : GenTypeCommon.type_) ->
+            match t with
+            | Ident {builtin = false; name; _} -> name :: acc
+            | _ -> acc)
+          [] tr.type_
+        |> List.sort_uniq String.compare
+        |> List.filter (fun n -> n <> type_name)
+        |> List.map (fun n ->
+               {CodeItem.type_name = n; as_type_name = None; import_path})
+      | None -> []
     in
+    let import_types = base_import :: extra_type_imports in
     let export_from_type_declaration =
       (* Make the imported type usable from other modules by exporting it too. *)
+      let imported_ident =
+        as_type_name
+        |> ident ~type_args:(type_vars |> List.map (fun s -> TypeVar s))
+      in
+      let export_type_body =
+        match expected_translation_opt with
+        | Some tr ->
+          (* $GenTypeImport<Expected, Imported> *)
+          ident GentypeImportHelper.name ~type_args:[tr.type_; imported_ident]
+        | None -> imported_ident
+      in
       typeName_
       |> create_export_type_from_type_declaration ~doc_string
            ~annotation:GenType ~loc ~name_as:None ~opaque:(Some false)
-           ~type_:
-             (as_type_name
-             |> ident ~type_args:(type_vars |> List.map (fun s -> TypeVar s)))
-           ~type_env ~type_vars
+           ~type_:export_type_body ~type_env ~type_vars
     in
     [{CodeItem.import_types; export_from_type_declaration}]
   | (GeneralDeclarationFromTypes None | GeneralDeclaration None), None ->

tests/gentype_tests/genimport-single/Makefile

@@ -0,0 +1,40 @@
+SHELL = /bin/bash
+
+test:
+	yarn workspaces focus @tests/gentype-genimport-single
+	yarn build
+	# Helper exists once in single generated file
+	grep -Fq 'type $$GenTypeImport<Expected, T extends Expected> = T;' src/GenTypeImportExpectedErrors.gen.tsx
+	# Wrapper lines for each case present
+	grep -Fq 'export type numberT = $$GenTypeImport<number,' src/GenTypeImportExpectedErrors.gen.tsx
+	grep -Fq 'export type tupleT = $$GenTypeImport<[number, string],' src/GenTypeImportExpectedErrors.gen.tsx
+	grep -Fq 'export type arrayT = $$GenTypeImport<number[],' src/GenTypeImportExpectedErrors.gen.tsx
+	grep -Fq 'export type promiseT = $$GenTypeImport<Promise<number>,' src/GenTypeImportExpectedErrors.gen.tsx
+	# nested arrays may render as Array<number[]>; accept either style
+	grep -Fq 'export type nestedArrayT = $$GenTypeImport<Array<number[]>' src/GenTypeImportExpectedErrors.gen.tsx
+	# Positive wrapper present too
+	grep -Fq 'export type stringT = $$GenTypeImport<string,' src/GenTypeImportExpectedErrors.gen.tsx
+	# Now TypeScript typecheck and assert exact errors
+	yarn typecheck > ts-errors.txt 2>&1 || true
+	# Expect exactly 5 TS2344 errors (the mismatches), and no others
+	test $$(grep -c 'error TS2344' ts-errors.txt) -eq 5
+	grep -Fq "Type 'string' does not satisfy the constraint 'number'." ts-errors.txt
+	grep -Fq "Type 'string' does not satisfy the constraint '[number, string]'." ts-errors.txt
+	grep -Fq "Type 'string' does not satisfy the constraint 'number[]'." ts-errors.txt
+	grep -Fq "Type 'string' does not satisfy the constraint 'Promise<number>'." ts-errors.txt
+	grep -Fq "Type 'string' does not satisfy the constraint 'number[][]'." ts-errors.txt
+	# Positive should not produce any error about constraint 'string'
+	if grep -Fq "constraint 'string'." ts-errors.txt; then \
+		echo 'Unexpected error for positive string case' ; \
+		exit 1 ; \
+	else \
+		echo 'All expected TS errors present; positive has no error' ; \
+	fi
+
+clean:
+	yarn workspaces focus @tests/gentype-genimport-single
+	yarn clean
+
+.DEFAULT_GOAL := test
+
+.PHONY: clean test

tests/gentype_tests/genimport-single/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@tests/gentype-genimport-single",
+  "private": true,
+  "scripts": {
+    "build": "rescript legacy build",
+    "clean": "rescript clean",
+    "typecheck": "tsc"
+  },
+  "dependencies": {
+    "rescript": "workspace:^"
+  },
+  "devDependencies": {
+    "typescript": "5.8.2"
+  }
+}
+

tests/gentype_tests/genimport-single/rescript.json

@@ -0,0 +1,19 @@
+{
+  "gentypeconfig": {
+    "language": "typescript",
+    "module": "esmodule",
+    "importPath": "relative",
+    "debug": { "all": false },
+    "exportInterfaces": false
+  },
+  "name": "@tests/gentype-genimport-single",
+  "sources": [
+    { "dir": "src", "subdirs": true }
+  ],
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "suffix": ".res.js"
+}
+

tests/gentype_tests/genimport-single/src/GenTypeImportExpectedErrors.gen.tsx

@@ -0,0 +1,44 @@
+/* TypeScript file generated from GenTypeImportExpectedErrors.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+type $GenTypeImport<Expected, T extends Expected> = T;
+
+import * as GenTypeImportExpectedErrorsJS from './GenTypeImportExpectedErrors.res.js';
+
+import type {Type as $$arrayT} from 'external-module';
+
+import type {Type as $$nestedArrayT} from 'external-module';
+
+import type {Type as $$numberT} from 'external-module';
+
+import type {Type as $$promiseT} from 'external-module';
+
+import type {Type as $$stringT} from 'external-module';
+
+import type {Type as $$tupleT} from 'external-module';
+
+export type numberT = $GenTypeImport<number,$$numberT>;
+
+export type tupleT = $GenTypeImport<[number, string],$$tupleT>;
+
+export type arrayT = $GenTypeImport<number[],$$arrayT>;
+
+export type promiseT = $GenTypeImport<Promise<number>,$$promiseT>;
+
+export type nestedArrayT = $GenTypeImport<Array<number[]>,$$nestedArrayT>;
+
+export type stringT = $GenTypeImport<string,$$stringT>;
+
+export const useNumber: (x:numberT) => numberT = GenTypeImportExpectedErrorsJS.useNumber as any;
+
+export const useTuple: (x:tupleT) => tupleT = GenTypeImportExpectedErrorsJS.useTuple as any;
+
+export const useArray: (x:arrayT) => arrayT = GenTypeImportExpectedErrorsJS.useArray as any;
+
+export const usePromise: (x:promiseT) => promiseT = GenTypeImportExpectedErrorsJS.usePromise as any;
+
+export const useNestedArray: (x:nestedArrayT) => nestedArrayT = GenTypeImportExpectedErrorsJS.useNestedArray as any;
+
+export const useString: (x:stringT) => stringT = GenTypeImportExpectedErrorsJS.useString as any;

tests/gentype_tests/genimport-single/src/GenTypeImportExpectedErrors.res

@@ -0,0 +1,39 @@
+/* This module intentionally contains cases that should cause TypeScript errors
+ when the external imported Type mismatches the ReScript manifest type. */
+
+@genType.import(("external-module", "Type"))
+type numberT = int
+
+@genType
+let useNumber = (x: numberT) => x
+
+@genType.import(("external-module", "Type"))
+type tupleT = (int, string)
+
+@genType
+let useTuple = (x: tupleT) => x
+
+@genType.import(("external-module", "Type"))
+type arrayT = array<int>
+
+@genType
+let useArray = (x: arrayT) => x
+
+@genType.import(("external-module", "Type"))
+type promiseT = Js.Promise.t<int>
+
+@genType
+let usePromise = (x: promiseT) => x
+
+@genType.import(("external-module", "Type"))
+type nestedArrayT = array<array<int>>
+
+@genType
+let useNestedArray = (x: nestedArrayT) => x
+
+/* Positive case: string matches external Type=string */
+@genType.import(("external-module", "Type"))
+type stringT = string
+
+@genType
+let useString = (x: stringT) => x