Unify visible member resolution algorithm and disallow conflicting member names. (#301)

Author: eiriktsarpalis

src/PolyType.Roslyn/Helpers/RoslynHelpers.cs

@@ -367,61 +367,65 @@ public static ICollection<ITypeSymbol> GetSortedTypeHierarchy(this ITypeSymbol t
         }
     }
 
-    public static IEnumerable<ISymbol> GetAllMembers(this ITypeSymbol type)
-        => type.GetSortedTypeHierarchy().SelectMany(t => t.GetMembers());
-
-    public static IEnumerable<(IMethodSymbol Symbol, bool IsAmbiguous)> GetAllMethods(this ITypeSymbol type)
+    /// <summary>
+    /// Resolves all members that are visible on the specified type,
+    /// accounting for overrides and shadowing in the type hierarchy.
+    /// </summary>
+    public static IEnumerable<(ISymbol Symbol, bool IsAmbiguous)> ResolveVisibleMembers(this ITypeSymbol type)
     {
-        List<(IMethodSymbol Symbol, bool IsAmbiguous)> methods = [];
-        Dictionary<string, int> foundSignatures = new();
+        Dictionary<string, List<int>> membersInScope = new(StringComparer.Ordinal);
+        List<(ISymbol Symbol, bool IsAmbiguous)> results = [];
 
+        // Walk the type hierarchy, from most derived to least derived.
         foreach (ITypeSymbol current in type.GetSortedTypeHierarchy())
         {
-            foreach (IMethodSymbol method in current.GetMembers().OfType<IMethodSymbol>())
+            foreach (ISymbol member in current.GetMembers())
             {
-                // Create a signature key that includes name, parameters, and return type
-                string signature = GetMethodSignature(method);
-                if (foundSignatures.TryGetValue(signature, out int index))
+                // To account for overloads, method identifiers include the method name and parameter types but not the return type.
+                string identifier = member is IMethodSymbol method
+                    ? $"{method.Name}({string.Join(", ", method.Parameters.Select(p => p.Type.GetFullyQualifiedName()))})"
+                    : member.Name;
+
+                bool isAmbiguous;
+                if (membersInScope.TryGetValue(identifier, out List<int> conflictingMemberIndices))
                 {
-                    IMethodSymbol conflictingMethod = methods[index].Symbol;
-                    if (!current.IsAssignableFrom(conflictingMethod.ContainingType))
+                    if (conflictingMemberIndices.Exists(i => current.IsAssignableFrom(results[i].Symbol.ContainingType)))
                     {
-                        // We have a method with the same signature in an unrelated type,
-                        // due to diamond ambiguity in an interface hierarchy.
+                        continue; // Member is overridden or shadowed by a more derived type in the hierarchy.
+                    }
 
-                        Debug.Assert(type.TypeKind is TypeKind.Interface);
-                        methods[index] = (conflictingMethod, IsAmbiguous: true);
-                        methods.Add((method, IsAmbiguous: true));
+                    if (conflictingMemberIndices is [int singleIndex])
+                    {
+                        // We found our first ambiguity, update the previous entry accordingly.
+                        results[singleIndex] = (results[singleIndex].Symbol, IsAmbiguous: true);
                     }
 
-                    continue; // This method is shadowed by a derived type, skip it.
+                    // Member forms diamond ambiguity, include in case there is disambiguation on attribute configs.
+                    Debug.Assert(type.TypeKind is TypeKind.Interface);
+                    isAmbiguous = true;
+                }
+                else
+                {
+                    membersInScope[identifier] = conflictingMemberIndices = [];
+                    isAmbiguous = false;
                 }
 
-                foundSignatures.Add(signature, methods.Count);
-                methods.Add((method, IsAmbiguous: false));
+                conflictingMemberIndices.Add(results.Count);
+                results.Add((member, isAmbiguous));
             }
         }
 
-        return methods;
-
-        static string GetMethodSignature(IMethodSymbol method)
-        {
-            string parameters = string.Join(",", method.Parameters.Select(p => p.Type.ToDisplayString()));
-            return $"{method.ReturnType.ToDisplayString()} {method.Name}({parameters})";
-        }
+        return results;
     }
 
-    public static IEnumerable<IEventSymbol> GetAllEvents(this ITypeSymbol type)
+    public static IEnumerable<(TMember Symbol, bool IsAmbiguous)> ResolveVisibleMembers<TMember>(this ITypeSymbol type)
+        where TMember : ISymbol
     {
-        HashSet<string> foundNames = [];
-        foreach (ITypeSymbol current in type.GetSortedTypeHierarchy())
+        foreach ((ISymbol symbol, bool isAmbiguous) in type.ResolveVisibleMembers())
         {
-            foreach (IEventSymbol eventSymbol in current.GetMembers().OfType<IEventSymbol>())
+            if (symbol is TMember member)
             {
-                if (foundNames.Add(eventSymbol.Name))
-                {
-                    yield return eventSymbol;
-                }
+                yield return (member, isAmbiguous);
             }
         }
     }

src/PolyType.Roslyn/Model/EventDataModel.cs

@@ -16,10 +16,15 @@ public readonly struct EventDataModel
     /// The event symbol that this model represents.
     /// </summary>
     public required IEventSymbol Event { get; init; }
+
+    /// <summary>
+    /// Gets a value indicating whether the member is ambiguous due to diamond inheritance.
+    /// </summary>
+    public bool IsAmbiguous { get; init; }
 }
 
 /// <summary>
-/// A method data model wrapping an <see cref="IEventSymbol"/>.
+/// An event data model wrapping an <see cref="IEventSymbol"/>.
 /// </summary>
 public readonly struct ResolvedEventSymbol
 {
@@ -32,4 +37,9 @@ public readonly struct ResolvedEventSymbol
     /// Gets a custom name to be applied to the method, if specified.
     /// </summary>
     public string? CustomName { get; init; }
+
+    /// <summary>
+    /// Gets a value indicating whether the member is ambiguous due to diamond inheritance.
+    /// </summary>
+    public bool IsAmbiguous { get; init; }
 }

src/PolyType.Roslyn/Model/MethodDataModel.cs

@@ -36,7 +36,7 @@ public readonly struct MethodDataModel
     /// <summary>
     /// Whether the method is ambiguous due to diamond inheritance.
     /// </summary>
-    public required bool IsDiamondAmbiguous { get; init; }
+    public required bool IsAmbiguous { get; init; }
 }
 
 /// <summary>
@@ -93,5 +93,5 @@ public readonly struct ResolvedMethodSymbol
     /// <summary>
     /// Gets a value indicating whether the method is ambiguous due to diamond inheritance.
     /// </summary>
-    public bool IsDiamondAmbiguous { get; init; }
+    public bool IsAmbiguous { get; init; }
 }

src/PolyType.Roslyn/Model/PropertyDataModel.cs

@@ -50,6 +50,16 @@ public PropertyDataModel(IFieldSymbol field)
     /// </summary>
     public string Name => PropertySymbol.Name;
 
+    /// <summary>
+    /// A logical name overwriting the underlying name.
+    /// </summary>
+    public string? LogicalName { get; init; }
+
+    /// <summary>
+    /// The declared order of the property or field.
+    /// </summary>
+    public int Order { get; init; }
+
     /// <summary>
     /// The type exposed by this property.
     /// </summary>
@@ -104,6 +114,11 @@ public PropertyDataModel(IFieldSymbol field)
     /// </summary>
     public bool? IsRequiredByPolicy { get; init; }
 
+    /// <summary>
+    /// Gets a value indicating whether the member is ambiguous due to diamond inheritance.
+    /// </summary>
+    public bool IsAmbiguous { get; init; }
+
     /// <summary>
     /// Whether the property is init-only.
     /// </summary>
@@ -113,3 +128,39 @@ public PropertyDataModel(IFieldSymbol field)
         _ => false,
     };
 }
+
+/// <summary>
+/// A property data model wrapping an <see cref="IEventSymbol"/>.
+/// </summary>
+public readonly struct ResolvedPropertySymbol
+{
+    /// <summary>
+    /// Gets the resolved property or field symbol.
+    /// </summary>
+    public required ISymbol Symbol { get; init; }
+
+    /// <summary>
+    /// Gets a custom name to be applied to the member, if specified.
+    /// </summary>
+    public string? CustomName { get; init; }
+
+    /// <summary>
+    /// Gets a value indicating whether the getter should be included in the shape.
+    /// </summary>
+    public bool IncludeGetter { get; init; }
+
+    /// <summary>
+    /// Gets a value indicating whether the setter should be included in the shape.
+    /// </summary>
+    public bool IncludeSetter { get; init; }
+
+    /// <summary>
+    /// The declared order of the property or field.
+    /// </summary>
+    public int Order { get; init; }
+
+    /// <summary>
+    /// Gets a value indicating whether the member is ambiguous due to diamond inheritance.
+    /// </summary>
+    public bool IsAmbiguous { get; init; }
+}

src/PolyType.Roslyn/ModelGenerator/TypeDataModelGenerator.Dictionary.cs

@@ -98,11 +98,10 @@ bool ContainsInserter(ITypeSymbol type, ITypeSymbol keyType, ITypeSymbol valueTy
         {
             availableInsertionModes = DictionaryInsertionMode.None;
             bool foundContainsKey = false;
-            var instanceMethods = type.GetAllMembers()
-                .OfType<IMethodSymbol>()
-                .Where(method => method.IsStatic is false && IsAccessibleSymbol(method));
+            var instanceMethods = type.ResolveVisibleMembers<IMethodSymbol>()
+                .Where(method => method.Symbol.IsStatic is false && IsAccessibleSymbol(method.Symbol));
 
-            foreach (var method in instanceMethods)
+            foreach ((var method, _) in instanceMethods)
             {
                 if (method.Parameters is [var p1, var p2] &&
                     SymbolEqualityComparer.Default.Equals(p1.Type, keyType) &&

src/PolyType.Roslyn/ModelGenerator/TypeDataModelGenerator.Enumerable.cs

@@ -159,11 +159,10 @@ private bool TryMapEnumerable(
         IMethodSymbol? ResolveAddMethod(ITypeSymbol type, ITypeSymbol elementType, out EnumerableInsertionMode insertionMode)
         {
             insertionMode = EnumerableInsertionMode.None;
-            IMethodSymbol? result = type.GetAllMembers()
-                .OfType<IMethodSymbol>()
+            (IMethodSymbol? result, _) = type.ResolveVisibleMembers<IMethodSymbol>()
                 .FirstOrDefault(method =>
-                    method is { DeclaredAccessibility: Accessibility.Public, IsStatic: false, Name: "Add" or "Enqueue" or "Push", Parameters: [{ Type: ITypeSymbol parameterType }] } &&
-                    SymbolEqualityComparer.Default.Equals(method.Parameters[0].Type, elementType));
+                    method.Symbol is { DeclaredAccessibility: Accessibility.Public, IsStatic: false, Name: "Add" or "Enqueue" or "Push", Parameters: [{ Type: ITypeSymbol parameterType }] } &&
+                    SymbolEqualityComparer.Default.Equals(method.Symbol.Parameters[0].Type, elementType));
 
             if (result is not null)
             {