Fix Vsix Microsoft.Bcl.AsyncInterfaces version conflict with VS 17.x

VS 17.14 ships Microsoft.Bcl.AsyncInterfaces 9.0.0.0 and devenv.exe.config
binding-redirects 0-9.0.0.0 to that version. Anything in the Vsix that
references >9.0.0.0 falls outside the redirect, so devenv loads a second copy
from the extension folder, producing duplicate IAsyncDisposable type identities
and silent runtime failures.

CodeConverter was transitively pulling in Microsoft.Bcl.AsyncInterfaces 10.0.0.0
via System.Linq.AsyncEnumerable (which only ships as a 10.x package) and
System.Text.Json 10.0.0. Drop those package references from CodeConverter and
hand-roll the small subset of System.Linq.AsyncEnumerable we actually used
(ToArraySafeAsync, AsAsyncEnumerable, SelectSafe). The helpers are deliberately
renamed so they do not clash with .NET 10's BCL System.Linq.AsyncEnumerable
extension methods when referenced by a multi-targeted consumer.

System.Linq.AsyncEnumerable is added directly to CodeConv.csproj instead - the
CLI tool never loads into devenv.exe so the binding-redirect ceiling does not
apply there.

Add VsixAssemblyCompatibilityTests that statically walks the Vsix output via
PEReader and asserts every referenced version of a known VS-owned polyfill
(currently Microsoft.Bcl.AsyncInterfaces) is satisfiable by the version the
oldest supported VS ships. The test reproduces the original bug and now passes.

Author: claude

CodeConv/CodeConv.csproj

@@ -31,6 +31,15 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.2" />
+    <!--
+      System.Linq.AsyncEnumerable only ships as a 10.x package, so it transitively pulls in
+      Microsoft.Bcl.AsyncInterfaces 10.0.0.0. That's fine here because the CodeConv CLI never
+      loads into devenv.exe (unlike the Vsix), so the VS-shipped binding redirect ceiling on
+      Microsoft.Bcl.AsyncInterfaces does not apply. The CodeConverter library itself avoids
+      depending on this package precisely so the Vsix output stays compatible with VS 17.x.
+      See VsixAssemblyCompatibilityTests.
+    -->
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0" />
     <PackageReference Include="Microsoft.Build.Tasks.Core" Version="17.8.43" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.14.0" />
     <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic.Workspaces" Version="4.14.0" />

CodeConverter/CSharp/HandledEventsAnalyzer.cs

@@ -37,8 +37,10 @@ private async Task<HandledEventsAnalysis> AnalyzeAsync()
 #pragma warning restore RS1024 // Compare symbols correctly
 
 
-        var writtenWithEventsProperties = await ancestorPropsMembersByName.Values.OfType<IPropertySymbol>().ToAsyncEnumerable()
-            .ToDictionaryAsync(async (p, _) => p.Name, async (p, cancellationToken) => (p, await IsNeverWrittenOrOverriddenAsync(p, cancellationToken)));
+        var writtenWithEventsProperties = new Dictionary<string, (IPropertySymbol p, bool)>();
+        foreach (var prop in ancestorPropsMembersByName.Values.OfType<IPropertySymbol>()) {
+            writtenWithEventsProperties[prop.Name] = (prop, await IsNeverWrittenOrOverriddenAsync(prop));
+        }
 
         var eventContainerToMethods = _type.GetMembers().OfType<IMethodSymbol>()
             .SelectMany(HandledEvents)

CodeConverter/CSharp/ProjectMergedDeclarationExtensions.cs

@@ -63,7 +63,7 @@ public static async Task<Project> WithRenamedMergedMyNamespaceAsync(this Project
         var projectDir = Path.Combine(vbProject.GetDirectoryPath(), "My Project");
 
         var compilation = await vbProject.GetCompilationAsync(cancellationToken);
-        var embeddedSourceTexts = await GetAllEmbeddedSourceTextAsync(compilation).Select((r, i) => (Text: r, Suffix: $".Static.{i+1}")).ToArrayAsync(cancellationToken);
+        var embeddedSourceTexts = await GetAllEmbeddedSourceTextAsync(compilation).SelectSafe((r, i) => (Text: r, Suffix: $".Static.{i+1}")).ToArraySafeAsync(cancellationToken);
         var generatedSourceTexts = (Text: await GetDynamicallyGeneratedSourceTextAsync(compilation), Suffix: ".Dynamic").Yield();
 
         foreach (var (text, suffix) in embeddedSourceTexts.Concat(generatedSourceTexts)) {

CodeConverter/CodeConverter.csproj

@@ -54,9 +54,6 @@
     <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
     <PackageReference Include="System.Globalization.Extensions" Version="4.3.0" />
     <PackageReference Include="System.IO.Abstractions" Version="13.2.33" />
-    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0" />
-    <PackageReference Include="System.Text.Encodings.Web" Version="10.0.0" />
-    <PackageReference Include="System.Text.Json" Version="10.0.0" />
     <PackageReference Include="System.Threading.Tasks.Dataflow" Version="5.0.0">
       <IncludeAssets>all</IncludeAssets>
     </PackageReference>

CodeConverter/Common/AsyncEnumerableTaskExtensions.cs

@@ -92,4 +92,68 @@ public static async Task<TResult[]> SelectAsync<TArg, TResult>(this IEnumerable<
 
         return partitionResults.ToArray();
     }
+
+    /// <summary>
+    /// Hand-rolled to avoid depending on <c>System.Linq.AsyncEnumerable</c>, which only ships as a 10.x
+    /// package and so transitively forces Microsoft.Bcl.AsyncInterfaces 10.0.0.0 into the Vsix output —
+    /// a version Visual Studio 17.x cannot bind to. See <c>VsixAssemblyCompatibilityTests</c>.
+    /// </summary>
+    /// <remarks>
+    /// Deliberately not named <c>ToArrayAsync</c> so it does not clash with
+    /// <see cref="System.Linq.AsyncEnumerable"/>.<c>ToArrayAsync</c> on .NET 10+ when this assembly is
+    /// referenced by a project whose target framework provides the BCL version.
+    /// </remarks>
+    public static async Task<TSource[]> ToArraySafeAsync<TSource>(this IAsyncEnumerable<TSource> source,
+        CancellationToken cancellationToken = default)
+    {
+        var list = new List<TSource>();
+        await foreach (var item in source.WithCancellation(cancellationToken)) {
+            list.Add(item);
+        }
+        return list.ToArray();
+    }
+
+    /// <summary>
+    /// Adapts a synchronous sequence to <see cref="IAsyncEnumerable{T}"/>. Hand-rolled for the same
+    /// reason as <see cref="ToArraySafeAsync{TSource}"/>, and likewise renamed to avoid clashing with
+    /// <see cref="System.Linq.AsyncEnumerable"/>.<c>ToAsyncEnumerable</c> on .NET 10+.
+    /// </summary>
+#pragma warning disable 1998 // async method without await; required for the iterator to compile to IAsyncEnumerable.
+#pragma warning disable VSTHRD200 // The method returns IAsyncEnumerable, not a Task; "Async" suffix would be misleading.
+    public static async IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this IEnumerable<TSource> source)
+    {
+        foreach (var item in source) {
+            yield return item;
+        }
+    }
+#pragma warning restore 1998
+
+    /// <summary>
+    /// Lazy projection over an <see cref="IAsyncEnumerable{T}"/>. Hand-rolled for the same reason
+    /// as <see cref="ToArraySafeAsync{TSource}"/>, and renamed to avoid clashing with
+    /// <see cref="System.Linq.AsyncEnumerable"/>.<c>Select</c> on .NET 10+.
+    /// </summary>
+    public static async IAsyncEnumerable<TResult> SelectSafe<TSource, TResult>(this IAsyncEnumerable<TSource> source,
+        Func<TSource, TResult> selector,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        await foreach (var item in source.WithCancellation(cancellationToken)) {
+            yield return selector(item);
+        }
+    }
+
+    /// <summary>
+    /// Lazy projection (with index) over an <see cref="IAsyncEnumerable{T}"/>. Hand-rolled for the same
+    /// reason as <see cref="ToArraySafeAsync{TSource}"/>.
+    /// </summary>
+    public static async IAsyncEnumerable<TResult> SelectSafe<TSource, TResult>(this IAsyncEnumerable<TSource> source,
+        Func<TSource, int, TResult> selector,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        var index = 0;
+        await foreach (var item in source.WithCancellation(cancellationToken)) {
+            yield return selector(item, index++);
+        }
+    }
+#pragma warning restore VSTHRD200
 }

CodeConverter/Common/ProjectConversion.cs

@@ -50,7 +50,7 @@ private ProjectConversion(IProjectContentsConverter projectContentsConverter, IE
         if (conversionOptions.SelectedTextSpan is { Length: > 0 } span) {
             document = await WithAnnotatedSelectionAsync(document, span);
         }
-        var conversionResults = await ConvertDocumentsAsync<TLanguageConversion>(new[] {document}, conversionOptions, progress, cancellationToken).ToArrayAsync(cancellationToken);
+        var conversionResults = await ConvertDocumentsAsync<TLanguageConversion>(new[] {document}, conversionOptions, progress, cancellationToken).ToArraySafeAsync(cancellationToken);
         var codeResult = conversionResults.First(r => r.SourcePathOrNull == document.FilePath);
         codeResult.Exceptions = conversionResults.SelectMany(x => x.Exceptions).ToArray();
         return codeResult;
@@ -183,7 +183,7 @@ private async IAsyncEnumerable<ConversionResult> ConvertAsync(IProgress<Conversi
     {
         var phaseProgress = StartPhase(progress, "Phase 1 of 2:");
         var firstPassResults = _documentsToConvert.ParallelSelectAwaitAsync(d => FirstPassLoggedAsync(d, phaseProgress), Env.MaxDop, _cancellationToken);
-        var (proj1, docs1) = await _projectContentsConverter.GetConvertedProjectAsync(await firstPassResults.ToArrayAsync(_cancellationToken));
+        var (proj1, docs1) = await _projectContentsConverter.GetConvertedProjectAsync(await firstPassResults.ToArraySafeAsync(_cancellationToken));
 
         var warnings = await GetProjectWarningsAsync(_projectContentsConverter.SourceProject, proj1);
         if (!string.IsNullOrWhiteSpace(warnings)) {
@@ -193,7 +193,7 @@ private async IAsyncEnumerable<ConversionResult> ConvertAsync(IProgress<Conversi
 
         phaseProgress = StartPhase(progress, "Phase 2 of 2:");
         var secondPassResults = proj1.GetDocuments(docs1).ParallelSelectAwaitAsync(d => SecondPassLoggedAsync(d, phaseProgress), Env.MaxDop, _cancellationToken);
-        await foreach (var result in secondPassResults.Select(CreateConversionResult).WithCancellation(_cancellationToken)) {
+        await foreach (var result in secondPassResults.SelectSafe(CreateConversionResult).WithCancellation(_cancellationToken)) {
             yield return result;
         }
         await foreach (var result in _projectContentsConverter.GetAdditionalConversionResultsAsync(_additionalDocumentsToConvert, _cancellationToken)) {

CodeConverter/Common/SolutionConverter.cs

@@ -71,17 +71,20 @@ private SolutionConverter(string solutionFilePath,
     public async IAsyncEnumerable<ConversionResult> ConvertAsync()
     {
         var projectsToUpdateReferencesOnly = _projectsToConvert.First().Solution.Projects.Except(_projectsToConvert);
-        var solutionResult = string.IsNullOrWhiteSpace(_sourceSolutionContents) ? Enumerable.Empty<ConversionResult>() : ConvertSolutionFile().Yield();
-        var convertedProjects = await ConvertProjectsAsync();
-        var projectsAndSolutionResults = UpdateProjectReferences(projectsToUpdateReferencesOnly).Concat(solutionResult).ToAsyncEnumerable();
-        await foreach (var p in convertedProjects.Concat(projectsAndSolutionResults)) {
-            yield return p;
+
+        foreach (var project in _projectsToConvert) {
+            await foreach (var result in ConvertProjectAsync(project).WithCancellation(_cancellationToken)) {
+                yield return result;
+            }
         }
-    }
 
-    private async Task<IAsyncEnumerable<ConversionResult>> ConvertProjectsAsync()
-    {
-        return _projectsToConvert.ToAsyncEnumerable().SelectMany(ConvertProjectAsync);
+        foreach (var result in UpdateProjectReferences(projectsToUpdateReferencesOnly)) {
+            yield return result;
+        }
+
+        if (!string.IsNullOrWhiteSpace(_sourceSolutionContents)) {
+            yield return ConvertSolutionFile();
+        }
     }
 
     private IAsyncEnumerable<ConversionResult> ConvertProjectAsync(Project project)

Tests/Tests.csproj

@@ -41,4 +41,13 @@
   <ItemGroup>
     <ProjectReference Include="..\CodeConv\CodeConv.csproj" />
   </ItemGroup>
+  <!--
+    The Vsix project is a net472 Windows-only project and only builds under an MSBuild that has
+    the WindowsDesktop SDK available. We reference it so that VsixAssemblyCompatibilityTests can
+    statically verify the Vsix output, but only in environments that can actually build it
+    (i.e. Windows). Elsewhere the tests that depend on Vsix output will skip.
+  -->
+  <ItemGroup Condition="'$(OS)' == 'Windows_NT'">
+    <ProjectReference Include="..\Vsix\Vsix.csproj" ReferenceOutputAssembly="false" SkipGetTargetFrameworkProperties="true" PrivateAssets="all" />
+  </ItemGroup>
 </Project>