NameUtils.RenameAllAsync now works alongside document renaming in TransformHandles

Author: Exanite

.silktouch/a8a82533527277ff.stout

@@ -169,10 +169,10 @@
         "AddApiProfiles",
         "MixKhronosData",
         "ExtractNestedTyping",
+        "PrettifyNames",
         "TransformHandles",
         "TransformFunctions",
         "TransformProperties",
-        "PrettifyNames",
         "AddVTables"
       ],
       "ClangScraper": {

generator.json

@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.FindSymbols;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Silk.NET.SilkTouch.Clang;
 using Silk.NET.SilkTouch.Naming;
@@ -37,7 +38,7 @@ namespace Silk.NET.SilkTouch.Mods;
 /// <c>Program</c>, <c>Program</c> must be declared in <c>Silk.NET.OpenGL</c>, <c>Silk.NET</c>, or <c>Silk</c>.
 /// </remarks>
 [ModConfiguration<Config>]
-public class TransformHandles(IOptionsSnapshot<TransformHandles.Config> config) : Mod
+public class TransformHandles(IOptionsSnapshot<TransformHandles.Config> config, ILogger<TransformHandles> logger) : Mod
 {
     /// <summary>
     /// The configuration for the <see cref="TransformHandles"/> mod.
@@ -69,12 +70,14 @@ public override async Task ExecuteAsync(IModContext ctx, CancellationToken ct =
 
         var cfg = config.Get(ctx.JobKey);
 
-        // First pass to gather data
+        // Phase 1. Gather data before modifying
+        // Find handle documents
         var handleTypeDiscoverer = new HandleTypeDiscoverer(proj, compilation, ct);
         var handleTypes = await handleTypeDiscoverer.GetHandleTypesAsync();
 
-        // Second pass to modify the project based on gathered data
-        var handleTypeRewriter = new HandleTypeRewriter(cfg.UseDSL);
+        // Store handle document IDs for later
+        // We will use these IDs to know which documents to rewrite and rename
+        var handleTypeDocumentIds = new List<(string OriginalName, DocumentId DocumentId)>();
         foreach (var handleTypeSymbol in handleTypes)
         {
             if (handleTypeSymbol.DeclaringSyntaxReferences.Length > 1)
@@ -85,25 +88,45 @@ public override async Task ExecuteAsync(IModContext ctx, CancellationToken ct =
             }
 
             var declaringSyntaxReference = handleTypeSymbol.DeclaringSyntaxReferences.Single();
-            var document = proj.GetDocument(declaringSyntaxReference.SyntaxTree);
-            if (document != null)
+            var documentId = proj.GetDocumentId(declaringSyntaxReference.SyntaxTree);
+            if (documentId != null)
             {
-                var syntaxTree = await document.GetSyntaxTreeAsync(ct);
-                if (syntaxTree == null)
-                {
-                    continue;
-                }
+                handleTypeDocumentIds.Add((handleTypeSymbol.Name, documentId));
+            }
+        }
 
-                var syntaxRoot = await syntaxTree.GetRootAsync(ct);
+        // Phase 2. Modify project after gathering data
+        // Add -Handle suffix
+        ctx.SourceProject = proj;
+        await NameUtils.RenameAllAsync(ctx, logger, handleTypes.Select(t => ((ISymbol)t, $"{t.Name}Handle")), ct);
+        proj = ctx.SourceProject;
 
-                // Rewrite handle struct to include handle members
-                document = document.WithSyntaxRoot(handleTypeRewriter.Visit(syntaxRoot).NormalizeWhitespace());
+        // Use document IDs from earlier
+        var handleTypeRewriter = new HandleTypeRewriter(cfg.UseDSL);
+        foreach (var (originalName, documentId) in handleTypeDocumentIds)
+        {
+            var document = proj.GetDocument(documentId) ?? throw new InvalidOperationException("Failed to find document");
 
-                proj = document.Project;
+            var syntaxTree = await document.GetSyntaxTreeAsync(ct);
+            if (syntaxTree == null)
+            {
+                continue;
             }
+
+            var syntaxRoot = await syntaxTree.GetRootAsync(ct);
+
+            // Rewrite handle struct to include handle members
+            document = document.WithSyntaxRoot(handleTypeRewriter.Visit(syntaxRoot).NormalizeWhitespace());
+
+            // Add -Handle suffix to end of document name
+            document = document.WithFilePath(
+                    document.FilePath!.Replace(originalName, $"{originalName}Handle")
+                )
+                .WithName(document.Name.Replace(originalName, $"{originalName}Handle"));
+
+            proj = document.Project;
         }
 
-        // TODO: Add -Handle prefix to handle type names
         // TODO: Reduce handle pointer dimensions by 1
 
         // TODO: Old code. Cleanup needed
@@ -132,12 +155,12 @@ public override async Task ExecuteAsync(IModContext ctx, CancellationToken ct =
 
     private class HandleTypeDiscoverer(Project project, Compilation compilation, CancellationToken ct) : SymbolVisitor
     {
-        private readonly Solution solution = project.Solution;
+        private readonly Solution _solution = project.Solution;
 
         /// <summary>
         /// All discovered empty structs. These are not all handle types.
         /// </summary>
-        private readonly List<INamedTypeSymbol> emptyStructs = new();
+        private readonly List<INamedTypeSymbol> _emptyStructs = new();
 
         /// <summary>
         /// Finds all symbols that correspond to a handle type.
@@ -151,12 +174,12 @@ public async Task<List<INamedTypeSymbol>> GetHandleTypesAsync()
 
             var results = new List<INamedTypeSymbol>();
             var documents = project.Documents.ToImmutableHashSet();
-            foreach (var structSymbol in emptyStructs)
+            foreach (var structSymbol in _emptyStructs)
             {
                 // For each struct, find its references
                 // Verify that all references are through pointers
                 // Also verify that there is at least one reference through a pointer
-                var references = await SymbolFinder.FindReferencesAsync(structSymbol, solution, documents, ct);
+                var references = await SymbolFinder.FindReferencesAsync(structSymbol, _solution, documents, ct);
 
                 var wasReferencedAsPointer = false;
                 var wasReferencedAsNonPointer = false;
@@ -198,10 +221,7 @@ public async Task<List<INamedTypeSymbol>> GetHandleTypesAsync()
         /// <summary>
         /// Clears all internal state
         /// </summary>
-        private void Clear()
-        {
-            emptyStructs.Clear();
-        }
+        private void Clear() => _emptyStructs.Clear();
 
         public override void VisitNamespace(INamespaceSymbol symbol)
         {
@@ -225,7 +245,7 @@ public override void VisitNamedType(INamedTypeSymbol symbol)
                 return;
             }
 
-            emptyStructs.Add(symbol);
+            _emptyStructs.Add(symbol);
         }
     }
 

sources/SilkTouch/SilkTouch/Mods/TransformHandles.cs

@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// Ported from the Vulkan headers and corresponding dependencies.
+// Original source is Copyright 2015-2023 The Khronos Group Inc. Licensed under the MIT license.
+global using global::System;
+global using global::System.Collections.Generic;
+global using global::System.IO;
+global using global::System.Linq;
+global using global::System.Net.Http;
+global using global::System.Threading;
+global using global::System.Threading.Tasks;
+global using Silk.NET.Core;
+global using static Silk.NET.Core.DSL;
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Silk.NET.Vulkan;
+
+public readonly unsafe partial struct AccelerationStructureKHRHandle
+{
+    public readonly void* Handle;
+
+    public bool Equals(AccelerationStructureKHRHandle other) => Handle == other.Handle;
+
+    public override bool Equals(object? obj) =>
+        obj is AccelerationStructureKHRHandle other && Equals(other);
+
+    public override int GetHashCode() => HashCode.Combine((nuint)Handle);
+
+    public static bool operator ==(
+        AccelerationStructureKHRHandle left,
+        AccelerationStructureKHRHandle right
+    ) => left.Equals(right);
+
+    public static bool operator !=(
+        AccelerationStructureKHRHandle left,
+        AccelerationStructureKHRHandle right
+    ) => !left.Equals(right);
+
+    public bool Equals(NullPtr _) => Handle is null;
+
+    public static bool operator ==(AccelerationStructureKHRHandle left, NullPtr right) =>
+        left.Equals(right);
+
+    public static bool operator !=(AccelerationStructureKHRHandle left, NullPtr right) =>
+        !left.Equals(right);
+
+    public static implicit operator AccelerationStructureKHRHandle(NullPtr _) => default;
+}

sources/Vulkan/Vulkan/Handles/AccelerationStructureKHRHandle.gen.cs

@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// Ported from the Vulkan headers and corresponding dependencies.
+// Original source is Copyright 2015-2023 The Khronos Group Inc. Licensed under the MIT license.
+global using global::System;
+global using global::System.Collections.Generic;
+global using global::System.IO;
+global using global::System.Linq;
+global using global::System.Net.Http;
+global using global::System.Threading;
+global using global::System.Threading.Tasks;
+global using Silk.NET.Core;
+global using static Silk.NET.Core.DSL;
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Silk.NET.Vulkan;
+
+public readonly unsafe partial struct AccelerationStructureNVHandle
+{
+    public readonly void* Handle;
+
+    public bool Equals(AccelerationStructureNVHandle other) => Handle == other.Handle;
+
+    public override bool Equals(object? obj) =>
+        obj is AccelerationStructureNVHandle other && Equals(other);
+
+    public override int GetHashCode() => HashCode.Combine((nuint)Handle);
+
+    public static bool operator ==(
+        AccelerationStructureNVHandle left,
+        AccelerationStructureNVHandle right
+    ) => left.Equals(right);
+
+    public static bool operator !=(
+        AccelerationStructureNVHandle left,
+        AccelerationStructureNVHandle right
+    ) => !left.Equals(right);
+
+    public bool Equals(NullPtr _) => Handle is null;
+
+    public static bool operator ==(AccelerationStructureNVHandle left, NullPtr right) =>
+        left.Equals(right);
+
+    public static bool operator !=(AccelerationStructureNVHandle left, NullPtr right) =>
+        !left.Equals(right);
+
+    public static implicit operator AccelerationStructureNVHandle(NullPtr _) => default;
+}

sources/Vulkan/Vulkan/Handles/AccelerationStructureNV.gen.cs

@@ -18,25 +18,25 @@
 
 namespace Silk.NET.Vulkan;
 
-public readonly unsafe partial struct ShaderModule
+public readonly unsafe partial struct BufferHandle
 {
     public readonly void* Handle;
 
-    public bool Equals(ShaderModule other) => Handle == other.Handle;
+    public bool Equals(BufferHandle other) => Handle == other.Handle;
 
-    public override bool Equals(object? obj) => obj is ShaderModule other && Equals(other);
+    public override bool Equals(object? obj) => obj is BufferHandle other && Equals(other);
 
     public override int GetHashCode() => HashCode.Combine((nuint)Handle);
 
-    public static bool operator ==(ShaderModule left, ShaderModule right) => left.Equals(right);
+    public static bool operator ==(BufferHandle left, BufferHandle right) => left.Equals(right);
 
-    public static bool operator !=(ShaderModule left, ShaderModule right) => !left.Equals(right);
+    public static bool operator !=(BufferHandle left, BufferHandle right) => !left.Equals(right);
 
     public bool Equals(NullPtr _) => Handle is null;
 
-    public static bool operator ==(ShaderModule left, NullPtr right) => left.Equals(right);
+    public static bool operator ==(BufferHandle left, NullPtr right) => left.Equals(right);
 
-    public static bool operator !=(ShaderModule left, NullPtr right) => !left.Equals(right);
+    public static bool operator !=(BufferHandle left, NullPtr right) => !left.Equals(right);
 
-    public static implicit operator ShaderModule(NullPtr _) => default;
+    public static implicit operator BufferHandle(NullPtr _) => default;
 }