Keep the functor's file for members of an applied functor

Codex review on #9084: the members of `module M = Other.Make(X)` were
registered in the current file with the locations of Other's functor
body, so Go to Definition and hover's type-definition link combined
Other's location with the current file. Their module path now records
the functor, as it does for included modules, so both resolve to the
functor's file.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Kbf3gLMawVgtmiKy3TMBc3
Signed-off-by: Christoph Knittel <ck@cca.io>

Author: cknitt

analysis/src/hover.ml

@@ -64,6 +64,9 @@ type extracted_type = {
   decl: Types.type_declaration;
   env: Shared_types.Query_env.t;
   loc: Warnings.loc;
+  uri: Uri.t;
+      (** the file of [loc], which differs from [env]'s for a type
+                   of an applied or included module of another file *)
 }
 
 let find_relevant_types_from_type ~state ~file ~package typ =
@@ -103,9 +106,13 @@ let find_relevant_types_from_type ~state ~file ~package typ =
   let from_constructor_path ~env path =
     match References.dig_constructor ~state ~env ~package path with
     | None -> None
-    | Some (env, {name = {txt}; extent_loc; item = {decl}}) ->
+    | Some (env, {name = {txt}; extent_loc; item = {decl}; module_path}) ->
       if Utils.is_uncurried_internal path then None
-      else Some {name = txt; env; loc = extent_loc; decl; path}
+      else
+        let uri =
+          Resolve_path.get_source_uri ~state ~env ~package module_path
+        in
+        Some {name = txt; env; loc = extent_loc; decl; path; uri}
   in
   let constructors = Shared.find_type_constructors types_to_search in
   constructors |> List.filter_map (from_constructor_path ~env:env_to_search)
@@ -142,12 +149,14 @@ let expand_types ~state ~file ~package ~supports_markdown_links typ =
           else (
             types_seen := String_set.add type_id !types_seen;
             true))
-      |> List.map (fun {decl; env; loc; path} ->
+      |> List.map (fun {decl; env; loc; path; uri} ->
           let link_to_type_definition_str =
             if
               supports_markdown_links
               && not (is_inline_record_definition decl path)
-            then Markdown.go_to_definition_text ~env ~pos:loc.Warnings.loc_start
+            then
+              Markdown.go_to_definition_text ~uri ~env
+                ~pos:loc.Warnings.loc_start ()
             else ""
           in
           Markdown.divider

analysis/src/markdown.ml

@@ -8,12 +8,17 @@ let make_goto_command link =
   Printf.sprintf "[%s](%s#L%d,%d)" link.label link.file (link.start_pos.line + 1)
     (link.start_pos.character + 1)
 
-let go_to_definition_text ~env ~pos =
+let go_to_definition_text ?uri ~env ~pos () =
   let start_line, start_col = Pos.of_lexing pos in
+  let uri =
+    match uri with
+    | Some uri -> uri
+    | None -> env.Shared_types.Query_env.file.uri
+  in
   "\nGo to: "
   ^ make_goto_command
       {
         label = "Type definition";
-        file = Uri.to_string env.Shared_types.Query_env.file.uri;
+        file = Uri.to_string uri;
         start_pos = {line = start_line; character = start_col};
       }

analysis/src/process_cmt.ml

@@ -669,12 +669,20 @@ and for_module ~env (mod_expr : Typedtree.module_expr) module_name =
       in
       Stamps.add_module env.stamps stamp declared);
     for_module ~env result_expr module_name
-  | Tmod_apply _ ->
+  | Tmod_apply (functor_, _arg, _coercion) ->
     (* The functor's body has the parameter's types; the application's
        signature has the argument's. Its items keep the identifiers of the
        body, whose stamps are already taken, so they are renamed first,
-       with stamps above any that a compilation hands out. *)
+       with stamps above any that a compilation hands out. Their locations
+       are in the functor's body, so they are marked as coming from the
+       functor, like included items, for definitions to find its file. *)
     let env = env |> Env.add_module ~name:module_name in
+    let env =
+      match get_module_path functor_.mod_desc with
+      | Some path ->
+        {env with module_path = IncludedModule (path, env.module_path)}
+      | None -> env
+    in
     if Ident.current_time () < renamed_stamp_floor then
       Ident.set_current_time renamed_stamp_floor;
     for_type_module ~name:module_name ~env

analysis/src/signature_help.ml

@@ -12,7 +12,7 @@ let docs_for_label type_expr ~file ~state ~package ~supports_markdown_links =
     |> List.map (fun {Hover.decl; name; env; loc; path} ->
         let link_to_type_definition_str =
           if supports_markdown_links then
-            Markdown.go_to_definition_text ~env ~pos:loc.Warnings.loc_start
+            Markdown.go_to_definition_text ~env ~pos:loc.Warnings.loc_start ()
           else ""
         in
         (* Since printing the whole name via its path can get quite long, and

tests/analysis_tests/tests/src/AppliedFunctorUse.res

@@ -0,0 +1,10 @@
+module StrSet = AppliedFunctor.MakeSet({
+  type t = string
+  let compare = (a: string, b) => a < b ? -1 : a > b ? 1 : 0
+})
+
+let s = StrSet.add([], "a")
+//             ^def
+
+let t: StrSet.t = []
+//            ^hov

tests/analysis_tests/tests/src/expected/AppliedFunctorUse.res.txt

@@ -0,0 +1,17 @@
+Definition src/AppliedFunctorUse.res 5:15
+{
+  "range": {
+    "end": { "character": 9, "line": 7 },
+    "start": { "character": 6, "line": 7 }
+  },
+  "uri": "file:///AppliedFunctor.res"
+}
+
+Hover src/AppliedFunctorUse.res 8:14
+{
+  "contents": {
+    "kind": "markdown",
+    "value": "```rescript\nStrSet.t\n```\n\n---\n\n```\n \n```\n```rescript\ntype StrSet.t = array<string>\n```\nGo to: [Type definition](AppliedFunctor.res#L7,3)\n"
+  }
+}
+