chore: initial commit

Signed-off-by: Alan Brault <alan.brault@visus.io>

src/MapperSourceGen.SourceGenerator/Model/HierarchyInfo.cs

@@ -0,0 +1,115 @@
+// This file is ported and adapted from CommunityToolkit.Mvvm (CommunityToolkit/dotnet)
+
+namespace MapperSourceGen.SourceGenerator.Model;
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using static Microsoft.CodeAnalysis.SymbolDisplayTypeQualificationStyle;
+
+/// <summary>
+///     Represents information about a type hierarchy in a source code file.
+/// </summary>
+internal sealed partial class HierarchyInfo : IEquatable<HierarchyInfo>
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="HierarchyInfo" /> class.
+    /// </summary>
+    /// <param name="fileNameHint">The filename hint for the type (including namespace) without extension.</param>
+    /// <param name="namespace">The containing namespace for the type.</param>
+    /// <param name="hierarchy">The current hierarchy for the type.</param>
+    /// <exception cref="ArgumentException"><paramref name="fileNameHint" /> is <c>null</c> or empty.</exception>
+    private HierarchyInfo(string fileNameHint, string @namespace, ImmutableArray<TypeInfo> hierarchy)
+    {
+        if ( string.IsNullOrWhiteSpace(fileNameHint) )
+        {
+            throw new ArgumentException($"'{nameof(fileNameHint)}' cannot be null or empty.", nameof(fileNameHint));
+        }
+
+        FileNameHint = fileNameHint;
+        Hierarchy = hierarchy;
+        Namespace = @namespace;
+    }
+
+    /// <summary>
+    ///     Gets the file name hint (including full namespace) for the type hierarchy.
+    /// </summary>
+    public string FileNameHint { get; }
+
+    /// <summary>
+    ///     Gets a collection of <see cref="TypeInfo" /> representing the hierarchy of types.
+    /// </summary>
+    public ImmutableArray<TypeInfo> Hierarchy { get; }
+
+    /// <summary>
+    ///     Gets the namespace of the type hierarchy.
+    /// </summary>
+    public string Namespace { get; }
+
+    public static HierarchyInfo From(INamedTypeSymbol typeSymbol)
+    {
+        if ( typeSymbol is null )
+        {
+            throw new ArgumentNullException(nameof(typeSymbol));
+        }
+
+        LinkedList<TypeInfo> hierarchy = [];
+
+        for ( INamedTypeSymbol? parent = typeSymbol;
+             parent is not null;
+             parent = parent.ContainingType )
+        {
+            hierarchy.AddLast(new TypeInfo(parent.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
+                                           parent.TypeKind,
+                                           parent.DeclaredAccessibility,
+                                           parent.IsRecord,
+                                           parent.IsSealed));
+        }
+
+        return new HierarchyInfo(typeSymbol.ToDisplayString(new SymbolDisplayFormat(typeQualificationStyle: NameAndContainingTypesAndNamespaces)),
+                                 typeSymbol.ContainingNamespace.ToDisplayString(new SymbolDisplayFormat(typeQualificationStyle: NameAndContainingTypesAndNamespaces)),
+                                 [..hierarchy]);
+    }
+
+    public static bool operator ==(HierarchyInfo? left, HierarchyInfo? right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(HierarchyInfo? left, HierarchyInfo? right)
+    {
+        return !Equals(left, right);
+    }
+
+    /// <inheritdoc />
+    public bool Equals(HierarchyInfo? other)
+    {
+        if ( other is null )
+        {
+            return false;
+        }
+
+        if ( ReferenceEquals(this, other) )
+        {
+            return true;
+        }
+
+        return string.Equals(FileNameHint, other.FileNameHint, StringComparison.OrdinalIgnoreCase)
+            && string.Equals(Namespace, other.Namespace, StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <inheritdoc />
+    public override bool Equals(object? obj)
+    {
+        return ReferenceEquals(this, obj) || ( obj is HierarchyInfo other && Equals(other) );
+    }
+
+    /// <inheritdoc />
+    public override int GetHashCode()
+    {
+        unchecked
+        {
+            return ( StringComparer.OrdinalIgnoreCase.GetHashCode(FileNameHint) * 397 )
+                 ^ StringComparer.OrdinalIgnoreCase.GetHashCode(Namespace);
+        }
+    }
+}