Preserve friend assemblies across migration layouts

DavidObando · DavidObando · commit a7e4301e64e1 · 2026-07-27T22:19:49.000-07:00
Keep hand-authored InternalsVisibleTo annotations in translated source, preserve SDK-generated declarations only for diagnostic projects, and reproduce generated friend items in repository test parity projects.
diff --git a/tools/cs2gs/Cs2Gs.Pipeline/GsharpTestProjectRunner.cs b/tools/cs2gs/Cs2Gs.Pipeline/GsharpTestProjectRunner.cs
@@ -451,16 +451,27 @@ private static byte[] ComputeHash(string path)
         return sha256.ComputeHash(stream);
     }
 
-    private static string LibraryProject(GsharpTestProject project, string sdkVersion) =>
-        $"<Project Sdk=\"{SdkPackageId}/{sdkVersion}\">\n" +
-        "\n" +
-        "  <PropertyGroup>\n" +
-        "    <OutputType>Library</OutputType>\n" +
-        "    <TargetFramework>net10.0</TargetFramework>\n" +
-        $"    <RootNamespace>{project.LibraryRootNamespace}</RootNamespace>\n" +
-        "  </PropertyGroup>\n" +
-        "\n" +
-        "</Project>\n";
+    private static string LibraryProject(GsharpTestProject project, string sdkVersion)
+    {
+        string friendAssemblies = project.LibraryFriendAssemblies.Count == 0
+            ? string.Empty
+            : "\n  <ItemGroup>\n" +
+                string.Concat(project.LibraryFriendAssemblies.Select(name =>
+                    "    <InternalsVisibleTo Include=\"" +
+                    System.Security.SecurityElement.Escape(name) +
+                    "\" />\n")) +
+                "  </ItemGroup>\n";
+        return $"<Project Sdk=\"{SdkPackageId}/{sdkVersion}\">\n" +
+            "\n" +
+            "  <PropertyGroup>\n" +
+            "    <OutputType>Library</OutputType>\n" +
+            "    <TargetFramework>net10.0</TargetFramework>\n" +
+            $"    <RootNamespace>{project.LibraryRootNamespace}</RootNamespace>\n" +
+            "  </PropertyGroup>\n" +
+            friendAssemblies +
+            "\n" +
+            "</Project>\n";
+    }
 
     private static string TestsProject(GsharpTestProject project, string sdkVersion) =>
         $"<Project Sdk=\"{SdkPackageId}/{sdkVersion}\">\n" +
@@ -534,6 +545,9 @@ public sealed class GsharpTestProject
     /// <summary>Gets or sets the translated G# library source files.</summary>
     public IReadOnlyList<GsharpSourceFile> LibraryFiles { get; set; } = Array.Empty<GsharpSourceFile>();
 
+    /// <summary>Gets or sets friend assemblies declared by the source library project.</summary>
+    public IReadOnlyList<string> LibraryFriendAssemblies { get; set; } = Array.Empty<string>();
+
     /// <summary>Gets or sets the test project name (folder + assembly).</summary>
     public string TestsName { get; set; } = "Library.Tests";
 
diff --git a/tools/cs2gs/Cs2Gs.Pipeline/IMigrationStage.cs b/tools/cs2gs/Cs2Gs.Pipeline/IMigrationStage.cs
@@ -190,6 +190,13 @@ public StageExecutionContext(
     /// <summary>Gets the source project's declared ProjectReference items.</summary>
     public List<DeclaredProjectItem> ProjectReferences { get; } = new List<DeclaredProjectItem>();
 
+    /// <summary>
+    /// Gets friend assemblies contributed by generated C# sources, including
+    /// SDK-generated <c>InternalsVisibleTo</c> items.
+    /// </summary>
+    public ISet<string> GeneratedFriendAssemblies { get; } =
+        new HashSet<string>(StringComparer.Ordinal);
+
     /// <summary>
     /// Gets or sets the absolute path of the assembly emitted by the Compile
     /// stage, published for the IL-verify stage to read (ADR-0115 §C). It is
diff --git a/tools/cs2gs/Cs2Gs.Pipeline/TestParityStage.cs b/tools/cs2gs/Cs2Gs.Pipeline/TestParityStage.cs
@@ -251,6 +251,10 @@ private async Task<StageOutcome> RunLibraryParityAsync(
             LibraryFiles = context.EmittedFiles
                 .Select(f => new GsharpSourceFile(Path.GetFileName(f.GsPath), f.GSharpSource))
                 .ToList(),
+            LibraryFriendAssemblies =
+                context.Options.OutputLayout == MigrationOutputLayout.Repository
+                    ? context.GeneratedFriendAssemblies.OrderBy(name => name, StringComparer.Ordinal).ToList()
+                    : Array.Empty<string>(),
             TestsName = libraryName + ".Tests",
             TestsRootNamespace = libraryName.Replace('-', '_') + ".Tests",
             TestFiles = tests.Files,
diff --git a/tools/cs2gs/Cs2Gs.Pipeline/TranslateStage.cs b/tools/cs2gs/Cs2Gs.Pipeline/TranslateStage.cs
@@ -273,7 +273,7 @@ await CSharpProjectLoader.LoadProjectAsync(
                 markMergedTypePartial: hasAnalyzerReferences,
                 retainedFilePaths: retainedFilePaths);
 
-            EmitFriendAssemblyAnnotations(
+            PreserveGeneratedFriendAssemblyAnnotations(
                 context,
                 currentProject,
                 isReferencedProject,
@@ -461,26 +461,38 @@ await CSharpProjectLoader.LoadProjectAsync(
         return artifacts.Count == 0 ? StageOutcome.Passed() : StageOutcome.Failed(artifacts);
     }
 
-    private static void EmitFriendAssemblyAnnotations(
+    private static void PreserveGeneratedFriendAssemblyAnnotations(
         StageExecutionContext context,
         LoadedCSharpProject project,
         bool isReferencedProject,
         ISet<string> usedOutputPaths)
     {
         const string attributeName = "System.Runtime.CompilerServices.InternalsVisibleToAttribute";
-
-        // Documents are loader-classified hand-authored sources; generated obj
-        // AssemblyInfo trees remain in the compilation but are excluded here.
+        var handAuthoredTrees = project.Documents
+            .Select(document => document.SyntaxTree)
+            .ToHashSet();
         List<string> friendAssemblies = project.Compilation.Assembly.GetAttributes()
             .Where(attribute =>
                 attribute.AttributeClass?.ToDisplayString() == attributeName &&
                 attribute.ConstructorArguments.Length == 1 &&
                 attribute.ConstructorArguments[0].Value is string &&
-                attribute.ApplicationSyntaxReference is { SyntaxTree: { } syntaxTree } &&
-                project.Documents.Any(document => document.SyntaxTree == syntaxTree))
+                !handAuthoredTrees.Contains(attribute.ApplicationSyntaxReference?.SyntaxTree))
             .Select(attribute => (string)attribute.ConstructorArguments[0].Value)
             .Distinct(StringComparer.Ordinal)
             .ToList();
+        if (!isReferencedProject)
+        {
+            foreach (string friendAssembly in friendAssemblies)
+            {
+                context.GeneratedFriendAssemblies.Add(friendAssembly);
+            }
+        }
+
+        if (context.Options.OutputLayout == MigrationOutputLayout.Repository)
+        {
+            return;
+        }
+
         if (friendAssemblies.Count == 0)
         {
             return;
diff --git a/tools/cs2gs/Cs2Gs.Tests/MigrationPipelineTests.cs b/tools/cs2gs/Cs2Gs.Tests/MigrationPipelineTests.cs
@@ -202,11 +202,12 @@ public async Task L2_StagesOneAndTwo_AreGreen_WithZeroArtifacts()
     }
 
     /// <summary>
-    /// SDK-generated and hand-authored friend-assembly declarations must each
-    /// reach the compiled G# assembly exactly once.
+    /// Diagnostic-run projects disable SDK AssemblyInfo generation, so the
+    /// translator must retain only generated friend declarations while the
+    /// hand-authored fully-qualified attribute stays in its translated source.
     /// </summary>
     [Fact]
-    public async Task L2_Compile_EmitsInternalsVisibleToExactlyOnce()
+    public async Task L2_DiagnosticCompile_EmitsInternalsVisibleToExactlyOnce()
     {
         string compiler = FindCompiler();
         if (compiler is null)
@@ -216,60 +217,96 @@ public async Task L2_Compile_EmitsInternalsVisibleToExactlyOnce()
 
         string corpus = ResolveCorpusDir();
         string repoRoot = GsharpTestProjectRunner.FindRepoRoot();
-        (string NupkgPath, string Version)? sdk =
-            GsharpTestProjectRunner.ResolveLocalSdkPackage(repoRoot);
-        if (sdk is null)
+        if (GsharpTestProjectRunner.ResolveLocalSdkPackage(repoRoot) is null)
         {
             return;
         }
 
-        CorpusApp originalL2 = CorpusDiscovery.FindById(corpus, "corpus/L2-Library");
         string sourceRoot = NewOutputRoot("l2-friend-source");
-        string sourceProjectDir = Path.Combine(sourceRoot, "L2-Library");
-        Directory.CreateDirectory(sourceProjectDir);
-        File.Copy(
-            Path.Combine(corpus, "Directory.Build.props"),
-            Path.Combine(sourceRoot, "Directory.Build.props"));
-        string projectPath = Path.Combine(sourceProjectDir, Path.GetFileName(originalL2.ProjectPath));
-        File.Copy(originalL2.ProjectPath, projectPath);
-        File.WriteAllText(
-            projectPath,
-            File.ReadAllText(projectPath).Replace(
-                "<PropertyGroup>",
-                "<PropertyGroup>" + Environment.NewLine + "    <TargetFramework>net10.0</TargetFramework>",
-                StringComparison.Ordinal));
-        File.WriteAllText(Path.Combine(sourceProjectDir, "FriendAssembly.cs"), """
-            using System.Runtime.CompilerServices;
-
-            [assembly: InternalsVisibleTo("L2-Library.Source.Tests")]
-
-            public sealed class Marker
-            {
-            }
-            """);
-        var l2 = new CorpusApp(
-            originalL2.Id,
-            projectPath,
-            originalL2.TargetKind);
-        string outRoot = NewOutputRoot("l2-friend-assembly");
+        CorpusApp l2 = CreateFriendAssemblyFixture(corpus, sourceRoot);
+        string outRoot = NewOutputRoot("l2-friend-diagnostic");
         var options = new PipelineOptions { GscPath = compiler, OutputRoot = outRoot };
-        var pipeline = new MigrationPipeline(options, new IMigrationStage[] { new TranslateStage() });
+        var pipeline = new MigrationPipeline(
+            options,
+            new IMigrationStage[] { new TranslateStage(), new CompileStage() });
 
         RunResult result = await pipeline.RunAsync(new[] { l2 });
         AppResult app = Assert.Single(result.Apps);
 
-        Assert.True(app.Succeeded);
+        Assert.True(app.Succeeded, string.Join(Environment.NewLine, app.Artifacts));
         string appDir = Path.Combine(outRoot, result.RunId, MigrationPipeline.SanitizeAppId(l2.Id));
-        string generatedProjectPath = Path.Combine(appDir, "L2-Library.gsproj");
+        Assert.Equal(
+            "@assembly:InternalsVisibleTo(\"L2-Library.Tests\")" + Environment.NewLine,
+            File.ReadAllText(Path.Combine(appDir, "AssemblyInfo.gs")));
+        Assert.Contains(
+            "@assembly:System.Runtime.CompilerServices.InternalsVisibleTo(\"L2-Library.Source.Tests\")",
+            File.ReadAllText(Path.Combine(appDir, "FriendAssembly.gs")),
+            StringComparison.Ordinal);
+
+        string assemblyPath = Path.Combine(appDir, "bin", "Release", "net10.0", "L2-Library.dll");
+        AssertFriendAssemblies(assemblyPath);
+    }
+
+    /// <summary>
+    /// Repository projects preserve the MSBuild item and must not receive a
+    /// second generated G# annotation from translation.
+    /// </summary>
+    [Fact]
+    public async Task L2_RepositoryCompile_EmitsInternalsVisibleToExactlyOnce()
+    {
+        string compiler = FindCompiler();
+        string repoRoot = GsharpTestProjectRunner.FindRepoRoot();
+        (string NupkgPath, string Version)? sdk =
+            GsharpTestProjectRunner.ResolveLocalSdkPackage(repoRoot);
+        if (compiler is null || sdk is null)
+        {
+            return;
+        }
+
+        string corpus = ResolveCorpusDir();
+        string sourceRoot = NewOutputRoot("l2-friend-repository-source");
+        CorpusApp l2 = CreateFriendAssemblyFixture(corpus, sourceRoot);
+        string destinationRoot = NewOutputRoot("l2-friend-repository");
+        string projectDir = Path.Combine(destinationRoot, "L2-Library");
+        Directory.CreateDirectory(projectDir);
+        var options = new PipelineOptions
+        {
+            GscPath = compiler,
+            SourceRoot = sourceRoot,
+            OutputRoot = destinationRoot,
+            OutputLayout = MigrationOutputLayout.Repository,
+        };
+        var context = new StageExecutionContext(
+            l2,
+            options,
+            new GscInvoker(compiler),
+            projectDir,
+            new TriageBuilder("run", "2026-07-28T00:00:00Z", "test", l2.Id));
+        StageOutcome translation = await new TranslateStage().ExecuteAsync(context);
+
+        Assert.Equal(StageStatus.Passed, translation.Status);
+        Assert.False(File.Exists(Path.Combine(projectDir, "AssemblyInfo.gs")));
+        Assert.Contains(
+            "@assembly:System.Runtime.CompilerServices.InternalsVisibleTo(\"L2-Library.Source.Tests\")",
+            File.ReadAllText(Path.Combine(projectDir, "FriendAssembly.gs")),
+            StringComparison.Ordinal);
+
+        string generatedProjectPath = Path.Combine(projectDir, "L2-Library.gsproj");
         GSharpProjectTransformer.Transform(
-            projectPath,
-            appDir,
+            l2.ProjectPath,
+            projectDir,
             "Gsharp.NET.Sdk/" + sdk.Value.Version,
             generatedProjectPaths: null).Save(
                 generatedProjectPath,
                 System.Xml.Linq.SaveOptions.DisableFormatting);
+        Assert.Single(
+            System.Xml.Linq.XDocument.Load(generatedProjectPath).Descendants(),
+            element =>
+                element.Name.LocalName == "InternalsVisibleTo" &&
+                element.Attribute("Include")?.Value == "L2-Library.Tests");
+
         GsharpTestProjectRunner.EnsureInLocalFeed(repoRoot, sdk.Value.NupkgPath);
-        GsharpTestProjectRunner.WriteIsolationBoundary(appDir);
+        GsharpTestProjectRunner.WriteIsolationBoundary(projectDir);
         ProcessRunResult build = ProcessRunner.Run(
             "dotnet",
             new[]
@@ -280,21 +317,12 @@ public sealed class Marker
                 "Release",
                 "-p:RestoreConfigFile=" + Path.Combine(repoRoot, "nuget.config"),
             },
-            appDir,
+            projectDir,
             TimeSpan.FromMinutes(5));
         Assert.True(build.ExitCode == 0, build.Output);
 
-        string assemblyPath = Path.Combine(appDir, "bin", "Release", "net10.0", "L2-Library.dll");
-        Assembly assembly = Assembly.LoadFile(assemblyPath);
-        string[] friendAssemblies = assembly.GetCustomAttributesData()
-            .Where(attribute => attribute.AttributeType == typeof(InternalsVisibleToAttribute))
-            .Select(attribute => (string)Assert.Single(attribute.ConstructorArguments).Value)
-            .OrderBy(name => name, StringComparer.Ordinal)
-            .ToArray();
-
-        Assert.Equal(
-            new[] { "L2-Library.Source.Tests", "L2-Library.Tests" },
-            friendAssemblies);
+        string assemblyPath = Path.Combine(projectDir, "bin", "Release", "net10.0", "L2-Library.dll");
+        AssertFriendAssemblies(assemblyPath);
     }
 
     /// <summary>
@@ -559,6 +587,50 @@ public Task<StageOutcome> ExecuteAsync(StageExecutionContext context, Cancellati
             Task.FromResult(StageOutcome.Failed(Array.Empty<TriageArtifact>()));
     }
 
+    private static CorpusApp CreateFriendAssemblyFixture(string corpus, string sourceRoot)
+    {
+        CorpusApp original = CorpusDiscovery.FindById(corpus, "corpus/L2-Library");
+        string projectDir = Path.Combine(sourceRoot, "L2-Library");
+        Directory.CreateDirectory(projectDir);
+        File.Copy(
+            Path.Combine(corpus, "Directory.Build.props"),
+            Path.Combine(sourceRoot, "Directory.Build.props"));
+        string projectPath = Path.Combine(projectDir, Path.GetFileName(original.ProjectPath));
+        File.Copy(original.ProjectPath, projectPath);
+        File.WriteAllText(
+            projectPath,
+            File.ReadAllText(projectPath).Replace(
+                "<PropertyGroup>",
+                "<PropertyGroup>" + Environment.NewLine + "    <TargetFramework>net10.0</TargetFramework>",
+                StringComparison.Ordinal));
+        File.WriteAllText(Path.Combine(projectDir, "FriendAssembly.cs"), """
+            [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("L2-Library.Source.Tests")]
+
+            public sealed class Marker
+            {
+            }
+            """);
+        return new CorpusApp(
+            original.Id,
+            projectPath,
+            original.TargetKind,
+            relativeProjectPath: Path.Combine("L2-Library", Path.GetFileName(projectPath)));
+    }
+
+    private static void AssertFriendAssemblies(string assemblyPath)
+    {
+        Assembly assembly = Assembly.LoadFile(assemblyPath);
+        string[] friendAssemblies = assembly.GetCustomAttributesData()
+            .Where(attribute => attribute.AttributeType == typeof(InternalsVisibleToAttribute))
+            .Select(attribute => (string)Assert.Single(attribute.ConstructorArguments).Value)
+            .OrderBy(name => name, StringComparer.Ordinal)
+            .ToArray();
+
+        Assert.Equal(
+            new[] { "L2-Library.Source.Tests", "L2-Library.Tests" },
+            friendAssemblies);
+    }
+
     private static string FingerprintShort(string fingerprint)
     {
         string hex = fingerprint.StartsWith("sha256:", StringComparison.Ordinal)
diff --git a/tools/cs2gs/Cs2Gs.Tests/TestParityLibraryLiveTests.cs b/tools/cs2gs/Cs2Gs.Tests/TestParityLibraryLiveTests.cs
