Merge pull request #487 from CommunityToolkit/dev/generator-tweaks

Sergio0694 · web-flow · commit a0df37193765 · 2022-10-29T06:37:10.000-07:00
More source generator optimizations
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/Extensions/INamedTypeSymbolExtensions.cs b/CommunityToolkit.Mvvm.SourceGenerators/Extensions/INamedTypeSymbolExtensions.cs
@@ -2,8 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Text;
+using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 using Microsoft.CodeAnalysis;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
@@ -20,27 +22,46 @@ internal static class INamedTypeSymbolExtensions
     /// <returns>The full metadata name for <paramref name="symbol"/> that is also a valid filename.</returns>
     public static string GetFullMetadataNameForFileName(this INamedTypeSymbol symbol)
     {
-        static StringBuilder BuildFrom(ISymbol? symbol, StringBuilder builder)
+        using ImmutableArrayBuilder<char> builder = ImmutableArrayBuilder<char>.Rent();
+
+        static void BuildFrom(ISymbol? symbol, in ImmutableArrayBuilder<char> builder)
         {
-            return symbol switch
+            switch (symbol)
             {
-                INamespaceSymbol ns when ns.IsGlobalNamespace => builder,
-                INamespaceSymbol ns when ns.ContainingNamespace is { IsGlobalNamespace: false }
-                    => BuildFrom(ns.ContainingNamespace, builder.Insert(0, $".{ns.MetadataName}")),
-                ITypeSymbol ts when ts.ContainingType is ISymbol pt
-                    => BuildFrom(pt, builder.Insert(0, $"+{ts.MetadataName}")),
-                ITypeSymbol ts when ts.ContainingNamespace is ISymbol pn and not INamespaceSymbol { IsGlobalNamespace: true }
-                    => BuildFrom(pn, builder.Insert(0, $".{ts.MetadataName}")),
-                ISymbol => BuildFrom(symbol.ContainingSymbol, builder.Insert(0, symbol.MetadataName)),
-                _ => builder
-            };
+                // Namespaces that are nested also append a leading '.'
+                case INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: false }:
+                    BuildFrom(symbol.ContainingNamespace, in builder);
+                    builder.Add('.');
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+                // Other namespaces (ie. the one right before global) skip the leading '.'
+                case INamespaceSymbol { IsGlobalNamespace: false }:
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+                // Types with no namespace just have their metadata name directly written
+                case ITypeSymbol { ContainingSymbol: INamespaceSymbol { IsGlobalNamespace: true } }:
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+                // Types with a containing non-global namespace also append a leading '.'
+                case ITypeSymbol { ContainingSymbol: INamespaceSymbol namespaceSymbol }:
+                    BuildFrom(namespaceSymbol, in builder);
+                    builder.Add('.');
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+                // Nested types append a leading '+'
+                case ITypeSymbol { ContainingSymbol: ITypeSymbol typeSymbol }:
+                    BuildFrom(typeSymbol, in builder);
+                    builder.Add('+');
+                    builder.AddRange(symbol.MetadataName.AsSpan());
+                    break;
+                default:
+                    break;
+            }
         }
 
-        // Build the full metadata name by concatenating the metadata names of all symbols from the input
-        // one to the outermost namespace, if any. Additionally, the ` and + symbols need to be replaced
-        // to avoid errors when generating code. This is a known issue with source generators not accepting
-        // those characters at the moment, see: https://github.com/dotnet/roslyn/issues/58476.
-        return BuildFrom(symbol, new StringBuilder(256)).Replace('`', '-').Replace('+', '.').ToString();
+        BuildFrom(symbol, in builder);
+
+        return builder.ToString();
     }
 
     /// <summary>
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/Helpers/ImmutableArrayBuilder{T}.cs b/CommunityToolkit.Mvvm.SourceGenerators/Helpers/ImmutableArrayBuilder{T}.cs
@@ -2,81 +2,234 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This file is ported and adapted from ComputeSharp (Sergio0694/ComputeSharp),
+// more info in ThirdPartyNotices.txt in the root of the project.
+
 using System;
 using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 
 /// <summary>
-/// A helper type to build <see cref="ImmutableArray{T}"/> instances with pooled buffers.
+/// A helper type to build sequences of values with pooled buffers.
 /// </summary>
-/// <typeparam name="T">The type of items to create arrays for.</typeparam>
-internal ref struct ImmutableArrayBuilder<T>
+/// <typeparam name="T">The type of items to create sequences for.</typeparam>
+internal struct ImmutableArrayBuilder<T> : IDisposable
 {
     /// <summary>
-    /// The shared <see cref="ObjectPool{T}"/> instance to share <see cref="ImmutableArray{T}.Builder"/> objects.
+    /// The shared <see cref="ObjectPool{T}"/> instance to share <see cref="Writer"/> objects.
     /// </summary>
-    private static readonly ObjectPool<ImmutableArray<T>.Builder> sharedObjectPool = new(ImmutableArray.CreateBuilder<T>);
+    private static readonly ObjectPool<Writer> SharedObjectPool = new(static () => new Writer());
 
     /// <summary>
-    /// The rented <see cref="ImmutableArray{T}.Builder"/> instance to use.
+    /// The rented <see cref="Writer"/> instance to use.
     /// </summary>
-    private ImmutableArray<T>.Builder? builder;
+    private Writer? writer;
 
     /// <summary>
-    /// Rents a new pooled <see cref="ImmutableArray{T}.Builder"/> instance through a new <see cref="ImmutableArrayBuilder{T}"/> value.
+    /// Creates a <see cref="ImmutableArrayBuilder{T}"/> value with a pooled underlying data writer.
     /// </summary>
-    /// <returns>A <see cref="ImmutableArrayBuilder{T}"/> to interact with the underlying <see cref="ImmutableArray{T}.Builder"/> instance.</returns>
+    /// <returns>A <see cref="ImmutableArrayBuilder{T}"/> instance to write data to.</returns>
     public static ImmutableArrayBuilder<T> Rent()
     {
-        return new(sharedObjectPool.Allocate());
+        return new(SharedObjectPool.Allocate());
     }
 
     /// <summary>
     /// Creates a new <see cref="ImmutableArrayBuilder{T}"/> object with the specified parameters.
     /// </summary>
-    /// <param name="builder"></param>
-    private ImmutableArrayBuilder(ImmutableArray<T>.Builder builder)
+    /// <param name="writer">The target data writer to use.</param>
+    private ImmutableArrayBuilder(Writer writer)
     {
-        this.builder = builder;
+        this.writer = writer;
     }
 
     /// <inheritdoc cref="ImmutableArray{T}.Builder.Count"/>
-    public readonly int Count
+    public int Count
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => this.writer!.Count;
+    }
+
+    /// <summary>
+    /// Gets the data written to the underlying buffer so far, as a <see cref="ReadOnlySpan{T}"/>.
+    /// </summary>
+    public readonly ReadOnlySpan<T> WrittenSpan
     {
-        get => this.builder!.Count;
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => this.writer!.WrittenSpan;
     }
 
     /// <inheritdoc cref="ImmutableArray{T}.Builder.Add(T)"/>
     public readonly void Add(T item)
     {
-        this.builder!.Add(item);
+        this.writer!.Add(item);
+    }
+
+    /// <summary>
+    /// Adds the specified items to the end of the array.
+    /// </summary>
+    /// <param name="items">The items to add at the end of the array.</param>
+    public readonly void AddRange(ReadOnlySpan<T> items)
+    {
+        this.writer!.AddRange(items);
     }
 
     /// <inheritdoc cref="ImmutableArray{T}.Builder.ToImmutable"/>
     public readonly ImmutableArray<T> ToImmutable()
     {
-        return this.builder!.ToImmutable();
+        T[] array = this.writer!.WrittenSpan.ToArray();
+
+        return Unsafe.As<T[], ImmutableArray<T>>(ref array);
     }
 
     /// <inheritdoc cref="ImmutableArray{T}.Builder.ToArray"/>
     public readonly T[] ToArray()
     {
-        return this.builder!.ToArray();
+        return this.writer!.WrittenSpan.ToArray();
     }
 
-    /// <inheritdoc cref="IDisposable.Dispose"/>
+    /// <inheritdoc/>
+    public override readonly string ToString()
+    {
+        return this.writer!.WrittenSpan.ToString();
+    }
+
+    /// <inheritdoc/>
     public void Dispose()
     {
-        ImmutableArray<T>.Builder? builder = this.builder;
+        Writer? writer = this.writer;
 
-        this.builder = null;
+        this.writer = null;
 
-        if (builder is not null)
+        if (writer is not null)
         {
-            builder.Clear();
+            writer.Clear();
 
-            sharedObjectPool.Free(builder);
+            SharedObjectPool.Free(writer);
+        }
+    }
+
+    /// <summary>
+    /// A class handling the actual buffer writing.
+    /// </summary>
+    private sealed class Writer
+    {
+        /// <summary>
+        /// The underlying <typeparamref name="T"/> array.
+        /// </summary>
+        private T[] array;
+
+        /// <summary>
+        /// The starting offset within <see cref="array"/>.
+        /// </summary>
+        private int index;
+
+        /// <summary>
+        /// Creates a new <see cref="Writer"/> instance with the specified parameters.
+        /// </summary>
+        public Writer()
+        {
+            if (typeof(T) == typeof(char))
+            {
+                this.array = new T[1024];
+            }
+            else
+            {
+                this.array = new T[8];
+            }
+
+            this.index = 0;
+        }
+
+        /// <inheritdoc cref="ImmutableArrayBuilder{T}.Count"/>
+        public int Count
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.array!.Length;
+        }
+
+        /// <inheritdoc cref="ImmutableArrayBuilder{T}.WrittenSpan"/>
+        public ReadOnlySpan<T> WrittenSpan
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => new(this.array, 0, this.index);
         }
+
+        /// <inheritdoc cref="ImmutableArrayBuilder{T}.Add"/>
+        public void Add(T value)
+        {
+            EnsureCapacity(1);
+
+            this.array[this.index++] = value;
+        }
+
+        /// <inheritdoc cref="ImmutableArrayBuilder{T}.AddRange"/>
+        public void AddRange(ReadOnlySpan<T> items)
+        {
+            EnsureCapacity(items.Length);
+
+            items.CopyTo(this.array.AsSpan(this.index));
+
+            this.index += items.Length;
+        }
+
+        /// <summary>
+        /// Clears the items in the current writer.
+        /// </summary>
+        public void Clear()
+        {
+            if (typeof(T) != typeof(char))
+            {
+                this.array.AsSpan(0, this.index).Clear();
+            }
+
+            this.index = 0;
+        }
+
+        /// <summary>
+        /// Ensures that <see cref="array"/> has enough free space to contain a given number of new items.
+        /// </summary>
+        /// <param name="requestedSize">The minimum number of items to ensure space for in <see cref="array"/>.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void EnsureCapacity(int requestedSize)
+        {
+            if (requestedSize > this.array.Length - this.index)
+            {
+                ResizeBuffer(requestedSize);
+            }
+        }
+
+        /// <summary>
+        /// Resizes <see cref="array"/> to ensure it can fit the specified number of new items.
+        /// </summary>
+        /// <param name="sizeHint">The minimum number of items to ensure space for in <see cref="array"/>.</param>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void ResizeBuffer(int sizeHint)
+        {
+            int minimumSize = this.index + sizeHint;
+            int requestedSize = Math.Max(this.array.Length * 2, minimumSize);
+
+            T[] newArray = new T[requestedSize];
+
+            Array.Copy(this.array, newArray, this.index);
+
+            this.array = newArray;
+        }
+    }
+}
+
+/// <summary>
+/// Private helpers for the <see cref="ImmutableArrayBuilder{T}"/> type.
+/// </summary>
+file static class ImmutableArrayBuilder
+{
+    /// <summary>
+    /// Throws an <see cref="ArgumentOutOfRangeException"/> for <c>"index"</c>.
+    /// </summary>
+    public static void ThrowArgumentOutOfRangeExceptionForIndex()
+    {
+        throw new ArgumentOutOfRangeException("index");
     }
 }
