Add support for active patterns in reference finding and enhance tests

- Implemented logic to search for both active pattern functions and their cases in reference finding.
- Added tests for active pattern usage, including partial and total patterns.
- Created new project structure for active pattern test cases.
- Updated existing tests to include active pattern references across modules.

Author: TheAngryByrd

src/FsAutoComplete.Core/Commands.fs

@@ -841,6 +841,57 @@ module Commands =
 
         let dict = ConcurrentDictionary()
 
+        // For active patterns, we need to search for both the function and its cases
+        // because FCS doesn't always find cross-file references correctly
+        let symbolsToSearch =
+          match symbol with
+          | :? FSharpActivePatternCase as apCase ->
+            // At a usage site: we have a case, also search for the declaring function
+            // e.g., for case `ParseInt` in `(|ParseInt|_|)`, also search for the function
+            match apCase.Group.DeclaringEntity with
+            | Some entity ->
+              // Search for the function using the pattern "|CaseName|" to match within the full pattern name
+              // e.g., for case "ParseInt", search for function containing "|ParseInt|"
+              let apcSearchString = $"|{apCase.DisplayName}|"
+
+              let declaringMember =
+                try
+                  entity.MembersFunctionsAndValues
+                  |> Seq.tryFind (fun m ->
+                    m.DisplayName.Contains(apcSearchString, System.StringComparison.OrdinalIgnoreCase)
+                    || m.CompiledName.Contains(apCase.DisplayName, System.StringComparison.OrdinalIgnoreCase))
+                with _ ->
+                  None
+
+              match declaringMember with
+              | Some m -> [ symbol; m :> FSharpSymbol ]
+              | None -> [ symbol ]
+            | None -> [ symbol ]
+          | :? FSharpMemberOrFunctionOrValue as mfv when mfv.IsActivePattern ->
+            // At a declaration site: this is an active pattern function
+            // We need to search for both the function AND its individual cases to find all usages
+            // FCS finds function-call style usages (e.g., `(|ParseFloat|_|) x`) for the function
+            // FCS finds match-case style usages (e.g., `| ParseFloat x ->`) for the cases
+            match mfv.DeclaringEntity with
+            | Some entity ->
+              // Get all active pattern cases in the entity and find those matching this function's cases
+              let functionCases =
+                try
+                  entity.ActivePatternCases
+                  |> Seq.filter (fun apc ->
+                    // Match case to function by checking if the function's display name contains the case name
+                    // e.g., for function "|ParseFloat|_|", case would be "ParseFloat"
+                    mfv.DisplayName.Contains($"|{apc.DisplayName}|", System.StringComparison.OrdinalIgnoreCase))
+                  |> Seq.map (fun apc -> apc :> FSharpSymbol)
+                  |> Seq.toList
+                with _ ->
+                  []
+              symbol :: functionCases
+            | None -> [ symbol ]
+          | :? FSharpMemberOrFunctionOrValue ->
+            [ symbol ]
+          | _ -> [ symbol ]
+
         /// Adds References of `symbol` in `file` to `dict`
         ///
         /// `Error` iff adjusting ranges failed (including cannot get source) and `errorOnFailureToFixRange`. Otherwise always `Ok`
@@ -849,7 +900,20 @@ module Commands =
             if dict.ContainsKey file then
               return Ok()
             else
-              let! references = findReferencesForSymbolInFile (file, project, symbol)
+              // Search for all related symbols (for active pattern cases, includes the declaring member)
+              let! allReferences =
+                symbolsToSearch
+                |> List.map (fun s -> findReferencesForSymbolInFile (file, project, s) |> Async.map Seq.toArray)
+                |> Async.Parallel
+
+              let references =
+                allReferences
+                |> Array.concat
+                // Deduplicate - when searching for multiple symbols (e.g., active pattern function + cases),
+                // they may return duplicate ranges at the same location
+                // Use distinctBy with a tuple key since Range objects may not be structurally equal
+                |> Array.distinctBy (fun r -> r.StartLine, r.StartColumn, r.EndLine, r.EndColumn)
+                |> Array.toSeq
 
               let references =
                 if includeDeclarations then

test/FsAutoComplete.Tests.Lsp/FindReferencesTests.fs

@@ -609,6 +609,55 @@ let private rangeTests state =
           | MyModule.$<Even>$ -> ()
           | MyModule.Odd -> ()
         """
+      testCaseAsync "can get range of partial Active Pattern"
+      <|
+      // Partial active pattern: `(|ParseInt|_|)` - returns Option
+      // The `|_|` indicates it's partial (can fail to match)
+      checkRanges
+        server
+        """
+        module MyModule =
+          let ($D<|Pa$0rseInt|_|>D$) (input: string) =
+            match System.Int32.TryParse input with
+            | true, v -> Some v
+            | false, _ -> None
+
+        open MyModule
+        let _ = ($<|ParseInt|_|>$) "42"
+        let _ = MyModule.($<|ParseInt|_|>$) "42"
+        let _ =
+          match "42" with
+          | ParseInt v -> v
+          | _ -> 0
+        let _ =
+          match "42" with
+          | MyModule.ParseInt v -> v
+          | _ -> 0
+        """
+      testCaseAsync "can get range of partial Active Pattern case"
+      <|
+      // When clicking on the case name in a partial active pattern
+      checkRanges
+        server
+        """
+        module MyModule =
+          let (|$D<ParseInt>D$|_|) (input: string) =
+            match System.Int32.TryParse input with
+            | true, v -> Some v
+            | false, _ -> None
+
+        open MyModule
+        let _ = (|ParseInt|_|) "42"
+        let _ = MyModule.(|ParseInt|_|) "42"
+        let _ =
+          match "42" with
+          | $<Par$0seInt>$ v -> v
+          | _ -> 0
+        let _ =
+          match "42" with
+          | MyModule.$<ParseInt>$ v -> v
+          | _ -> 0
+        """
       testCaseAsync "can get range of type for static function call"
       <| checkRanges
         server

test/FsAutoComplete.Tests.Lsp/TestCases/FindReferences/ActivePatternProject/ActivePatternProject.fsproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Patterns.fs" />
+    <Compile Include="Module1.fs" />
+    <Compile Include="Module2.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+</Project>

test/FsAutoComplete.Tests.Lsp/TestCases/FindReferences/ActivePatternProject/Module1.fs

@@ -0,0 +1,88 @@
+namespace ActivePatternProject
+
+/// First module that uses patterns from Patterns module
+module Module1 =
+    open Patterns
+
+    // Using total active pattern Even|Odd
+    let classifyNumber n =
+        match n with
+        | Even -> "even"
+        | Odd -> "odd"
+
+    // Using total active pattern as function
+    let getEvenOdd n = (|Even|Odd|) n
+
+    // Using partial active pattern ParseInt
+    let tryParseNumber input =
+        match input with
+        | ParseInt n -> Some n
+        | _ -> None
+
+    // Using partial active pattern as function
+    let parseIntDirect input = (|ParseInt|_|) input
+
+    // Using ParseFloat partial active pattern
+    let tryParseFloat input =
+        match input with
+        | ParseFloat f -> Some f
+        | _ -> None
+
+    // Using ParseFloat as function
+    let parseFloatDirect input = (|ParseFloat|_|) input
+
+    // Using parameterized active pattern
+    let isDivisibleBy3 n =
+        match n with
+        | DivisibleBy 3 result -> Some result
+        | _ -> None
+
+    // Using multiple patterns in one match
+    let analyzeNumber n =
+        match n with
+        | Even & Positive -> "even positive"
+        | Even & Negative -> "even negative"
+        | Odd & Positive -> "odd positive"
+        | Odd & Negative -> "odd negative"
+        | Zero -> "zero"
+
+    // Using Positive|Negative|Zero pattern
+    let getSign n =
+        match n with
+        | Positive -> 1
+        | Negative -> -1
+        | Zero -> 0
+
+    // ============================================
+    // STRUCT PARTIAL ACTIVE PATTERNS
+    // ============================================
+
+    // Using struct partial active pattern ParseIntStruct
+    let tryParseNumberStruct input =
+        match input with
+        | ParseIntStruct n -> ValueSome n
+        | _ -> ValueNone
+
+    // Using struct partial active pattern as function
+    let parseIntStructDirect input = (|ParseIntStruct|_|) input
+
+    // Using ParseFloatStruct partial active pattern
+    let tryParseFloatStruct input =
+        match input with
+        | ParseFloatStruct f -> ValueSome f
+        | _ -> ValueNone
+
+    // Using ParseFloatStruct as function
+    let parseFloatStructDirect input = (|ParseFloatStruct|_|) input
+
+    // Using NonEmptyStruct partial active pattern
+    let validateInputStruct input =
+        match input with
+        | NonEmptyStruct s -> ValueSome s
+        | _ -> ValueNone
+
+    // Using struct parameterized active pattern
+    let isDivisibleBy3Struct n =
+        match n with
+        | DivisibleByStruct 3 result -> ValueSome result
+        | _ -> ValueNone

test/FsAutoComplete.Tests.Lsp/TestCases/FindReferences/ActivePatternProject/Module2.fs

@@ -0,0 +1,88 @@
+namespace ActivePatternProject
+
+/// Second module - uses patterns with qualified access
+module Module2 =
+
+    // Using patterns with fully qualified names
+    let classifyWithQualified n =
+        match n with
+        | Patterns.Even -> "even"
+        | Patterns.Odd -> "odd"
+
+    // Using partial pattern with qualified name
+    let parseWithQualified input =
+        match input with
+        | Patterns.ParseInt n -> Some n
+        | _ -> None
+
+    // Using the pattern as a function with qualified name
+    let parseIntQualified input = Patterns.(|ParseInt|_|) input
+    let evenOddQualified n = Patterns.(|Even|Odd|) n
+
+    // Using Regex pattern
+    let matchEmail input =
+        match input with
+        | Patterns.Regex @"[\w.]+@[\w.]+" email -> Some email
+        | _ -> None
+
+    // Using NonEmpty pattern
+    let validateInput input =
+        match input with
+        | Patterns.NonEmpty s -> Ok s
+        | _ -> Error "Input cannot be empty"
+
+    // Complex example with multiple patterns
+    let processInput input =
+        match input with
+        | Patterns.NonEmpty s ->
+            match s with
+            | Patterns.ParseInt n ->
+                match n with
+                | Patterns.Even -> "parsed even number"
+                | Patterns.Odd -> "parsed odd number"
+            | Patterns.ParseFloat f -> sprintf "parsed float: %f" f
+            | _ -> "non-numeric string"
+        | _ -> "empty input"
+
+    // Using DivisibleBy with different parameters
+    let checkDivisibility n =
+        match n with
+        | Patterns.DivisibleBy 2 _ -> "divisible by 2"
+        | Patterns.DivisibleBy 3 _ -> "divisible by 3"
+        | Patterns.DivisibleBy 5 _ -> "divisible by 5"
+        | _ -> "not divisible by 2, 3, or 5"
+
+    // ============================================
+    // STRUCT PARTIAL ACTIVE PATTERNS (qualified access)
+    // ============================================
+
+    // Using struct partial pattern with qualified name
+    let parseWithQualifiedStruct input =
+        match input with
+        | Patterns.ParseIntStruct n -> ValueSome n
+        | _ -> ValueNone
+
+    // Using struct pattern as a function with qualified name
+    let parseIntStructQualified input = Patterns.(|ParseIntStruct|_|) input
+    let parseFloatStructQualified input = Patterns.(|ParseFloatStruct|_|) input
+
+    // Complex example with struct patterns
+    let processInputStruct input =
+        match input with
+        | Patterns.NonEmptyStruct s ->
+            match s with
+            | Patterns.ParseIntStruct n ->
+                match n with
+                | Patterns.Even -> "parsed even number (struct)"
+                | Patterns.Odd -> "parsed odd number (struct)"
+            | Patterns.ParseFloatStruct f -> sprintf "parsed float (struct): %f" f
+            | _ -> "non-numeric string"
+        | _ -> "empty input"
+
+    // Using struct DivisibleBy with different parameters
+    let checkDivisibilityStruct n =
+        match n with
+        | Patterns.DivisibleByStruct 2 _ -> "divisible by 2 (struct)"
+        | Patterns.DivisibleByStruct 3 _ -> "divisible by 3 (struct)"
+        | Patterns.DivisibleByStruct 5 _ -> "divisible by 5 (struct)"
+        | _ -> "not divisible by 2, 3, or 5"