Enhance MatchTypeInfo and PropertySelection

Added multiple constructors to MatchTypeInfo for flexible initialization. Introduced FlattenedPropertyPath and ToEnumerablePath methods in PropertySelection for better property path handling. Fixed a bug in PropertySelection's Select method. Enhanced TypeDescriptor for accurate type name representation and added a static Object property. Added extension methods for extracting strings from AttributeSyntax. Implemented TryReadStringValue for parsing syntax trees. Updated project version to 0.1.8.

Author: eglauko

RoyalCode.Utils/RoyalCode.Extensions.SourceGenerator/Descriptors/PropertySelection/MatchTypeInfo.cs

@@ -28,6 +28,52 @@ public MatchTypeInfo(
         Options = options;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the MatchTypeInfo class for the specified target type descriptor.
+    /// </summary>
+    /// <remarks>
+    ///     The constructed instance uses the default match options and retrieves the target type's
+    ///     properties using the default property retriever.
+    ///     This ensures consistent matching behavior across instances.
+    /// </remarks>
+    /// <param name="targetType">
+    ///     The type descriptor representing the target type for which matching information will be constructed.
+    ///     Cannot be null.
+    /// </param>
+    public MatchTypeInfo(TypeDescriptor targetType)
+    {
+        Type = targetType;
+        Properties = MatchOptions.Default.TargetPropertiesRetriever.GetProperties(targetType);
+        Options = MatchOptions.Default;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the MatchTypeInfo class with the specified type descriptor and property
+    /// descriptors.
+    /// </summary>
+    /// <param name="type">The type descriptor representing the type to be matched.</param>
+    /// <param name="properties">A read-only list of property descriptors that define the properties associated with the type.</param>
+    public MatchTypeInfo(TypeDescriptor type, IReadOnlyList<PropertyDescriptor> properties)
+    {
+        Type = type;
+        Properties = properties;
+        Options = MatchOptions.Default;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the MatchTypeInfo class using the specified type descriptor and matching options.
+    /// </summary>
+    /// <param name="targetType">The type descriptor representing the target type for which property matching information will be generated.
+    /// Cannot be null.</param>
+    /// <param name="options">The options that configure property matching behavior, including how target properties are retrieved. Cannot be
+    /// null.</param>
+    public MatchTypeInfo(TypeDescriptor targetType, MatchOptions options)
+    {
+        Type = targetType;
+        Properties = options.TargetPropertiesRetriever.GetProperties(targetType);
+        Options = options;
+    }
+
     /// <summary>
     /// The type descriptor of the current type.
     /// </summary>

RoyalCode.Utils/RoyalCode.Extensions.SourceGenerator/Descriptors/PropertySelection/PropertySelection.cs

@@ -41,18 +41,62 @@ public void WritePropertyPath(StringBuilder sb)
         sb.Append(property.Name);
     }
 
+    /// <summary>
+    /// Returns a flattened string representation of the property path by concatenating the names of all properties in
+    /// the path.
+    /// </summary>
+    /// <examples>
+    ///     Given a property path like "Address.Street.Name", this method will return "AddressStreetName".
+    /// </examples>
+    /// <returns>
+    ///     A <see cref="string"/> that represents the flattened property path.
+    /// </returns>
+    public string FlattenedPropertyPath()
+    {
+        StringBuilder sb = new();
+        foreach (var p in ToEnumerablePath())
+        {
+            sb.Append(p.property.Name);
+        }
+        return sb.ToString();
+    }
+
+    /// <summary>
+    /// Returns an enumerable sequence representing the path from the root to the current property selection.
+    /// </summary>
+    /// <remarks>
+    ///     The returned sequence includes all ancestor property selections, followed by the current instance. 
+    ///     This can be used to traverse or analyze the full selection path in hierarchical scenarios.
+    /// </remarks>
+    /// <returns>
+    ///     An <see cref="IEnumerable{PropertySelection}"/> containing each property selection in the path,
+    ///     ordered from the root to the current instance.
+    /// </returns>
+    public IEnumerable<PropertySelection> ToEnumerablePath()
+    {
+        if (Parent is not null)
+        {
+            foreach (var p in Parent.ToEnumerablePath())
+                yield return p;
+        }
+        yield return this;
+    }
+
     public static PropertySelection? Select(PropertyDescriptor property, MatchTypeInfo targetType)
+        => Select(property.Name, targetType);
+
+    public static PropertySelection? Select(string propertyName, MatchTypeInfo targetType)
     {
         PropertySelection? ps = null;
 
-        var targetProperty = targetType.Properties.FirstOrDefault(p => p.Name == property.Name);
+        var targetProperty = targetType.Properties.FirstOrDefault(p => p.Name == propertyName);
 
         if (targetProperty != null)
         {
             return new PropertySelection(targetProperty);
         }
 
-        var parts = property.Name.SplitUpperCase();
+        var parts = propertyName.SplitUpperCase();
         if (parts is not null)
         {
             ps = SelectPart(parts, targetType);

RoyalCode.Utils/RoyalCode.Extensions.SourceGenerator/Descriptors/TypeDescriptor.cs

@@ -33,7 +33,6 @@ public static TypeDescriptor Create(ITypeSymbol typeSymbol)
     {
         var name = typeSymbol.ToString();
         bool isNullable = false;
-
         var namedTypeSymbol = typeSymbol as INamedTypeSymbol;
 
         if (name[name.Length - 1] == '?')
@@ -53,6 +52,10 @@ public static TypeDescriptor Create(ITypeSymbol typeSymbol)
             {
                 name = namedTypeSymbol.GetName();
             }
+            else
+            {
+                name = namedTypeSymbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
+            }
         }
 
         return new(name, namespaces, typeSymbol, isNullable);
@@ -112,6 +115,8 @@ public static TypeDescriptor Void()
         return voidTypeDescriptor;
     }
 
+    public static TypeDescriptor Object { get; } = new("object", ["System"]);
+
     #endregion
 
     private List<string>? hints;

RoyalCode.Utils/RoyalCode.Extensions.SourceGenerator/ExtensionMethods.cs

@@ -564,4 +564,107 @@ public static StringBuilder AppendPropertyPath(this StringBuilder sb, PropertySe
         property.WritePropertyPath(sb);
         return sb;
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static IEnumerable<string> GetConstructorStrings(this AttributeSyntax attr)
+    {
+        if (attr.ArgumentList is not { Arguments.Count: > 0 }) yield break;
+        foreach (var arg in attr.ArgumentList.Arguments)
+        {
+            if (arg.NameEquals is not null) continue; // skip named
+            if (TryReadStringValue(arg.Expression, out var value))
+                yield return value;
+            else if (arg.Expression is ArrayCreationExpressionSyntax acs && acs.Initializer is not null)
+            {
+                foreach (var expr in acs.Initializer.Expressions)
+                    if (TryReadStringValue(expr, out var v)) yield return v;
+            }
+            else if (arg.Expression is ImplicitArrayCreationExpressionSyntax iacs && iacs.Initializer is not null)
+            {
+                foreach (var expr in iacs.Initializer.Expressions)
+                    if (TryReadStringValue(expr, out var v)) yield return v;
+            }
+            else if (arg.Expression is InitializerExpressionSyntax init)
+            {
+                foreach (var expr in init.Expressions)
+                    if (TryReadStringValue(expr, out var v)) yield return v;
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static IEnumerable<string> GetNamedArgumentStrings(this AttributeSyntax attr, string name)
+    {
+        if (attr.ArgumentList is not { Arguments.Count: > 0 }) yield break;
+        foreach (var arg in attr.ArgumentList.Arguments)
+        {
+            if (arg.NameEquals?.Name.Identifier.Text != name) continue;
+            var expr = arg.Expression;
+            if (TryReadStringValue(expr, out var value))
+            {
+                yield return value;
+                continue;
+            }
+            if (expr is ArrayCreationExpressionSyntax acs && acs.Initializer is not null)
+            {
+                foreach (var item in acs.Initializer.Expressions)
+                    if (TryReadStringValue(item, out var v)) yield return v;
+            }
+            else if (expr is ImplicitArrayCreationExpressionSyntax iacs && iacs.Initializer is not null)
+            {
+                foreach (var item in iacs.Initializer.Expressions)
+                    if (TryReadStringValue(item, out var v)) yield return v;
+            }
+            else if (expr is InitializerExpressionSyntax init)
+            {
+                foreach (var item in init.Expressions)
+                    if (TryReadStringValue(item, out var v)) yield return v;
+            }
+        }
+    }
+
+    /// <summary>
+    /// <para>
+    ///     Attempts to extract a string value from the specified expression syntax node.
+    /// </para>
+    /// </summary>
+    /// <remarks>
+    ///     This method supports string literal expressions and 'nameof' invocations with a single argument.
+    ///     For unsupported expression types, the method returns false and sets <paramref name="value"/>
+    ///     to an empty string.
+    /// </remarks>
+    /// <param name="expr">
+    ///     The expression syntax node to analyze for a string value.
+    ///     Supported expressions include string literals and 'nameof' invocations.
+    /// </param>
+    /// <param name="value">
+    ///     When this method returns <see langword="true"/>, contains the extracted string value; 
+    ///     otherwise, contains an empty string.
+    /// </param>
+    /// <returns>
+    ///     true if a string value was successfully extracted from the expression; otherwise, false.
+    /// </returns>
+    public static bool TryReadStringValue(this ExpressionSyntax expr, out string value)
+    {
+        switch (expr)
+        {
+            case LiteralExpressionSyntax { Token.Value: string s }:
+                value = s; return true;
+            case InvocationExpressionSyntax { Expression: IdentifierNameSyntax id } inv when id.Identifier.Text == "nameof":
+                if (inv.ArgumentList.Arguments.Count == 1)
+                {
+                    var inner = inv.ArgumentList.Arguments[0].Expression;
+                    if (inner is IdentifierNameSyntax ins)
+                    {
+                        value = ins.Identifier.Text; return true;
+                    }
+                    else if (inner is MemberAccessExpressionSyntax ma)
+                    {
+                        value = ma.Name.Identifier.Text; return true;
+                    }
+                }
+                break;
+        }
+        value = string.Empty; return false;
+    }
 }

RoyalCode.Utils/RoyalCode.Extensions.SourceGenerator/RoyalCode.Extensions.SourceGenerator.csproj

@@ -6,7 +6,7 @@
 		<TargetFramework>netstandard2.0</TargetFramework>
 		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 
-		<Ver>0.1.7</Ver>
+		<Ver>0.1.8</Ver>
 		<Prev></Prev>
 
 		<Version>$(Ver)$(Prev)</Version>