Keep the compile directory unless a mapped name already starts with it

A relative name in metadata is relative to the directory the assembly was
compiled in, as the #line names that compilers before F# 10 wrote are. A path
map writes the files compiled from under that directory with the mapped
directory at their start, so only such a name is used as is; the directory
being relative did not prove a name was mapped.

The in-memory test gives way to one that compiles the library out of process
from its own directory and references the emitted assembly, with no map, a
relative one and the rooted /_/ one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: xperiandri

docs/release-notes/.FSharp.Compiler.Service/11.0.200.md

@@ -5,7 +5,7 @@
 ### Fixed
 
 * A project reusing cached framework imports is checked with its own `--pathmap` instead of the map of the project that filled the cache, so the ranges of its in-memory reference data name its real files. ([Issue #20474](https://github.com/dotnet/fsharp/issues/20474), [PR #20476](https://github.com/dotnet/fsharp/pull/20476))
-* `GetDeclarationLocation` no longer names the compile-time directory twice for a declaration in an assembly built with `--pathmap` (as `DeterministicSourcePaths` sets it). Such a build maps the directory it compiled in as well as the file names of its ranges, so both already reach the same root and joining them repeated the directory, leaving a path that matches no file. ([PR #20518](https://github.com/dotnet/fsharp/pull/20518))
+* `GetDeclarationLocation` no longer names the compile-time directory twice for a declaration in an assembly built with a relative `--pathmap`. Such a build maps the directory it compiled in along with its file names, so a file from under that directory already starts with it, and joining the two left a path that matches no file. Other relative names, such as the `#line` names that compilers before F# 10 wrote, are still resolved against that directory. ([PR #20518](https://github.com/dotnet/fsharp/pull/20518))
 * Split Linux CoreCLR CI into two parallel test batches to reduce test turnaround time. ([PR #20587](https://github.com/dotnet/fsharp/pull/20587))
 * Fix `NativePtr.stackalloc` used inside the `with` handler, filter or `finally` block of a `try` expression producing an assembly that throws `InvalidProgramException` at method load. Direct or mandatory-inline allocations are now reported at compile time as error FS3924; calls to non-inline allocation helpers, including handler-local helpers, remain legal and retain their method boundary during inlining and let-binding elimination. ([Issue #20295](https://github.com/dotnet/fsharp/issues/20295), [PR #20491](https://github.com/dotnet/fsharp/pull/20491))
 * `FsiEvaluationSession.EvalInteraction` and `EvalInteractionNonThrowing` evaluate every `;;`-separated interaction in the text they are given, as their documentation has always said, instead of silently discarding everything after the first. ([PR #20396](https://github.com/dotnet/fsharp/pull/20396))

src/Compiler/Symbols/SymbolHelpers.fs

@@ -231,10 +231,16 @@ module internal SymbolHelpers =
         let file = m.FileName
         if verbose then dprintf "file stored in metadata is '%s'\n" file
 
-        // A build that maps its source paths maps the directory it compiled in as well, so that directory
-        // and the file name reach the same unrecorded root on their own: joining them repeats the directory.
+        // A relative name is relative to the directory the assembly was compiled in, as the #line names that
+        // compilers before F# 10 wrote are. A path map rewrites that directory along with the files compiled
+        // from under it, though, so such a file already starts with the directory: joining them repeats it.
         let underDirectory (dir: string) =
-            if FileSystem.IsPathRootedShim dir then Path.Combine(dir, file) else file
+            let startsWithDirectory =
+                file.Length > dir.Length
+                && file.StartsWithOrdinal dir
+                && (file[dir.Length] = '\\' || file[dir.Length] = '/')
+
+            if startsWithDirectory then file else Path.Combine(dir, file)
 
         if not (FileSystem.IsPathRootedShim file) then
             match ccuOfItem g h with

tests/FSharp.Compiler.ComponentTests/FSharpChecker/PathMap.fs

@@ -3,9 +3,13 @@ module FSharpChecker.PathMap
 open System.IO
 open System.Threading.Tasks
 open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
 open FSharp.Test.ProjectGeneration
+open FSharp.Test.Utilities
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.EditorServices
+open FSharp.Compiler.Symbols
 open FSharp.Compiler.Text
 
 let private checkWith (checker: FSharpChecker) (project: SyntheticProject) =
@@ -57,58 +61,84 @@ let ``a sibling's path map does not reach the ranges of a project without one``
         Assert.Equal(library.GetFilePath "Library", libraryFunction.Symbol.DeclarationLocation.Value.FileName)
     }
 
-/// A build that maps its source paths maps the directory it compiled in as well, so the file name of a
-/// range and that directory both reach the same root on their own. Joining them names the directory twice.
+/// Compiles the library from its own directory, as a build does: the assembly records that directory as the one it
+/// was compiled in.
+let private emitLibrary (root: string) (pathMap: string list) =
+    let projectDir = Directory.CreateDirectory(Path.Combine(root, "src", "Domain")).FullName
+    File.WriteAllText(Path.Combine(projectDir, "Library.fs"), "module Library\n\nlet f x = x + 1\n")
+
+    let result =
+        runFscProcessIn projectDir [
+            "--target:library"
+            yield! CompilerAssert.DefaultProjectOptions(TargetFramework.Current).OtherOptions
+            yield! pathMap
+            "-o:Library.dll"
+            "Library.fs"
+        ]
+
+    Assert.True((result.ExitCode = 0), $"fsc exited with {result.ExitCode}:\n{result.StdOut}\n{result.StdErr}")
+    projectDir
+
+/// Read back through the path map, a declaration names the file the library was compiled from, whatever the map.
+/// The compiler writes each name under a path map with the mapped directory it compiled in at its start; a #line
+/// name, which compilers before F# 10 wrote instead, is relative to that directory.
 [<Theory>]
-[<InlineData(false)>]
-[<InlineData(true)>]
-let ``a declaration in a project with a path map is named from the root once`` (useTransparentCompiler: bool) : Task =
+[<InlineData("")>]
+[<InlineData(".")>]
+[<InlineData("/_/")>]
+let ``a declaration in a referenced assembly names the file it was compiled from`` (mappedRoot: string) : Task =
     task {
-        let checker = FSharpChecker.Create(useTransparentCompiler = useTransparentCompiler)
-        let library = SyntheticProject.Create("MappedLibrary", sourceFile "Library" [])
-        let root = Path.GetDirectoryName library.ProjectDir
+        let root = TestFramework.createTemporaryDirectory().FullName
+        let pathMap = if mappedRoot = "" then [] else [ $"--pathmap:{root}={mappedRoot}" ]
+        let projectDir = emitLibrary root pathMap
 
-        let library =
-            { library with
-                OtherOptions = [ $"--pathmap:{root}=.{Path.DirectorySeparatorChar}" ] }
+        let usageLine = "let _ = Library.f 1"
+        let source = $"module Consumer\n{usageLine}\n"
+        let consumer = Path.Combine(root, "Consumer.fs")
+        File.WriteAllText(consumer, source)
 
-        let app =
-            { SyntheticProject.Create("MappedApp", sourceFile "App" [ "Library" ]) with
-                DependsOn = [ library ] }
+        let options =
+            let defaults = CompilerAssert.DefaultProjectOptions(TargetFramework.Current)
 
-        do! checkWith checker library
-        do! checkWith checker app
-
-        let appFile = app.GetFilePath "App"
-        let appLines = File.ReadAllLines appFile
+            { defaults with
+                SourceFiles = [| consumer |]
+                OtherOptions = [| yield! defaults.OtherOptions; $"""-r:{Path.Combine(projectDir, "Library.dll")}""" |] }
 
-        let! _, answer =
-            checker.ParseAndCheckFileInProject(
-                appFile,
-                0,
-                SourceText.ofString (File.ReadAllText appFile),
-                app.GetProjectOptions checker
-            )
+        let! _, answer = FSharpChecker.Create().ParseAndCheckFileInProject(consumer, 0, SourceText.ofString source, options)
 
         let checkResults =
             match answer with
             | FSharpCheckFileAnswer.Succeeded checkResults -> checkResults
             | FSharpCheckFileAnswer.Aborted -> failwith "the check was aborted"
 
-        let usage =
-            checkResults.GetAllUsesOfAllSymbolsInFile()
-            |> Seq.find (fun symbolUse -> symbolUse.Symbol.FullName = $"{library.Name}.ModuleLibrary.f")
+        let endOfName = usageLine.Length - " 1".Length
+        let names = [ "Library"; "f" ]
 
         let declaration =
-            checkResults.GetDeclarationLocation(
-                usage.Range.EndLine,
-                usage.Range.EndColumn,
-                appLines[usage.Range.EndLine - 1],
-                [ "ModuleLibrary"; "f" ]
-            )
-
-        match declaration with
-        | FindDeclResult.DeclFound range ->
-            Assert.Equal(library.GetFilePath "Library", Path.GetFullPath(Path.Combine(root, range.FileName)))
-        | result -> failwith $"expected the declaration of ModuleLibrary.f, got %A{result}"
+            match checkResults.GetDeclarationLocation(2, endOfName, usageLine, names) with
+            | FindDeclResult.DeclFound range -> range
+            | result -> failwith $"expected the declaration of Library.f, got %A{result}"
+
+        // Since F# 10 the compiler writes the real file for a #line directive, so the name an older one wrote is
+        // resolved against this assembly's recorded directory directly
+        let fromLineDirective =
+            let symbol = checkResults.GetSymbolUseAtLocation(2, endOfName, usageLine, names).Value.Symbol
+            let range = Range.mkRange "Original.fs" declaration.Start declaration.End
+            SymbolHelpers.fileNameOfItem symbol.SymbolEnv.g None range symbol.Item
+
+        // A reader that knows the map turns a name back into the file it stands for, reading a rooted name as the
+        // full path GetDeclarationLocation gives
+        let compiledFrom (fileName: string) =
+            let asRead (path: string) =
+                if Path.IsPathRooted path then Path.GetFullPath path else path
+
+            if mappedRoot = "" then
+                Path.GetFullPath fileName
+            else
+                let fileName, mappedRoot = asRead fileName, asRead mappedRoot
+                Assert.StartsWith(mappedRoot, fileName)
+                Path.GetFullPath(Path.Combine(root, fileName.Substring(mappedRoot.Length).TrimStart('/', '\\')))
+
+        Assert.Equal(Path.Combine(projectDir, "Library.fs"), compiledFrom declaration.FileName)
+        Assert.Equal(Path.Combine(projectDir, "Original.fs"), compiledFrom fromLineDirective)
     }

tests/FSharp.Test.Utilities/Compiler.fs

@@ -2552,24 +2552,28 @@ $ code --diff {outFile} {expectedFile}
     type ProcessResult = { ExitCode: int; StdOut: string; StdErr: string }
 
     /// Run an F# tool (FSI or FSC) as a subprocess. Shared helper for runFsiProcess / runFscProcess.
-    let private runToolProcess (toolPath: string) (args: string list) : ProcessResult =
+    let private runToolProcess (toolPath: string) (workingDirectory: string) (args: string list) : ProcessResult =
 #if NETCOREAPP
         let exe = TestFramework.initialConfig.DotNetExe
         let arguments = toolPath + " " + (args |> String.concat " ")
 #else
         let exe = toolPath
         let arguments = args |> String.concat " "
 #endif
-        let exitCode, stdout, stderr = Commands.executeProcess exe arguments (Directory.GetCurrentDirectory())
+        let exitCode, stdout, stderr = Commands.executeProcess exe arguments workingDirectory
         { ExitCode = exitCode; StdOut = stdout; StdErr = stderr }
 
     /// Run FSI as a subprocess with the given arguments. For CLI-level tests only (--help, exit codes, etc.).
     let runFsiProcess (args: string list) : ProcessResult =
-        runToolProcess TestFramework.initialConfig.FSI args
+        runToolProcess TestFramework.initialConfig.FSI (Directory.GetCurrentDirectory()) args
+
+    /// Run FSC as a subprocess in the given directory, which the compiled assembly records as the one it was compiled in.
+    let runFscProcessIn (workingDirectory: string) (args: string list) : ProcessResult =
+        runToolProcess TestFramework.initialConfig.FSC workingDirectory args
 
     /// Run FSC as a subprocess with the given arguments. For CLI-level tests only (missing files, exit codes, etc.).
     let runFscProcess (args: string list) : ProcessResult =
-        runToolProcess TestFramework.initialConfig.FSC args
+        runFscProcessIn (Directory.GetCurrentDirectory()) args
 
     /// Compile-and-run a compilation unit that depends on a FSharp.Core attribute
     /// which may not yet be shipped in the SDK's NuGet package.