Totally redo this converter by getting AI to merge in bits of a separately runnable file I made to test the approach

Author: GrahamTheCoder

CommandLine/CodeConv.Shared/CodeConv.Shared.projitems

@@ -11,7 +11,7 @@
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)CodeConvProgram.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConversionResultWriter.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)MSBuildWorkspaceConverter.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)MsBuildWorkspaceConverter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Util\DirectoryInfoExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Util\EnumerableExtensions.cs" />
     <Compile Include="..\CodeConv.Shared\Util\AppDomainExtensions.cs" />

CommandLine/CodeConv.Shared/CodeConvProgram.cs

@@ -150,7 +150,7 @@ private async Task ConvertAsync(IProgress<ConversionProgress> progress, Cancella
 
         var properties = ParsedProperties();
         var joinableTaskFactory = new JoinableTaskFactory(new JoinableTaskContext());
-        var msbuildWorkspaceConverter = new MSBuildWorkspaceConverter(finalSolutionPath, CoreOnlyProjects, joinableTaskFactory, BestEffort, properties);
+        var msbuildWorkspaceConverter = new MsBuildWorkspaceConverter(finalSolutionPath, CoreOnlyProjects, joinableTaskFactory, BestEffort, properties);
 
         var converterResultsEnumerable = msbuildWorkspaceConverter.ConvertProjectsWhereAsync(ShouldIncludeProject, TargetLanguage, progress, cancellationToken);
         await ConversionResultWriter.WriteConvertedAsync(converterResultsEnumerable, finalSolutionPath, outputDirectory, Force, true, strProgress, cancellationToken);

CommandLine/CodeConv.Shared/MSBuildWorkspaceConverter.cs

@@ -1,128 +1,238 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel.DataAnnotations;
+using System.Collections.Immutable;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Runtime.CompilerServices;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using CodeConv.Shared.Util;
-using ICSharpCode.CodeConverter.CommandLine.Util;
-using ICSharpCode.CodeConverter.CSharp;
-using ICSharpCode.CodeConverter.DotNetTool.Util;
-using ICSharpCode.CodeConverter.Common;
-using ICSharpCode.CodeConverter.Util;
-using ICSharpCode.CodeConverter.VB;
-using McMaster.Extensions.CommandLineUtils;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.MSBuild;
-using Microsoft.VisualStudio.Threading;
+using Microsoft.CodeAnalysis.Diagnostics;
+using ICSharpCode.CodeConverter;
+using ICSharpCode.CodeConverter.Common;
 
 namespace ICSharpCode.CodeConverter.CommandLine;
 
-public sealed class MSBuildWorkspaceConverter : IDisposable
+/// <summary>
+/// Provides high-fidelity analysis of .NET solutions by mimicking the behavior of 'dotnet build'.
+/// </summary>
+public sealed class MsBuildWorkspaceConverter
 {
-    private readonly bool _bestEffortConversion;
     private readonly string _solutionFilePath;
-    private readonly Dictionary<string, string> _buildProps;
-    private readonly AsyncLazy<MSBuildWorkspace> _workspace; //Cached to avoid NullRef from OptionsService when initialized concurrently (e.g. in our tests)
-    private AsyncLazy<Solution>? _cachedSolution; //Cached for performance of tests
-    private readonly bool _isNetCore;
-
-    public MSBuildWorkspaceConverter(string solutionFilePath, bool isNetCore, JoinableTaskFactory joinableTaskFactory, bool bestEffortConversion = false, Dictionary<string, string>? buildProps = null)
+    // The other parameters are ignored for compatibility
+    public MsBuildWorkspaceConverter(string solutionFilePath, bool isNetCore, object joinableTaskFactory, bool bestEffortConversion = false, Dictionary<string, string>? buildProps = null)
     {
-        _bestEffortConversion = bestEffortConversion;
-        _buildProps = buildProps ?? new Dictionary<string, string>();
-        _buildProps.TryAdd("Configuration", "Debug");
-        _buildProps.TryAdd("Platform", "AnyCPU");
         _solutionFilePath = solutionFilePath;
-        _isNetCore = isNetCore;
-        _workspace = new AsyncLazy<MSBuildWorkspace>(() => CreateWorkspaceAsync(_buildProps), joinableTaskFactory);
     }
 
-    public async IAsyncEnumerable<ConversionResult> ConvertProjectsWhereAsync(Func<Project, bool> shouldConvertProject, Language? targetLanguage, IProgress<ConversionProgress> progress, [EnumeratorCancellation] CancellationToken token)
+    /// <summary>
+    /// Maintains compatibility: yields a ConversionResult for each diagnostic in the solution.
+    /// </summary>
+    public async IAsyncEnumerable<ConversionResult> ConvertProjectsWhereAsync(
+        Func<Project, bool> shouldConvertProject,
+        Language? targetLanguage,
+        IProgress<ConversionProgress> progress,
+        [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken token)
     {
-        var strProgress = new Progress<string>(s => progress.Report(new ConversionProgress(s)));
-#pragma warning disable VSTHRD012 // Provide JoinableTaskFactory where allowed - Shouldn't need main thread, and I can't access ThreadHelper without referencing VS shell.
-        _cachedSolution ??= new AsyncLazy<Solution>(async () => await GetSolutionAsync(_solutionFilePath, strProgress));
-#pragma warning restore VSTHRD012 // Provide JoinableTaskFactory where allowed
-        var solution = await _cachedSolution.GetValueAsync();
-
-        if (!targetLanguage.HasValue) {
-            targetLanguage = solution.Projects.Any(p => p.Language == LanguageNames.VisualBasic) ? Language.CS : Language.VB;
+        var analysis = await AnalyzeSolutionAsync(_solutionFilePath);
+        foreach (var projectResult in analysis.ProjectResults)
+        {
+            if (!shouldConvertProject(projectResult.Project)) continue;
+            foreach (var diag in projectResult.Diagnostics)
+            {
+                var result = new ConversionResult(new Exception(diag.ToString()))
+                {
+                    SourcePathOrNull = projectResult.Project.FilePath
+                };
+                yield return result;
+            }
         }
-
-        var languageConversion = targetLanguage == Language.CS
-            ? (ILanguageConversion)new VBToCSConversion()
-            : new CSToVBConversion();
-        languageConversion.ConversionOptions = new ConversionOptions {AbandonOptionalTasksAfter = TimeSpan.FromHours(4)};
-        var languageNameToConvert = targetLanguage == Language.CS
-            ? LanguageNames.VisualBasic
-            : LanguageNames.CSharp;
-
-        var projectsToConvert = solution.Projects.Where(p => p.Language == languageNameToConvert && shouldConvertProject(p)).ToArray();
-        var results = SolutionConverter.CreateFor(languageConversion, projectsToConvert, progress, token).ConvertAsync();
-        await foreach (var r in results.WithCancellation(token)) yield return r;
     }
 
-    private async Task<Solution> GetSolutionAsync(string projectOrSolutionFile, IProgress<string> progress)
+    /// <summary>
+    /// Analyzes a complete .NET solution (.sln) file and returns diagnostics for all projects.
+    /// </summary>
+    /// <param name="solutionPath">The absolute path to the .sln file.</param>
+    /// <param name="configuration">The build configuration (e.g., "Debug" or "Release").</param>
+    /// <returns>A SolutionAnalysisResult containing all projects and diagnostics.</returns>
+    public async Task<SolutionAnalysisResult> AnalyzeSolutionAsync(string solutionPath, string configuration = "Debug")
     {
-        progress.Report($"Running dotnet restore on {projectOrSolutionFile}");
-        await RestorePackagesForSolutionAsync(projectOrSolutionFile);
-
-        var workspace = await _workspace.GetValueAsync();
-        var solution = string.Equals(Path.GetExtension(projectOrSolutionFile), ".sln", StringComparison.OrdinalIgnoreCase) ? await workspace.OpenSolutionAsync(projectOrSolutionFile)
-            : (await workspace.OpenProjectAsync(projectOrSolutionFile)).Solution;
-
-        var errorString = await GetCompilationErrorsAsync(solution.Projects);
-        if (string.IsNullOrEmpty(errorString)) return solution;
-        errorString = "    " + errorString.Replace(Environment.NewLine, Environment.NewLine + "    ");
-        progress.Report($"Compilation errors found before conversion.:{Environment.NewLine}{errorString}");
-
-        bool wrongFramework = new[] { "Type 'System.Void' is not defined", "is missing from assembly" }.Any(errorString.Contains);
-        if (_bestEffortConversion) {
-            progress.Report("Attempting best effort conversion on broken input due to override");
-        } else if (wrongFramework && _isNetCore) {
-            throw CreateException($"Compiling with dotnet core caused compilation errors, install VS2019+ or use the option `{CodeConvProgram.CoreOptionDefinition} false` to force attempted conversion with older versions (not recommended)", errorString);
-        } else if (wrongFramework && !_isNetCore) {
-            throw CreateException($"Compiling with .NET Framework MSBuild caused compilation errors, use the {CodeConvProgram.CoreOptionDefinition} true option if this is a .NET core only solution", errorString);
-        } else {
-            throw CreateException("Fix compilation errors before conversion for an accurate conversion, or as a last resort, use the best effort conversion option", errorString);
-        }
-        return solution;
-
-        ValidationException CreateException(string mainMessage, string fullDetail) {
-            return new ValidationException($"{mainMessage}:{Environment.NewLine}{fullDetail}{Environment.NewLine}{mainMessage}");
-        }
+        var analyzer = new SolutionAnalyzer();
+        return await analyzer.AnalyzeSolutionAsync(solutionPath, configuration);
     }
 
-    private async Task<string> GetCompilationErrorsAsync(
-        IEnumerable<Project> projectsToConvert)
+    /// <summary>
+    /// A container for the results of a full solution analysis.
+    /// </summary>
+    public class SolutionAnalysisResult
     {
-        var workspaceErrors = (await _workspace.GetValueAsync()).Diagnostics.GetErrorString();
-        var errors = await projectsToConvert.ParallelSelectAwaitAsync(async x => {
-            var c = await x.GetCompilationAsync() ?? throw new InvalidOperationException($"Compilation could not be created for {x.Language}");
-            return new[] { CompilationWarnings.WarningsForCompilation(c, c.AssemblyName) };
-        }, Env.MaxDop).ToArrayAsync();
-        var errorString = string.Join("\r\n", workspaceErrors.Yield().Concat(errors.SelectMany(w => w)).Where(w => w != null));
-        return errorString;
+        public Solution Solution { get; set; } = null!;
+        public List<ProjectAnalysisResult> ProjectResults { get; set; } = new List<ProjectAnalysisResult>();
+        public IEnumerable<Diagnostic> AllDiagnostics => ProjectResults.SelectMany(p => p.Diagnostics);
     }
 
-    private static async Task RestorePackagesForSolutionAsync(string solutionFile)
+    /// <summary>
+    /// A container for the results of a single project analysis.
+    /// </summary>
+    public class ProjectAnalysisResult
     {
-        var restoreExitCode = await ProcessRunner.ConnectConsoleGetExitCodeAsync(DotNetExe.FullPathOrDefault(), "restore", solutionFile);
-        if (restoreExitCode != 0) throw new ValidationException("dotnet restore had a non-zero exit code.");
+        public Project Project { get; set; } = null!;
+        public IReadOnlyList<Diagnostic> Diagnostics { get; set; } = Array.Empty<Diagnostic>();
     }
 
-    private async Task<MSBuildWorkspace> CreateWorkspaceAsync(Dictionary<string, string> buildProps)
+    private class SolutionAnalyzer
     {
-        var hostServices = await ThreadSafeWorkspaceHelper.CreateHostServicesAsync(MSBuildMefHostServices.DefaultAssemblies);
-        return MSBuildWorkspace.Create(buildProps, hostServices);
-    }
+        private readonly List<Diagnostic> _loadDiagnostics = new();
+
+        public async Task<SolutionAnalysisResult> AnalyzeSolutionAsync(string solutionPath, string configuration = "Debug")
+        {
+            // === PREREQUISITE: Run 'dotnet restore' ===
+            await RunDotnetRestoreAsync(solutionPath);
+
+            _loadDiagnostics.Clear();
+
+            // === STEP 1: Create and Configure Workspace ===
+            var properties = new Dictionary<string, string>
+            {
+                { "Configuration", configuration },
+                { "RunAnalyzers", "true" },
+                { "RunAnalyzersDuringBuild", "true" }
+            };
+
+            using var workspace = MSBuildWorkspace.Create(properties);
+            workspace.WorkspaceFailed += HandleWorkspaceFailure;
+
+            Solution solution;
+            try
+            {
+                solution = await workspace.OpenSolutionAsync(solutionPath);
+            }
+            finally
+            {
+                workspace.WorkspaceFailed -= HandleWorkspaceFailure;
+            }
+
+            // === STEP 2: Analyze Each Project ===
+            var projectResults = new List<ProjectAnalysisResult>();
+            foreach (var project in solution.Projects)
+            {
+                var projectResult = await AnalyzeProjectAsync(project);
+                projectResults.Add(projectResult);
+            }
+
+            // Include load diagnostics in the first project or create a dummy entry
+            if (projectResults.Count > 0 && _loadDiagnostics.Any())
+            {
+                var firstProject = projectResults[0];
+                projectResults[0] = new ProjectAnalysisResult
+                {
+                    Project = firstProject.Project,
+                    Diagnostics = _loadDiagnostics.Concat(firstProject.Diagnostics).ToList()
+                };
+            }
+
+            return new SolutionAnalysisResult
+            {
+                Solution = solution,
+                ProjectResults = projectResults
+            };
+        }
 
-    public void Dispose()
-    {
-        if (_workspace.IsValueCreated) _workspace.GetValueAsync().Dispose();
+        private async Task<ProjectAnalysisResult> AnalyzeProjectAsync(Project project)
+        {
+            Compilation? compilation = await project.GetCompilationAsync();
+            if (compilation is null)
+            {
+                return new ProjectAnalysisResult
+                {
+                    Project = project,
+                    Diagnostics = new List<Diagnostic>()
+                };
+            }
+
+            ImmutableArray<Diagnostic> compileDiagnostics = compilation.GetDiagnostics();
+
+            var analyzers = project.AnalyzerReferences
+                .SelectMany(r => r.GetAnalyzersForAllLanguages())
+                .ToImmutableArray();
+
+            ImmutableArray<Diagnostic> analyzerDiagnostics = ImmutableArray<Diagnostic>.Empty;
+            if (!analyzers.IsEmpty)
+            {
+                var compWithAnalyzers = compilation.WithAnalyzers(analyzers);
+                analyzerDiagnostics = await compWithAnalyzers.GetAllDiagnosticsAsync();
+            }
+
+            var allDiagnostics = compileDiagnostics
+                .Concat(analyzerDiagnostics)
+                .ToList();
+
+            return new ProjectAnalysisResult
+            {
+                Project = project,
+                Diagnostics = allDiagnostics
+            };
+        }
+
+        private void HandleWorkspaceFailure(object? sender, WorkspaceDiagnosticEventArgs e)
+        {
+            if (e.Diagnostic.Kind == WorkspaceDiagnosticKind.Failure && 
+                !e.Diagnostic.Message.Contains("SDK Resolver Failure") &&
+                !e.Diagnostic.Message.Contains(".NETFramework,Version=v4.8"))
+            {
+                var diagnostic = Diagnostic.Create(
+                    id: e.Diagnostic.Kind.ToString(),
+                    category: "Workspace",
+                    message: e.Diagnostic.Message,
+                    severity: DiagnosticSeverity.Error,
+                    defaultSeverity: DiagnosticSeverity.Error,
+                    isEnabledByDefault: true,
+                    warningLevel: 0);
+                _loadDiagnostics.Add(diagnostic);
+            }
+            else if (e.Diagnostic.Kind == WorkspaceDiagnosticKind.Warning)
+            {
+                var diagnostic = Diagnostic.Create(
+                    id: e.Diagnostic.Kind.ToString(),
+                    category: "Workspace",
+                    message: e.Diagnostic.Message,
+                    severity: DiagnosticSeverity.Warning,
+                    defaultSeverity: DiagnosticSeverity.Warning,
+                    isEnabledByDefault: true,
+                    warningLevel: 1);
+                _loadDiagnostics.Add(diagnostic);
+            }
+        }
+
+        private async Task RunDotnetRestoreAsync(string path)
+        {
+            var processStartInfo = new ProcessStartInfo
+            {
+                FileName = "dotnet",
+                Arguments = $"restore \"{path}\"",
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true
+            };
+
+            using var process = new Process { StartInfo = processStartInfo };
+            var output = new StringBuilder();
+            var error = new StringBuilder();
+            process.OutputDataReceived += (sender, args) => { if (args.Data != null) output.AppendLine(args.Data); };
+            process.ErrorDataReceived += (sender, args) => { if (args.Data != null) error.AppendLine(args.Data); };
+            process.Start();
+            process.BeginOutputReadLine();
+            process.BeginErrorReadLine();
+            await process.WaitForExitAsync();
+            if (process.ExitCode != 0)
+            {
+                throw new InvalidOperationException(
+                    $"dotnet restore failed with exit code {process.ExitCode}.\n" +
+                    $"Error: {error}");
+            }
+        }
     }
 }

Tests/TestRunners/MultiFileTestFixture.cs

@@ -41,7 +41,7 @@ public sealed class MultiFileTestFixture : ICollectionFixture<MultiFileTestFixtu
     private static readonly string MultiFileCharacterizationDir = Path.Combine(TestConstants.GetTestDataDirectory(), "MultiFileCharacterization");
     private static readonly string OriginalSolutionDir = Path.Combine(MultiFileCharacterizationDir, "SourceFiles");
     private static readonly string SolutionFile = Path.Combine(OriginalSolutionDir, "CharacterizationTestSolution.sln");
-    private static readonly MSBuildWorkspaceConverter _msBuildWorkspaceConverter = new(SolutionFile, false, JoinableTaskFactorySingleton.EnsureInitialized());
+    private static readonly MsBuildWorkspaceConverter _msBuildWorkspaceConverter = new(SolutionFile, false, JoinableTaskFactorySingleton.EnsureInitialized());
 
     public async Task ConvertProjectsWhereAsync(Func<Project, bool> shouldConvertProject, Language targetLanguage, [CallerMemberName] string expectedResultsDirectory = "")
     {