Reanalyze: link type re-export labels (#8217)

* Reanalyze: link type re-export labels

Track manifest type paths on label declarations so re-exported record/variant labels
can be linked to their manifest counterparts during type label dependency wiring.

Adds a regression test for `type y = x = {...}` field liveness.

Signed-off-by: Cristiano Calcagno <cristianoc@users.noreply.github.com>

* Changelog: mention reanalyze type re-export label linking

Signed-off-by: Cristiano Calcagno <cristianoc@users.noreply.github.com>

* Reanalyze: suppress dead warnings on re-exported labels

When a type is re-exported via `type y = x = {...}`, the re-exported record/variant
labels are restated but not independently actionable. Suppress dead-type warning
emission for those labels while keeping per-label liveness and linking intact.

Signed-off-by: Cristiano Calcagno <cristianoc@users.noreply.github.com>

* Reanalyze: link re-export manifests across modules

Track manifest type paths (not just local type ids) so `type y = M.x = ...` and
other cross-module type equations correctly link label/case liveness.

Extend deadcode tests to cover variants and cross-file record re-exports.

Signed-off-by: Cristiano Calcagno <cristianoc@users.noreply.github.com>

---------

Signed-off-by: Cristiano Calcagno <cristianoc@users.noreply.github.com>
# Conflicts:
#	tests/analysis_tests/tests-reanalyze/deadcode/expected/deadcode.txt

Author: cristianoc

CHANGELOG.md

@@ -26,6 +26,7 @@
 #### :bug: Bug fix
 
 - Reanalyze: fix reactive/server stale results when cross-file references change without changing dead declarations (non-transitive mode). https://github.com/rescript-lang/rescript/pull/8173
+- Reanalyze: link record/variant label liveness across type re-exports (`type y = x = {...}`). https://github.com/rescript-lang/rescript/pull/8217
 - Add duplicate package detection to rewatch. https://github.com/rescript-lang/rescript/pull/8180
 - Rewatch: do not warn about "reanalyze" config field. https://github.com/rescript-lang/rescript/pull/8181
 - Fix error when importing CommonJS runtime modules with `require()`. https://github.com/rescript-lang/rescript/pull/8194

analysis/reanalyze/src/DeadCommon.ml

@@ -4,6 +4,8 @@ module FileContext = struct
   (** Get module name as Name.t tagged with interface/implementation info *)
   let module_name_tagged file =
     file.module_name |> Name.create ~isInterface:file.is_interface
+
+  let isInterface (file : t) = file.is_interface
 end
 
 (* Adapted from https://github.com/LexiFi/dead_code_analyzer *)
@@ -82,7 +84,7 @@ let addValueReference ~config ~refs ~file_deps ~(binding : Location.t)
 
 let addDeclaration_ ~config ~decls ~(file : FileContext.t) ?posEnd ?posStart
     ~declKind ~path ~(loc : Location.t) ?(posAdjustment = Decl.Nothing)
-    ~moduleLoc (name : Name.t) =
+    ?manifestTypePath ~moduleLoc (name : Name.t) =
   let pos = loc.loc_start in
   let posStart =
     match posStart with
@@ -110,6 +112,7 @@ let addDeclaration_ ~config ~decls ~(file : FileContext.t) ?posEnd ?posStart
         moduleLoc;
         posAdjustment;
         path = name :: path;
+        manifestTypePath;
         pos;
         posEnd;
         posStart;
@@ -182,6 +185,16 @@ let reportDeclaration ~config ~hasRefBelow ?checkModuleDead ?shouldReport
     | Some f -> f decl
     | None -> decl.report
   in
+  (* For type re-exports (type y = x = {...}), the re-exported record/variant
+     labels are restated but not independently actionable. Avoid duplicate/noisy
+     warnings by suppressing reporting for the re-exported copy. *)
+  let should_report =
+    should_report
+    &&
+    match (decl.declKind, decl.manifestTypePath) with
+    | (RecordLabel | VariantCase), Some _ -> false
+    | _ -> true
+  in
   if not should_report then []
   else
     let deadWarning, message =

analysis/reanalyze/src/DeadType.ml

@@ -19,15 +19,14 @@ let extendTypeDependencies ~config ~refs (loc1 : Location.t) (loc2 : Location.t)
     addTypeReference ~config ~refs ~posFrom ~posTo)
 
 let addDeclaration ~config ~decls ~file ~(modulePath : ModulePath.t)
-    ~(typeId : Ident.t) ~(typeKind : Types.type_kind) =
-  let pathToType =
-    (typeId |> Ident.name |> Name.create)
-    :: (modulePath.path @ [FileContext.module_name_tagged file])
-  in
+    ~(typeId : Ident.t) ~(typeKind : Types.type_kind)
+    ~(manifestTypePath : DcePath.t option) =
+  let moduleContext = modulePath.path @ [FileContext.module_name_tagged file] in
+  let pathToType = (typeId |> Ident.name |> Name.create) :: moduleContext in
   let processTypeLabel ?(posAdjustment = Decl.Nothing) typeLabelName ~declKind
       ~(loc : Location.t) =
     addDeclaration_ ~config ~decls ~file ~declKind ~path:pathToType ~loc
-      ~moduleLoc:modulePath.loc ~posAdjustment typeLabelName
+      ?manifestTypePath ~moduleLoc:modulePath.loc ~posAdjustment typeLabelName
   in
   match typeKind with
   | Type_record (l, _) ->
@@ -162,4 +161,59 @@ let process_type_label_dependencies ~config ~decls ~refs =
               if not Config.reportTypesDeadOnlyInInterface then
                 extendTypeDependencies ~config ~refs loc loc1))
       | _ -> ())
-    decls
+    decls;
+
+  (* Link fields of re-exported types (type y = x = {...}) to original type fields.
+     We store the manifest type path on the label declarations themselves, and
+     derive the set of re-export relationships here. To preserve stable output
+     ordering, we process types bottom-to-top (by their first label position)
+     and fields top-to-bottom (by their label position). *)
+  let compare_pos (p1 : Lexing.position) (p2 : Lexing.position) =
+    match compare p1.Lexing.pos_fname p2.Lexing.pos_fname with
+    | 0 -> compare p1.Lexing.pos_cnum p2.Lexing.pos_cnum
+    | c -> c
+  in
+  (* currentTypePath -> (rep_pos, manifestTypePath, (pos, fieldName, currentLoc) list) *)
+  let groups :
+      ( DcePath.t,
+        Lexing.position
+        * DcePath.t
+        * (Lexing.position * Name.t * Location.t) list )
+      Hashtbl.t =
+    Hashtbl.create 32
+  in
+  Declarations.iter
+    (fun _pos decl ->
+      match (decl.Decl.declKind, decl.manifestTypePath, decl.path) with
+      | ( (RecordLabel | VariantCase),
+          Some manifestTypePath,
+          fieldName :: currentTypePath ) -> (
+        let item = (decl.pos, fieldName, decl_raw_loc decl) in
+        match Hashtbl.find_opt groups currentTypePath with
+        | None ->
+          Hashtbl.replace groups currentTypePath
+            (decl.pos, manifestTypePath, [item])
+        | Some (rep_pos, mtp0, items) ->
+          (* manifestTypePath should be stable for a given currentTypePath *)
+          let rep_pos =
+            if compare_pos decl.pos rep_pos < 0 then decl.pos else rep_pos
+          in
+          Hashtbl.replace groups currentTypePath (rep_pos, mtp0, item :: items))
+      | _ -> ())
+    decls;
+
+  groups |> Hashtbl.to_seq |> List.of_seq
+  |> List.map (fun (currentTypePath, (rep_pos, manifestTypePath, items)) ->
+         (rep_pos, currentTypePath, manifestTypePath, items))
+  (* Later (lower) types first *)
+  |> List.fast_sort (fun (p1, _, _, _) (p2, _, _, _) -> compare_pos p2 p1)
+  |> List.iter (fun (_rep_pos, _currentTypePath, manifestTypePath, items) ->
+         items
+         |> List.fast_sort (fun (p1, _, _) (p2, _, _) -> compare_pos p1 p2)
+         |> List.iter (fun (_pos, fieldName, currentLoc) ->
+                let manifestFieldPath = fieldName :: manifestTypePath in
+                match find_one manifestFieldPath with
+                | None -> ()
+                | Some manifestLoc ->
+                  extendTypeDependencies ~config ~refs currentLoc manifestLoc;
+                  extendTypeDependencies ~config ~refs manifestLoc currentLoc))

analysis/reanalyze/src/DeadValue.ml

@@ -247,8 +247,26 @@ let rec processSignatureItem ~config ~decls ~file ~doTypes ~doValues ~moduleLoc
   match si with
   | Sig_type (id, t, _) when doTypes ->
     if !Config.analyzeTypes then
+      (* Extract manifest type path for type re-exports (type y = x = {...}).
+         Use full Path.t so cross-module re-exports work (Path.Pdot, aliases, etc.). *)
+      let manifestTypePath =
+        match t.type_manifest with
+        | Some {desc = Tconstr (path, _, _)} -> (
+          let p = path |> DcePath.fromPathT in
+          match p with
+          | [typeName] ->
+            let moduleContext =
+              modulePath.path @ [FileContext.module_name_tagged file]
+            in
+            Some (typeName :: moduleContext)
+          | _ ->
+            Some
+              (if FileContext.isInterface file then DcePath.moduleToInterface p
+               else DcePath.moduleToImplementation p))
+        | _ -> None
+      in
       DeadType.addDeclaration ~config ~decls ~file ~modulePath ~typeId:id
-        ~typeKind:t.type_kind
+        ~typeKind:t.type_kind ~manifestTypePath
   | Sig_value (id, {Types.val_loc = loc; val_kind = kind; val_type})
     when doValues ->
     if not loc.Location.loc_ghost then
@@ -361,9 +379,29 @@ let traverseStructure ~config ~decls ~refs ~file_deps ~cross_file ~file ~doTypes
                   typeDeclarations
                   |> List.iter
                        (fun (typeDeclaration : Typedtree.type_declaration) ->
+                         (* Extract manifest type path for type re-exports (type y = x = {...}). *)
+                         let manifestTypePath =
+                           match typeDeclaration.typ_manifest with
+                           | Some {ctyp_desc = Ttyp_constr (path, _, _)} -> (
+                             let p = path |> DcePath.fromPathT in
+                             match p with
+                             | [typeName] ->
+                               let moduleContext =
+                                 modulePath.path
+                                 @ [FileContext.module_name_tagged file]
+                               in
+                               Some (typeName :: moduleContext)
+                             | _ ->
+                               Some
+                                 (if FileContext.isInterface file then
+                                    DcePath.moduleToInterface p
+                                  else DcePath.moduleToImplementation p))
+                           | _ -> None
+                         in
                          DeadType.addDeclaration ~config ~decls ~file
                            ~modulePath ~typeId:typeDeclaration.typ_id
-                           ~typeKind:typeDeclaration.typ_type.type_kind);
+                           ~typeKind:typeDeclaration.typ_type.type_kind
+                           ~manifestTypePath);
                 None
               | Tstr_include {incl_mod; incl_type} ->
                 (match incl_mod.mod_desc with

analysis/reanalyze/src/Decl.ml

@@ -31,6 +31,11 @@ type t = {
   moduleLoc: Location.t;
   posAdjustment: posAdjustment;
   path: DcePath.t;
+      (** For type re-exports (e.g. [type y = x = {...}]), record/variant label
+      declarations belonging to the re-exporting type can carry the manifest
+      type path so [DeadType.process_type_label_dependencies] can link fields
+      without needing the typed tree. *)
+  manifestTypePath: DcePath.t option;
   pos: Lexing.position;
   posEnd: Lexing.position;
   posStart: Lexing.position;