C#: csproj parsing and core dependency recipes (#7013)

* C#: csproj parsing and core dependency recipes

* UpgradeNuGetPackageVersion: semver selectors, NuGet source discovery, and test improvements

- Support semver version selectors (latest.release, ~, ^, etc.) via
  NuGetVersionResolver which queries NuGet V3 flat container APIs
- Discover package sources from nuget.config files during csproj parsing
  (C# RPC side walks up from project dir to repo root)
- Surface package sources through MSBuildProject marker and ParseSolutionResult
- Handle property-based version references that resolve across files
  (e.g. Directory.Build.props defining version properties)
- Convert CSharpParseProjectTest to use rewriteRun with csharp()/csproj()
  assertions instead of manual RPC calls where possible
- Add comprehensive test coverage: glob patterns, version ranges, floating
  versions, central package management, conditional refs, child elements

Author: jkschneider

rewrite-csharp/csharp/OpenRewrite/CSharp/Rpc/RewriteRpcServer.cs

@@ -181,7 +181,7 @@ public RewriteRpcServer(RecipeMarketplace marketplace)
     }
 
     [JsonRpcMethod("ParseSolution", UseSingleObjectParameterDeserialization = true)]
-    public async Task<List<ParseSolutionResponseItem>> ParseSolution(ParseSolutionRequest request)
+    public async Task<ParseSolutionResponse> ParseSolution(ParseSolutionRequest request)
     {
         Log.Debug("RPC ParseSolution: received request path={Path} rootDir={RootDir}", request.Path, request.RootDir);
         var solutionParser = new SolutionParser();
@@ -190,7 +190,7 @@ public async Task<List<ParseSolutionResponseItem>> ParseSolution(ParseSolutionRe
 
         var solution = await solutionParser.LoadAsync(path, CancellationToken.None);
 
-        var items = new List<ParseSolutionResponseItem>();
+        var response = new ParseSolutionResponse();
         var seenProjects = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
         var projectList = solution.Projects.Where(p => p.FilePath != null).ToList();
         Log.Debug("RPC ParseSolution: {ProjectCount} projects to parse", projectList.Count);
@@ -221,17 +221,299 @@ public async Task<List<ParseSolutionResponseItem>> ParseSolution(ParseSolutionRe
             {
                 var id = cu.Id.ToString();
                 _localObjects[id] = cu;
-                items.Add(new ParseSolutionResponseItem
+                response.Items.Add(new ParseSolutionResponseItem
                 {
                     Id = id,
                     SourceFileType = "org.openrewrite.csharp.tree.Cs$CompilationUnit",
                     ProjectPath = project.FilePath!
                 });
             }
+
+            // Extract MSBuild project metadata from .csproj
+            try
+            {
+                var metadata = ExtractProjectMetadata(project.FilePath!, rootDir);
+                response.Projects.Add(metadata);
+            }
+            catch (Exception ex)
+            {
+                Log.Debug("RPC ParseSolution: failed to extract metadata for {ProjectPath}: {ExType}: {ExMessage}",
+                    project.FilePath, ex.GetType().Name, ex.Message);
+            }
+        }
+
+        Log.Debug("RPC ParseSolution: completed, {ItemCount} compilation units, {ProjectCount} project metadata",
+            response.Items.Count, response.Projects.Count);
+        return response;
+    }
+
+    /// <summary>
+    /// Extracts MSBuild project metadata from a .csproj file by parsing its XML
+    /// and reading the resolved dependency tree from project.assets.json.
+    /// </summary>
+    private static ProjectMetadata ExtractProjectMetadata(string projectPath, string rootDir)
+    {
+        var doc = XDocument.Load(projectPath);
+        var root = doc.Root!;
+        var ns = root.Name.Namespace;
+
+        var relativePath = Path.GetRelativePath(rootDir, projectPath);
+
+        var metadata = new ProjectMetadata
+        {
+            ProjectPath = relativePath,
+            Sdk = root.Attribute("Sdk")?.Value
+        };
+
+        // Extract TargetFramework(s)
+        var tfmElement = root.Descendants(ns + "TargetFramework").FirstOrDefault();
+        var tfmsElement = root.Descendants(ns + "TargetFrameworks").FirstOrDefault();
+
+        var frameworks = new List<string>();
+        if (tfmsElement != null)
+        {
+            foreach (var tfm in tfmsElement.Value.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+                frameworks.Add(tfm);
+        }
+        else if (tfmElement != null)
+        {
+            frameworks.Add(tfmElement.Value.Trim());
+        }
+
+        // Extract PackageReferences
+        var packageRefs = root.Descendants(ns + "PackageReference")
+            .Select(e => new PackageReferenceEntry
+            {
+                Include = e.Attribute("Include")?.Value ?? "",
+                RequestedVersion = e.Attribute("Version")?.Value,
+                ResolvedVersion = e.Attribute("Version")?.Value // raw = resolved in XML context
+            })
+            .Where(r => !string.IsNullOrEmpty(r.Include))
+            .ToList();
+
+        // Extract ProjectReferences
+        var projectRefs = root.Descendants(ns + "ProjectReference")
+            .Select(e => new ProjectReferenceEntry
+            {
+                Include = e.Attribute("Include")?.Value ?? ""
+            })
+            .Where(r => !string.IsNullOrEmpty(r.Include))
+            .ToList();
+
+        // Read resolved packages from project.assets.json
+        var assetsPath = Path.Combine(Path.GetDirectoryName(projectPath)!, "obj", "project.assets.json");
+        var resolvedByTfm = new Dictionary<string, List<ResolvedPackageEntry>>();
+        if (File.Exists(assetsPath))
+        {
+            try
+            {
+                resolvedByTfm = ReadResolvedPackages(assetsPath);
+            }
+            catch (Exception ex)
+            {
+                Log.Debug("Failed to read project.assets.json at {Path}: {Ex}", assetsPath, ex.Message);
+            }
+        }
+
+        // Extract properties with provenance
+        foreach (var propGroup in root.Descendants(ns + "PropertyGroup"))
+        {
+            foreach (var prop in propGroup.Elements())
+            {
+                var propName = prop.Name.LocalName;
+                if (!metadata.Properties.ContainsKey(propName))
+                {
+                    metadata.Properties[propName] = new PropertyEntry
+                    {
+                        Value = prop.Value,
+                        DefinedIn = relativePath
+                    };
+                }
+            }
         }
 
-        Log.Debug("RPC ParseSolution: completed, {ItemCount} compilation units total", items.Count);
-        return items;
+        // Discover NuGet package sources from nuget.config files
+        metadata.PackageSources = FindNuGetPackageSources(projectPath, rootDir);
+
+        // Build per-TFM metadata
+        foreach (var tfm in frameworks)
+        {
+            resolvedByTfm.TryGetValue(tfm, out var resolved);
+            metadata.TargetFrameworks.Add(new TargetFrameworkEntry
+            {
+                TargetFramework = tfm,
+                PackageReferences = packageRefs,
+                ResolvedPackages = resolved ?? new List<ResolvedPackageEntry>(),
+                ProjectReferences = projectRefs
+            });
+        }
+
+        // If no frameworks found, still include a default entry
+        if (frameworks.Count == 0)
+        {
+            metadata.TargetFrameworks.Add(new TargetFrameworkEntry
+            {
+                PackageReferences = packageRefs,
+                ProjectReferences = projectRefs
+            });
+        }
+
+        return metadata;
+    }
+
+    /// <summary>
+    /// Discovers NuGet package sources by walking up from the project directory
+    /// to the repository root looking for nuget.config files.
+    /// NuGet resolves sources hierarchically — closest config wins.
+    /// </summary>
+    private static List<PackageSourceEntry> FindNuGetPackageSources(string projectPath, string rootDir)
+    {
+        var sources = new List<PackageSourceEntry>();
+        var dir = Path.GetDirectoryName(projectPath);
+
+        while (dir != null && dir.StartsWith(rootDir, StringComparison.OrdinalIgnoreCase))
+        {
+            var configPath = Path.Combine(dir, "nuget.config");
+            // Case-insensitive check (NuGet.Config, nuget.config, NuGet.config all valid)
+            if (!File.Exists(configPath))
+            {
+                configPath = Path.Combine(dir, "NuGet.Config");
+                if (!File.Exists(configPath))
+                {
+                    configPath = Path.Combine(dir, "NuGet.config");
+                }
+            }
+
+            if (File.Exists(configPath))
+            {
+                try
+                {
+                    var configDoc = XDocument.Load(configPath);
+                    var packageSources = configDoc.Root?
+                        .Element("packageSources")?
+                        .Elements("add");
+
+                    if (packageSources != null)
+                    {
+                        foreach (var source in packageSources)
+                        {
+                            var key = source.Attribute("key")?.Value;
+                            var url = source.Attribute("value")?.Value;
+                            if (key != null && url != null &&
+                                !sources.Any(s => s.Key == key))
+                            {
+                                sources.Add(new PackageSourceEntry
+                                {
+                                    Key = key,
+                                    Url = url
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Log.Debug("Failed to parse nuget.config at {Path}: {Ex}", configPath, ex.Message);
+                }
+                // NuGet uses the closest config — stop walking up once we find one
+                break;
+            }
+
+            if (dir == rootDir) break;
+            dir = Path.GetDirectoryName(dir);
+        }
+
+        // Default to nuget.org if no sources found
+        if (sources.Count == 0)
+        {
+            sources.Add(new PackageSourceEntry
+            {
+                Key = "nuget.org",
+                Url = "https://api.nuget.org/v3/index.json"
+            });
+        }
+
+        return sources;
+    }
+
+    /// <summary>
+    /// Reads the resolved dependency tree from project.assets.json.
+    /// Returns a dictionary keyed by target framework moniker.
+    /// </summary>
+    private static Dictionary<string, List<ResolvedPackageEntry>> ReadResolvedPackages(string assetsPath)
+    {
+        var result = new Dictionary<string, List<ResolvedPackageEntry>>();
+        var json = JObject.Parse(File.ReadAllText(assetsPath));
+        var targets = json["targets"] as JObject;
+        if (targets == null) return result;
+
+        foreach (var (tfmKey, tfmValue) in targets)
+        {
+            // tfmKey is like "net8.0" or ".NETCoreApp,Version=v8.0"
+            var tfm = tfmKey.Contains(',')
+                ? NormalizeTfm(tfmKey)
+                : tfmKey;
+
+            var packages = new List<ResolvedPackageEntry>();
+            if (tfmValue is JObject tfmObj)
+            {
+                foreach (var (pkgKey, pkgValue) in tfmObj)
+                {
+                    // pkgKey is "PackageName/Version"
+                    var parts = pkgKey.Split('/', 2);
+                    if (parts.Length != 2) continue;
+
+                    var type = pkgValue?["type"]?.Value<string>();
+                    if (type != "package") continue;
+
+                    var deps = new List<ResolvedPackageEntry>();
+                    var dependencies = pkgValue?["dependencies"] as JObject;
+                    if (dependencies != null)
+                    {
+                        foreach (var (depName, depVersion) in dependencies)
+                        {
+                            deps.Add(new ResolvedPackageEntry
+                            {
+                                Name = depName,
+                                ResolvedVersion = depVersion?.Value<string>() ?? "",
+                                Depth = 1
+                            });
+                        }
+                    }
+
+                    packages.Add(new ResolvedPackageEntry
+                    {
+                        Name = parts[0],
+                        ResolvedVersion = parts[1],
+                        Dependencies = deps,
+                        Depth = 0
+                    });
+                }
+            }
+
+            result[tfm] = packages;
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Normalizes a full framework identifier like ".NETCoreApp,Version=v8.0" to "net8.0".
+    /// </summary>
+    private static string NormalizeTfm(string fullTfm)
+    {
+        // Simple heuristic: extract the version part
+        if (fullTfm.StartsWith(".NETCoreApp,Version=v") || fullTfm.StartsWith(".NETCoreApp,Version=V"))
+        {
+            var version = fullTfm.Substring(".NETCoreApp,Version=v".Length);
+            return "net" + version;
+        }
+        if (fullTfm.StartsWith(".NETStandard,Version=v") || fullTfm.StartsWith(".NETStandard,Version=V"))
+        {
+            var version = fullTfm.Substring(".NETStandard,Version=v".Length);
+            return "netstandard" + version;
+        }
+        return fullTfm;
     }
 
     /// <summary>
@@ -1284,13 +1566,68 @@ public class ParseSolutionRequest
     public string RootDir { get; set; } = "";
 }
 
+public class ParseSolutionResponse
+{
+    public List<ParseSolutionResponseItem> Items { get; set; } = new();
+    public List<ProjectMetadata> Projects { get; set; } = new();
+}
+
 public class ParseSolutionResponseItem
 {
     public string Id { get; set; } = "";
     public string SourceFileType { get; set; } = "";
     public string ProjectPath { get; set; } = "";
 }
 
+public class ProjectMetadata
+{
+    public string ProjectPath { get; set; } = "";
+    public string? Sdk { get; set; }
+    public Dictionary<string, PropertyEntry> Properties { get; set; } = new();
+    public List<TargetFrameworkEntry> TargetFrameworks { get; set; } = new();
+    public List<PackageSourceEntry> PackageSources { get; set; } = new();
+}
+
+public class PackageSourceEntry
+{
+    public string Key { get; set; } = "";
+    public string Url { get; set; } = "";
+}
+
+public class PropertyEntry
+{
+    public string Value { get; set; } = "";
+    public string? DefinedIn { get; set; }
+}
+
+public class TargetFrameworkEntry
+{
+    public string TargetFramework { get; set; } = "";
+    public List<PackageReferenceEntry> PackageReferences { get; set; } = new();
+    public List<ResolvedPackageEntry> ResolvedPackages { get; set; } = new();
+    public List<ProjectReferenceEntry> ProjectReferences { get; set; } = new();
+}
+
+public class PackageReferenceEntry
+{
+    public string Include { get; set; } = "";
+    public string? RequestedVersion { get; set; }
+    public string? ResolvedVersion { get; set; }
+}
+
+public class ResolvedPackageEntry
+{
+    public string Name { get; set; } = "";
+    public string ResolvedVersion { get; set; } = "";
+    public List<ResolvedPackageEntry> Dependencies { get; set; } = new();
+    public int Depth { get; set; }
+}
+
+public class ProjectReferenceEntry
+{
+    public string Include { get; set; } = "";
+}
+
 public class GetObjectRequest
 {
     public string Id { get; set; } = "";