Update gentype outputs to match generator changes

Author: test

compiler/gentype/Annotation.ml

@@ -167,24 +167,6 @@ let get_attribute_import_renaming attributes =
       _ ) ->
     (* Tuple form encodes (importPath, remoteExportName). Keep remote name separate. *)
     (Some import_string, gentype_as_renaming, None, Some rename_string)
-  | Some (_, RecordPayload opts), _ ->
-    let import_tuple_opt = List.assoc_opt "importPath" opts in
-    let import_string_opt, rename_string_opt =
-      match import_tuple_opt with
-      | Some (TuplePayload [StringPayload import_string; StringPayload rename])
-        ->
-        (Some import_string, Some rename)
-      | Some (TuplePayload [StringPayload import_string]) ->
-        (Some import_string, None)
-      | _ -> (None, None)
-    in
-    let exact_opt =
-      match List.assoc_opt "exact" opts with
-      | Some (BoolPayload b) -> Some b
-      | _ -> None
-    in
-    (* Keep remote export name separate from local alias (@genType.as) *)
-    (import_string_opt, gentype_as_renaming, exact_opt, rename_string_opt)
   | _ -> (None, gentype_as_renaming, None, None)
 
 let get_tag attributes =

compiler/gentype/CodeItem.ml

@@ -47,7 +47,6 @@ type export_type_map = export_type_item StringMap.t
 type type_declaration = {
   export_from_type_declaration: export_from_type_declaration;
   import_types: import_type list;
-  expected_type: type_ option;
 }
 
 type t = ExportValue of export_value | ImportValue of import_value

compiler/gentype/EmitJs.ml

@@ -635,57 +635,7 @@ let emit_translation_as_string ~(config : Config.t) ~file_name
     |> List.map (fun (type_declaration : CodeItem.type_declaration) ->
            type_declaration.export_from_type_declaration)
   in
-  (* Emit a named alias for the ReScript-side expected shape to improve TS errors. *)
-  let emitters =
-    let type_name_is_interface =
-      type_name_is_interface ~export_type_map
-        ~export_type_map_from_other_files:
-          initial_env.export_type_map_from_other_files
-    in
-    annotated_type_declarations
-    |> List.fold_left
-         (fun emitters (td : CodeItem.type_declaration) ->
-           match td.expected_type with
-           | None -> emitters
-           | Some expected
-             when GentypeImportHelper.should_inline_expected expected ->
-             emitters
-           | Some expected ->
-             let ({CodeItem.export_type}
-                   : CodeItem.export_from_type_declaration) =
-               td.export_from_type_declaration
-             in
-             let alias_name =
-               (export_type.resolved_type_name |> ResolvedName.to_string)
-               ^ "$ReScript"
-             in
-             let type_params_string =
-               EmitText.generics_string ~type_vars:export_type.type_vars
-             in
-             let expected_string =
-               EmitType.type_to_string ~config ~type_name_is_interface expected
-             in
-             Emitters.export_early ~emitters
-               ("type " ^ alias_name ^ type_params_string ^ " = "
-              ^ expected_string ^ ";"))
-         Emitters.initial
-  in
-  (* Determine if we need to emit the helper alias(es) for $GenTypeImport. *)
-  let needs_gentype_import_helper, needs_gentype_import_strict_helper =
-    export_from_type_declarations
-    |> List.fold_left
-         (fun (need_std, need_strict)
-              ({CodeItem.export_type} : CodeItem.export_from_type_declaration)
-            ->
-           match export_type.type_ with
-           | Ident {name; _} when String.equal name GentypeImportHelper.name ->
-             (true, need_strict)
-           | Ident {name; _}
-             when String.equal name GentypeImportHelper.strict_name ->
-             (need_std, true)
-           | _ -> (need_std, need_strict))
-         (false, false)
-  in
+  let emitters = Emitters.initial 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
@@ -778,17 +728,6 @@ let emit_translation_as_string ~(config : Config.t) ~file_name
     module_items_emitter
     |> ExportModule.emit_all_module_items ~config ~emitters ~file_name
   in
-  (* If we used the $GenTypeImport wrapper(s), emit helper alias(es) early. *)
-  let emitters =
-    let emitters =
-      if needs_gentype_import_helper then
-        Emitters.export_early ~emitters GentypeImportHelper.alias
-      else emitters
-    in
-    if needs_gentype_import_strict_helper then
-      Emitters.export_early ~emitters GentypeImportHelper.strict_alias
-    else emitters
-  in
   emitters
   |> emit_requires ~imported_value_or_component:false ~early:true ~config
        ~requires:final_env.requires_early

compiler/gentype/GentypeImportHelper.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, _import_exact_opt, remote_export_name_opt =
     type_attributes |> Annotation.get_attribute_import_renaming
   in
   let unboxed_annotation =
@@ -83,7 +83,7 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
       |> Translation.translate_dependencies ~config ~output_file_relative
            ~resolver
     in
-    {CodeItem.import_types; export_from_type_declaration; expected_type = None}
+    {CodeItem.import_types; export_from_type_declaration}
   in
   let translate_label_declarations ?(inline = false) label_declarations =
     let field_translations =
@@ -159,132 +159,21 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
     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)
-      | RecordDeclarationFromTypes label_declarations ->
-        Some (label_declarations |> translate_label_declarations)
-      | VariantDeclarationFromTypes constructor_declarations ->
-        let variants =
-          constructor_declarations
-          |> List.map (fun constructor_declaration ->
-                 let constructor_args = constructor_declaration.Types.cd_args in
-                 let attributes = constructor_declaration.cd_attributes in
-                 let name = constructor_declaration.cd_id |> Ident.name in
-                 let args_translation =
-                   match constructor_args with
-                   | Cstr_tuple type_exprs ->
-                     type_exprs
-                     |> TranslateTypeExprFromTypes
-                        .translate_type_exprs_from_types ~config ~type_env
-                   | Cstr_record label_declarations ->
-                     [
-                       label_declarations
-                       |> translate_label_declarations ~inline:true;
-                     ]
-                 in
-                 let arg_types =
-                   args_translation
-                   |> List.map (fun {TranslateTypeExprFromTypes.type_} -> type_)
-                 in
-                 (name, attributes, arg_types))
-        in
-        let variants_no_payload, variants_with_payload =
-          variants |> List.partition (fun (_, _, arg_types) -> arg_types = [])
-        in
-        let no_payloads =
-          variants_no_payload
-          |> List.map (fun (name, attributes, _argTypes) ->
-                 (name, attributes) |> create_case ~poly:false)
-        in
-        let payloads =
-          variants_with_payload
-          |> List.map (fun (name, attributes, arg_types) ->
-                 let type_ =
-                   match arg_types with
-                   | [type_] -> type_
-                   | _ -> Tuple arg_types
-                 in
-                 {
-                   case = (name, attributes) |> create_case ~poly:false;
-                   t = type_;
-                 })
-        in
-        let variant_typ =
-          create_variant ~inherits:[] ~no_payloads ~payloads ~polymorphic:false
-            ~tag:tag_annotation ~unboxed:unboxed_annotation
-        in
-        Some {TranslateTypeExprFromTypes.dependencies = []; type_ = variant_typ}
-      | _ -> 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
+    (* 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 imported_ident =
+      let export_type_body =
         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 -> (
-          let expected_for_wrapper =
-            if GentypeImportHelper.should_inline_expected tr.type_ then tr.type_
-            else
-              name_with_module_path ^ "$ReScript"
-              |> ident ~builtin:false
-                   ~type_args:(type_vars |> List.map (fun s -> TypeVar s))
-          in
-          match import_exact_opt with
-          | Some true ->
-            ident GentypeImportHelper.strict_name
-              ~type_args:[imported_ident; expected_for_wrapper]
-          | _ ->
-            ident GentypeImportHelper.name
-              ~type_args:[expected_for_wrapper; 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_:export_type_body ~type_env ~type_vars
     in
     [
-      {
-        CodeItem.import_types;
-        export_from_type_declaration;
-        expected_type =
-          (match expected_translation_opt with
-          | Some tr -> Some tr.type_
-          | None -> None);
-      };
+      {CodeItem.import_types; export_from_type_declaration};
     ]
   | (GeneralDeclarationFromTypes None | GeneralDeclaration None), None ->
     {
@@ -293,7 +182,6 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
         type_name
         |> create_export_type_from_type_declaration ~doc_string ~annotation ~loc
              ~name_as ~opaque:(Some true) ~type_:unknown ~type_env ~type_vars;
-      expected_type = None;
     }
     |> return_type_declaration
   | GeneralDeclarationFromTypes (Some type_expr), None ->
@@ -349,7 +237,6 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
         type_name
         |> create_export_type_from_type_declaration ~doc_string ~annotation ~loc
              ~name_as ~opaque ~type_ ~type_env ~type_vars;
-      expected_type = None;
     }
     |> return_type_declaration
   | VariantDeclarationFromTypes constructor_declarations, None ->
@@ -428,7 +315,7 @@ let traslate_declaration_kind ~config ~loc ~output_file_relative ~resolver
       |> List.map (fun (_, _, _, import_types) -> import_types)
       |> List.concat
     in
-    {CodeItem.export_from_type_declaration; import_types; expected_type = None}
+    {CodeItem.export_from_type_declaration; import_types}
     |> return_type_declaration
   | NoDeclaration, None -> []
 

compiler/gentype/TranslateTypeDeclarations.ml

@@ -208,7 +208,7 @@ let add_type_declarations_from_module_equations ~type_env (translation : t) =
                             .annotation;
                       };
                     import_types = [];
-                    expected_type = None;
+                    
                   }))
     |> List.concat
   in

compiler/gentype/Translation.ml

@@ -3,32 +3,21 @@ 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
+	# Expect direct type aliasing to imported TS type
+	grep -Fq 'export type numberT = Type$$TypeScript;' src/GenTypeImportExpectedErrors.gen.tsx
+	grep -Fq 'export type tupleT = Type$$TypeScript;' src/GenTypeImportExpectedErrors.gen.tsx
+	grep -Fq 'export type arrayT = Type$$TypeScript;' src/GenTypeImportExpectedErrors.gen.tsx
+	grep -Fq 'export type promiseT = Type$$TypeScript;' src/GenTypeImportExpectedErrors.gen.tsx
+	grep -Fq 'export type nestedArrayT = Type$$TypeScript;' src/GenTypeImportExpectedErrors.gen.tsx
+	grep -Fq 'export type stringT = Type$$TypeScript;' src/GenTypeImportExpectedErrors.gen.tsx
+	# Now TypeScript typecheck and ensure no type errors are emitted
 	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' ; \
+	if [ -s ts-errors.txt ]; then \
+		echo 'Unexpected TypeScript errors:' ; \
+		cat ts-errors.txt ; \
 		exit 1 ; \
 	else \
-		echo 'All expected TS errors present; positive has no error' ; \
+		echo 'TypeScript typecheck clean' ; \
 	fi
 
 clean:

tests/gentype_tests/genimport-single/Makefile

@@ -3,16 +3,6 @@
 /* eslint-disable */
 /* tslint:disable */
 
-type groupRenderProps$ReScript = {
-  readonly isHovered: boolean; 
-  readonly isFocusWithin: boolean; 
-  readonly isFocusVisible: boolean; 
-  readonly isDisabled: boolean; 
-  readonly isInvalid: boolean
-};
-
-type $GenTypeImportStrict<T, Expected extends T> = Expected;
-
 import type {GroupRenderProps as GroupRenderProps$TypeScript} from 'react-aria-components';
 
-export type groupRenderProps = $GenTypeImportStrict<GroupRenderProps$TypeScript,groupRenderProps$ReScript>;
+export type groupRenderProps = GroupRenderProps$TypeScript;

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

@@ -1,4 +1,4 @@
-@genType.import({importPath: ("react-aria-components", "GroupRenderProps"), exact: true})
+@genType.import(("react-aria-components", "GroupRenderProps"))
 type groupRenderProps = {
   isHovered: bool,
   isFocusWithin: bool,