Add support for F# analyzers in project evaluation (#238)

* Add support for F# analyzers in project evaluation

- Extend ProjectInfo types to include Analyzers, AllProperties, and AllItems.
- Implement logic to collect all properties and items during project evaluation.
- Add a test case for loading a project with NuGet analyzers.
- Create sample project files for testing F# analyzers.

* Refactor package references in sample15-nuget-analyzers.fsproj to streamline asset management

Author: TheAngryByrd

build/Program.fs

@@ -114,7 +114,7 @@ let init args =
 
             exec
                 "dotnet"
-                $"test --blame --blame-hang-timeout 60s --framework {tfm} --logger trx --logger GitHubActions -c %s{configuration} .\\Ionide.ProjInfo.Tests\\Ionide.ProjInfo.Tests.fsproj -- %s{failedOnFocus}"
+                $"test --blame --blame-hang-timeout 120s --framework {tfm} --logger trx --logger GitHubActions -c %s{configuration} .\\Ionide.ProjInfo.Tests\\Ionide.ProjInfo.Tests.fsproj -- %s{failedOnFocus}"
                 "test"
                 (Map.ofSeq [ "BuildNet9", tfmToBuildNet9Map.[tfm].ToString() ])
             |> ignore

src/Ionide.ProjInfo/Library.fs

@@ -873,7 +873,48 @@ module ProjectLoader =
             IsPublishable = msbuildPropBool "IsPublishable"
         }
 
-    let mapToProject (path: string) (compilerArgs: string seq) (p2p: ProjectReference seq) (compile: CompileItem seq) (nugetRefs: PackageReference seq) (sdkInfo: ProjectSdkInfo) (props: Property seq) (customProps: Property seq) =
+#if DEBUG
+    let private printProperties (props: Map<string, Set<string>>) =
+        let file = Path.Combine(__SOURCE_DIRECTORY__, "props.txt")
+
+        props
+        |> Map.iter (fun key value ->
+            IO.File.AppendAllLines(file, [ $"Property: {key}" ])
+
+            value
+            |> Set.iter (fun v -> IO.File.AppendAllLines(file, [ $"  Value: {v}" ]))
+        )
+
+    let private printItems (items: Map<string, Set<string * Map<string, string>>>) =
+        let file = Path.Combine(__SOURCE_DIRECTORY__, "items.txt")
+
+        items
+        |> Map.iter (fun key value ->
+            IO.File.AppendAllLines(file, [ $"ItemType: {key}" ])
+
+            value
+            |> Set.iter (fun (include_, metadata) ->
+                IO.File.AppendAllLines(file, [ $"  Value: {include_}" ])
+
+                metadata
+                |> Map.iter (fun mk mv -> IO.File.AppendAllLines(file, [ $"    {mk}: {mv}" ]))
+            )
+        )
+#endif
+
+    let mapToProject
+        (path: string)
+        (compilerArgs: string seq)
+        (p2p: ProjectReference seq)
+        (compile: CompileItem seq)
+        (nugetRefs: PackageReference seq)
+        (sdkInfo: ProjectSdkInfo)
+        (props: Property seq)
+        (customProps: Property seq)
+        (analyzers: Analyzer list)
+        (allProps: Map<string, Set<string>>)
+        (allItems: Map<string, Set<string * Map<string, string>>>)
+        =
         let projDir = Path.GetDirectoryName path
 
         let outputType, sourceFiles, otherOptions =
@@ -944,6 +985,9 @@ module ProjectLoader =
             Items = compileItems
             Properties = List.ofSeq props
             CustomProperties = List.ofSeq customProps
+            Analyzers = analyzers
+            AllProperties = allProps
+            AllItems = allItems
         }
 
 
@@ -1005,10 +1049,78 @@ module ProjectLoader =
             let sdkInfo = getSdkInfo props
             let customProps = getProperties p customProperties
 
+            let allProperties =
+                (Map.empty, p.Properties)
+                ||> Seq.fold (fun acc p ->
+                    Map.change
+                        p.Name
+                        (function
+                        | None ->
+                            Set.singleton p.EvaluatedValue
+                            |> Some
+                        | Some v ->
+                            v
+                            |> Set.add p.EvaluatedValue
+                            |> Some)
+                        acc
+                )
+
+            let allItems =
+                (Map.empty, p.Items)
+                ||> Seq.fold (fun acc item ->
+                    let value = item.EvaluatedInclude
+
+                    let metadata =
+                        item.Metadata
+                        |> Seq.map (fun m -> m.Name, m.EvaluatedValue)
+                        |> Map.ofSeq
+
+                    Map.change
+                        item.ItemType
+                        (function
+                        | None ->
+                            Set.singleton (value, metadata)
+                            |> Some
+                        | Some items ->
+                            items
+                            |> Set.add (value, metadata)
+                            |> Some)
+                        acc
+
+                )
+
+
+            let analyzers =
+                let analyzerLikePath = Path.Combine("analyzers", "dotnet", "fs")
+
+                allProperties
+                |> Map.filter (fun k v ->
+                    k.StartsWith("Pkg")
+                    && v
+                       |> Set.exists (fun s -> Path.Exists(Path.Combine(s, analyzerLikePath)))
+                )
+                |> Seq.collect (fun (KeyValue(k, v)) ->
+                    v
+                    |> Seq.map (fun v ->
+                        let analyzerPath = Path.Combine(v, analyzerLikePath)
+
+                        {
+                            PropertyName = k
+                            NugetPackageRoot = v
+                            DllRootPath = analyzerPath
+                        }
+
+                    )
+                )
+                |> Seq.toList
+
+
             if not sdkInfo.RestoreSuccess then
                 Error "not restored"
             else
-                let proj = mapToProject path commandLineArgs p2pRefs compileItems nuGetRefs sdkInfo props customProps
+                let proj =
+                    mapToProject path commandLineArgs p2pRefs compileItems nuGetRefs sdkInfo props customProps analyzers allProperties allItems
+
                 Ok(LoadedProjectInfo.StandardProjectInfo proj)
         | LoadedProject.Other p -> Ok(LoadedProjectInfo.OtherProjectInfo p)
 

src/Ionide.ProjInfo/Types.fs

@@ -50,6 +50,15 @@ module Types =
 
     type ProjectItem = Compile of name: string * fullpath: string * metadata: Map<string, string> option
 
+    type Analyzer = {
+        /// The name of the Property from the Project like "PkgIonide_Analyzers"
+        PropertyName: string
+        /// The Path to the nuget root folder for this package, like "C:\Users\username\.nuget\packages\ionide.analyzers\0.14.7"
+        NugetPackageRoot: string
+        /// The Path that contains the actual analyzer DLLs, like "C:\Users\username\.nuget\packages\ionide.analyzers\0.14.7\analyzers\dotnet\fs"
+        DllRootPath: string
+    }
+
     type ProjectOptions = {
         ProjectId: string option
         ProjectFileName: string
@@ -68,6 +77,13 @@ module Types =
         Items: ProjectItem list
         Properties: Property list
         CustomProperties: Property list
+        /// This contains all Project Properties seen during evaluation
+        AllProperties: Map<string, Set<string>>
+        /// This contains all Project Items seen during evaluation with their values and associated metadata
+        AllItems: Map<string, Set<string * Map<string, string>>>
+        /// Will have Key Value pairs like "PkgIonide_Analyzers" -> "C:\Users\username\.nuget\packages\ionide.analyzers\0.14.7"
+        /// The "analyzers/dotnet/fs" subfolder is not included here, just the package root
+        Analyzers: Analyzer list
     } with
 
         /// ResolvedTargetPath is the path to the primary reference assembly for this project.

test/Ionide.ProjInfo.Tests/TestAssets.fs

@@ -366,3 +366,13 @@ let ``sample 14 slnx solution`` = {
     TargetFrameworks = Map.empty
     ProjectReferences = []
 }
+
+
+/// A test with f# analyzers
+let ``sample 15 nuget analyzers`` = {
+    ProjDir = "sample15-nuget-analyzers"
+    AssemblyName = ""
+    ProjectFile = "sample15-nuget-analyzers.fsproj"
+    TargetFrameworks = Map.empty
+    ProjectReferences = []
+}

test/Ionide.ProjInfo.Tests/Tests.fs

@@ -1506,6 +1506,9 @@ let testFCSmapManyProjCheckCaching =
                 Items = []
                 Properties = []
                 CustomProperties = []
+                Analyzers = []
+                AllProperties = Map.empty
+                AllItems = Map.empty
             }
 
             let makeReference (options: ProjectOptions) = {
@@ -2353,6 +2356,48 @@ let sample14SlnxFileTest toolsPath loaderType workspaceFactory =
             | _ -> failtestf "Expected a project, but got %A" expectedProject.Kind
         )
 
+let sample15NugetAnalyzers toolsPath loaderType workspaceFactory =
+    testCase
+    |> withLog
+        $"Can load sample15 with nuget analyzers - {loaderType}"
+        (fun log fs ->
+
+            let projPath = pathForProject ``sample 15 nuget analyzers``
+            let projDir = Path.GetDirectoryName projPath
+
+            // need to build the projects first so that there's something to latch on to
+            dotnet fs [
+                "restore"
+                projPath
+            ]
+            |> checkExitCodeZero
+
+            let loader: IWorkspaceLoader = workspaceFactory toolsPath
+
+            let parsed =
+                loader.LoadProjects [ projPath ]
+                |> Seq.toList
+
+            Expect.hasLength parsed 1 "Should have loaded the F# lib"
+
+            let fsharpProject = parsed[0]
+
+            let analyzerDlls = fsharpProject.Analyzers
+
+            Expect.isSome
+                (analyzerDlls
+                 |> List.tryFind (fun a -> a.PropertyName = "PkgG-Research_FSharp_Analyzers"))
+                "Should have found the PkgG-Research_FSharp_Analyzers key in the analyzers list"
+
+            Expect.isSome
+                (analyzerDlls
+                 |> List.tryFind (fun a -> a.PropertyName = "PkgIonide_Analyzers"))
+                "Should have found the PkgIonide_Analyzers key in the analyzers list"
+
+
+        )
+
+
 let tests toolsPath =
     let testSample3WorkspaceLoaderExpected = [
         ExpectNotification.loading "c1.fsproj"
@@ -2491,4 +2536,7 @@ let tests toolsPath =
 
         sample14SlnxFileTest toolsPath (nameof (WorkspaceLoader)) WorkspaceLoader.Create
         sample14SlnxFileTest toolsPath (nameof (WorkspaceLoaderViaProjectGraph)) WorkspaceLoaderViaProjectGraph.Create
+
+        sample15NugetAnalyzers toolsPath (nameof (WorkspaceLoader)) WorkspaceLoader.Create
+        sample15NugetAnalyzers toolsPath (nameof (WorkspaceLoaderViaProjectGraph)) WorkspaceLoaderViaProjectGraph.Create
     ]

test/examples/sample15-nuget-analyzers/Library.fs

@@ -0,0 +1,5 @@
+namespace sample14_nuget_analyzers
+
+module Say =
+    let hello name =
+        printfn "Hello %s" name

test/examples/sample15-nuget-analyzers/sample15-nuget-analyzers.fsproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>sample14_nuget_analyzers</RootNamespace>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Library.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="G-Research.FSharp.Analyzers" Version="0.18.0">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Ionide.Analyzers" Version="0.14.7">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>