Show C# and VB uses of an F# symbol in Find All References

docs/release-notes/.VisualStudio/18.vNext.md

@@ -4,6 +4,7 @@
 * Code-fixes for FS3888 (compiler-semantic attribute on the `.fs` but not the `.fsi`): copy the attribute into the `.fsi`, or remove it from the `.fs`. ([Issue #19560](https://github.com/dotnet/fsharp/issues/19560), [PR #19880](https://github.com/dotnet/fsharp/pull/19880))
 * Expand `<inheritdoc/>` in IDE tooltips, completion, and signature help, inheriting XML documentation from base classes, interfaces, overridden members, and constructors. ([Issue #19175](https://github.com/dotnet/fsharp/issues/19175), [PR #19188](https://github.com/dotnet/fsharp/pull/19188))
 * Added a **Tools > Options > F# Tools > Compiler** option, **"Use the .NET SDK F# compiler for builds"**, on by default. Visual Studio uses the .NET SDK F# compiler when the project supplies SDK paths, matching `dotnet build`. Otherwise, it uses the bundled .NET Framework compiler. Turn the option off to use the bundled compiler for all projects. Changes are saved on Apply or OK; Cancel discards unsaved changes. Command-line builds are unaffected. ([Issue #20484](https://github.com/dotnet/fsharp/issues/20484), [PR #20485](https://github.com/dotnet/fsharp/pull/20485))
+* Find All References on an F# symbol also lists its uses in C# and Visual Basic projects that reference the F# project's built assembly. ([PR #20463](https://github.com/dotnet/fsharp/pull/20463))
 
 ### Fixed
 

eng/Packages.props

@@ -36,6 +36,7 @@
     <PackageVersion Include="Microsoft.Build.Tasks.Core" Version="$(MicrosoftBuildTasksCoreVersion)" />
     <PackageVersion Include="Microsoft.Build.Utilities.Core" Version="$(MicrosoftBuildUtilitiesCoreVersion)" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisCSharpVersion)" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(MicrosoftCodeAnalysisCSharpVersion)" />
     <PackageVersion Include="Microsoft.CodeAnalysis.EditorFeatures" Version="$(MicrosoftCodeAnalysisEditorFeaturesTextVersion)" />
     <PackageVersion Include="Microsoft.CodeAnalysis.EditorFeatures.Text" Version="$(MicrosoftCodeAnalysisEditorFeaturesTextVersion)" />
     <PackageVersion Include="Microsoft.VisualStudio.LanguageServices.ExternalAccess" Version="$(MicrosoftVisualStudioLanguageServicesExternalAccessVersion)" />

vsintegration/src/FSharp.Editor/LanguageService/ProjectFiltering.fs

@@ -11,15 +11,46 @@ module internal ProjectFiltering =
     /// #10227: Filters projects to those referencing a specific assembly file.
     /// Used to optimize Find All References for external DLL symbols.
     let getProjectsReferencingAssembly (assemblyFilePath: string) (solution: Solution) =
-        let assemblyFileName = Path.GetFileName(assemblyFilePath)
+        let assemblyFileName = Path.GetFileName assemblyFilePath
+
+        let sameFileName (path: string) =
+            not (String.IsNullOrEmpty path)
+            && String.Equals(Path.GetFileName path, assemblyFileName, StringComparison.OrdinalIgnoreCase)
+
+        let samePath (path: string) (other: string) =
+            String.Equals(path, other, StringComparison.OrdinalIgnoreCase)
+
+        // The output paths of each project that produces an assembly of this name. The target frameworks of a
+        // multi-targeted project are projects of their own that share its project file: they are one producer,
+        // writing the assembly once per target.
+        let producers =
+            solution.Projects
+            |> Seq.filter (fun project -> sameFileName project.OutputFilePath)
+            |> Seq.groupBy _.FilePath
+            |> Seq.map (fun (_, targets) -> targets |> Seq.map _.OutputFilePath |> Seq.toArray)
+            |> Seq.toArray
+
+        // A consumer references the copy in its own output rather than the file the producer writes, so the
+        // name is what identifies the assembly. It stops identifying it once another project of the solution
+        // produces one named the same, and then only the paths the declaring project writes to will do.
+        let nameIsAmbiguous = producers.Length > 1
+
+        let declaringOutputs =
+            producers
+            |> Array.tryFindV (Array.exists (samePath assemblyFilePath))
+            |> ValueOption.defaultValue [| assemblyFilePath |]
+
+        let isTheAssembly (path: string) =
+            if nameIsAmbiguous then
+                declaringOutputs |> Array.exists (samePath path)
+            else
+                sameFileName path
 
         solution.Projects
         |> Seq.filter (fun project ->
             project.MetadataReferences
             |> Seq.exists (fun metaRef ->
                 match metaRef with
-                | :? PortableExecutableReference as peRef when not (isNull peRef.FilePath) ->
-                    let refFileName = Path.GetFileName(peRef.FilePath)
-                    String.Equals(refFileName, assemblyFileName, StringComparison.OrdinalIgnoreCase)
+                | :? PortableExecutableReference as peRef -> isTheAssembly peRef.FilePath
                 | _ -> false))
         |> Seq.toList

vsintegration/src/FSharp.Editor/LanguageService/Symbols.fs

@@ -1,6 +1,7 @@
 [<AutoOpen>]
 module internal Microsoft.VisualStudio.FSharp.Editor.Symbols
 
+open System
 open System.IO
 open Microsoft.CodeAnalysis
 open FSharp.Compiler.CodeAnalysis
@@ -35,6 +36,29 @@ type FSharpSymbol with
         | :? FSharpField -> not publicOrInternal
         | _ -> false
 
+    /// The documentation comment id of the symbol's compiled form, as C# and VB compilations resolve it.
+    member this.DocumentationCommentId =
+        let xmlDocSig =
+            match this with
+            | :? FSharpMemberOrFunctionOrValue as value ->
+                match value.XmlDocSig with
+                // A literal compiles to a field, which Roslyn names F: where FCS says P:.
+                | docSig when value.LiteralValue.IsSome && docSig.StartsWith("P:", StringComparison.Ordinal) -> $"F:{docSig.Substring 2}"
+                | docSig -> docSig
+            | :? FSharpEntity as entity -> entity.XmlDocSig
+            | :? FSharpField as field ->
+                match field.XmlDocSig with
+                // An enum case compiles to a field too, and FCS names it P: where Roslyn says F:.
+                | docSig when field.IsLiteral && docSig.StartsWith("P:", StringComparison.Ordinal) -> $"F:{docSig.Substring 2}"
+                | docSig -> docSig
+            | :? FSharpUnionCase as unionCase -> unionCase.XmlDocSig
+            | _ -> ""
+
+        if String.IsNullOrEmpty xmlDocSig then
+            ValueNone
+        else
+            ValueSome xmlDocSig
+
 type FSharpSymbolUse with
 
     member this.GetSymbolScope(currentDocument: Document) : SymbolScope option =

vsintegration/src/FSharp.Editor/Navigation/FindUsagesService.fs

@@ -2,6 +2,7 @@
 
 namespace Microsoft.VisualStudio.FSharp.Editor
 
+open System.Collections.Generic
 open System.Collections.Immutable
 open System.Composition
 open System.Threading.Tasks
@@ -10,6 +11,8 @@ open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp.FindUsages
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp.Editor.FindUsages
+open Microsoft.CodeAnalysis.FindSymbols
+open Microsoft.CodeAnalysis.Text
 
 open FSharp.Compiler.EditorServices
 open FSharp.Compiler.Text
@@ -44,7 +47,7 @@ module FSharpFindUsagesService =
                             externalDefinitionItem
                         else
                             definitionItems
-                            |> Array.tryFindV (snd >> (=) doc.Project.FilePath)
+                            |> Array.tryFindV (fun (_, project: Project) -> project.FilePath = doc.Project.FilePath)
                             |> ValueOption.map (fun (definitionItem, _) -> definitionItem)
                             |> ValueOption.defaultValue externalDefinitionItem
 
@@ -84,6 +87,82 @@ module FSharpFindUsagesService =
                 return spans |> Array.choose id
             }
 
+    let private referencingCompilationProjects (declaringProject: Project) =
+        match declaringProject.OutputFilePath with
+        | null -> []
+        | outputFilePath ->
+            ProjectFiltering.getProjectsReferencingAssembly outputFilePath declaringProject.Solution
+            |> List.filter (fun project -> not project.IsFSharp && project.SupportsCompilation)
+
+    /// Locations in a C# or VB project of the symbol with the given documentation comment id.
+    let private findRoslynReferences (docId: string) (declaringAssembly: string) (project: Project) =
+        cancellableTask {
+            let! cancellationToken = CancellableTask.getCancellationToken ()
+
+            match! project.GetCompilationAsync cancellationToken with
+            | null -> return Seq.empty
+            | compilation ->
+                // The id names a symbol of the F# assembly. A consumer that declares the same name itself
+                // would answer a compilation-wide lookup first, and the search would report its uses.
+                let ofDeclaringAssembly =
+                    DocumentationCommentId.GetSymbolsForDeclarationId(docId, compilation)
+                    |> Seq.tryFind (fun symbol ->
+                        match symbol.ContainingAssembly with
+                        | null -> false
+                        | assembly -> System.String.Equals(assembly.Name, declaringAssembly, System.StringComparison.OrdinalIgnoreCase))
+
+                match ofDeclaringAssembly with
+                | None -> return Seq.empty
+                | Some symbol ->
+                    let! referencedSymbols =
+                        SymbolFinder.FindReferencesAsync(
+                            symbol,
+                            project.Solution,
+                            ImmutableHashSet.CreateRange project.Documents,
+                            cancellationToken
+                        )
+
+                    return referencedSymbols |> Seq.collect _.Locations
+        }
+
+    // Every search may build a compilation, and those cost memory, not just a core.
+    [<Literal>]
+    let private ConcurrentCompilations = 4
+
+    /// The uses in the C# and VB projects that reference the assembly of a project declaring the symbol,
+    /// each with the definition item to report them under.
+    let private findCrossLanguageReferences (docId: string) (definitionItems: (FSharpDefinitionItem * Project)[]) =
+        seq {
+            for definitionItem, declaringProject in definitionItems do
+                for project in referencingCompilationProjects declaringProject -> definitionItem, declaringProject.AssemblyName, project
+        }
+        |> Seq.distinctBy (fun (_, _, project) -> project.Id)
+        |> Seq.map (fun (definitionItem, declaringAssembly, project) ->
+            findRoslynReferences docId declaringAssembly project
+            |> CancellableTask.map (Seq.map (fun location -> definitionItem, location)))
+        |> CancellableTask.whenAllThrottled ConcurrentCompilations
+        |> CancellableTask.map Seq.concat
+
+    /// Reports each file span once: the target-framework instances of a consumer share their files.
+    let private reportCrossLanguageReferences
+        (found: (FSharpDefinitionItem * ReferenceLocation) seq)
+        (onReferenceFoundAsync: FSharpSourceReferenceItem -> Task)
+        =
+        cancellableTask {
+            let reported = HashSet<struct (string * TextSpan)>()
+
+            for definitionItem, location in found do
+                let span = location.Location.SourceSpan
+
+                if reported.Add(struct (location.Document.FilePath, span)) then
+                    // Same as the F# path above: the window throws inside Roslyn on an item it will not take,
+                    // and one such item must not end the search that found the rest.
+                    try
+                        do! onReferenceFoundAsync (FSharpSourceReferenceItem(definitionItem, FSharpDocumentSpan(location.Document, span)))
+                    with _ ->
+                        ()
+        }
+
     let findReferencedSymbolsAsync
         (document: Document, position: int, context: IFSharpFindUsagesContext, allReferences: bool, userOp: string)
         : CancellableTask<unit> =
@@ -139,7 +218,7 @@ module FSharpFindUsagesService =
 
                     let definitionItems =
                         declarationSpans
-                        |> Array.map (fun span -> FSharpDefinitionItem.Create(tags, displayParts, span), span.Document.Project.FilePath)
+                        |> Array.map (fun span -> FSharpDefinitionItem.Create(tags, displayParts, span), span.Document.Project)
 
                     do!
                         definitionItems
@@ -159,7 +238,16 @@ module FSharpFindUsagesService =
                             symbol.Ident.idText
                             context.OnReferenceFoundAsync
 
+                    // Searched alongside the F# projects, reported after them.
+                    let crossLanguageSearch =
+                        match symbolUse.Symbol.DocumentationCommentId with
+                        | ValueSome docId when allReferences && not isExternal && not symbolUse.Symbol.IsInternalToProject ->
+                            findCrossLanguageReferences docId definitionItems cancellationToken
+                        | _ -> Task.FromResult Seq.empty
+
                     do! SymbolHelpers.findSymbolUses symbolUse document checkFileResults onFound
+                    let! found = crossLanguageSearch
+                    do! reportCrossLanguageReferences found context.OnReferenceFoundAsync
         }
 
 open FSharpFindUsagesService

vsintegration/tests/FSharp.Editor.Tests/FSharp.Editor.Tests.fsproj

@@ -27,6 +27,7 @@
     <Compile Include="IndentationServiceTests.fs" />
     <Compile Include="CompletionProviderTests.fs" />
     <Compile Include="FindReferencesTests.fs" />
+    <Compile Include="FindReferencesFromCSharpTests.fs" />
     <Compile Include="GoToDefinitionServiceTests.fs" />
     <Compile Include="PathMapNavigationTests.fs" />
     <Compile Include="HelpContextServiceTests.fs" />
@@ -95,6 +96,7 @@
   <ItemGroup>
 	<PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" />
 	<PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
+	<PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" />
 
 	<PackageReference Include="Microsoft.VisualStudio.LanguageServices.ExternalAccess" />
     <PackageReference Include="Microsoft.VisualStudio.Platform.VSEditor" />