Merge pull request #89 from CommunityToolkit/dev/nullability-attributes-check

Fix conflicting generation of nullability attributes

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/Attributes/NullabilityAttributesGenerator.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Text;
+using CommunityToolkit.Mvvm.SourceGenerators.Extensions;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
 
@@ -38,7 +39,7 @@ private void AddSourceCodeIfTypeIsNotPresent(GeneratorExecutionContext context,
         // this works fine both in .NET (Core) and .NET Standard implementations, we also need to check
         // that the target types are declared as public (we assume that in this case those types are from the BCL).
         // This avoids issues on .NET Standard with Roslyn also seeing internal types from referenced assemblies.
-        if (context.Compilation.GetTypeByMetadataName(typeFullName) is { DeclaredAccessibility: Accessibility.Public })
+        if (context.Compilation.HasAccessibleTypeWithMetadataName(typeFullName))
         {
             return;
         }

CommunityToolkit.Mvvm.SourceGenerators/EmbeddedResources/NotNullAttribute.cs

@@ -6,9 +6,8 @@ namespace System.Diagnostics.CodeAnalysis
 {
     /// <summary>
     /// Specifies that an output will not be null even if the corresponding type allows it.
-    /// Specifies that an input argument was not null when the call returns.
+    /// Also specifies that an input argument was not null when the call returns.
     /// </summary>
-    /// <remarks>Internal copy from the BCL attribute.</remarks>
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
     internal sealed class NotNullAttribute : Attribute
     {

CommunityToolkit.Mvvm.SourceGenerators/EmbeddedResources/NotNullIfNotNullAttribute.cs

@@ -7,17 +7,21 @@ namespace System.Diagnostics.CodeAnalysis
     /// <summary>
     /// Specifies that the output will be non-null if the named parameter is non-null.
     /// </summary>
-    /// <remarks>Internal copy from the BCL attribute.</remarks>
     [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
     internal sealed class NotNullIfNotNullAttribute : Attribute
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="NotNullIfNotNullAttribute"/> class.
         /// </summary>
         /// <param name="parameterName"> The associated parameter name. The output will be non-null if the argument to the parameter specified is non-null.</param>
-        public NotNullIfNotNullAttribute(string parameterName) => ParameterName = parameterName;
+        public NotNullIfNotNullAttribute(string parameterName)
+        {
+            ParameterName = parameterName;
+        }
 
-        /// <summary>Gets the associated parameter name.</summary>
+        /// <summary>
+        /// Gets the associated parameter name.
+        /// </summary>
         public string ParameterName { get; }
     }
 }

CommunityToolkit.Mvvm.SourceGenerators/Extensions/AttributeDataExtensions.cs

@@ -6,7 +6,6 @@
 // more info in ThirdPartyNotices.txt in the root of the project.
 
 using System.Collections.Generic;
-using System.Diagnostics.Contracts;
 using Microsoft.CodeAnalysis;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;

CommunityToolkit.Mvvm.SourceGenerators/Extensions/CompilationExtensions.cs

@@ -0,0 +1,78 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis;
+
+namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
+
+/// <summary>
+/// Extension methods for the <see cref="Compilation"/> type.
+/// </summary>
+internal static class CompilationExtensions
+{
+    /// <summary>
+    /// <para>
+    /// Checks whether or not a type with a specified metadata name is accessible from a given <see cref="Compilation"/> instance.
+    /// </para>
+    /// <para>
+    /// This method enumerates candidate type symbols to find a match in the following order:
+    /// <list type="number">
+    ///   <item><description>
+    ///     If only one type with the given name is found within the compilation and its referenced assemblies, check its accessibility.
+    ///   </description></item>
+    ///   <item><description>
+    ///     If the current <paramref name="compilation"/> defines the symbol, check its accessibility.
+    ///   </description></item>
+    ///   <item><description>
+    ///     Otherwise, check whether the type exists and is accessible from any of the referenced assemblies.
+    ///   </description></item>
+    /// </list>
+    /// </para>
+    /// </summary>
+    /// <param name="compilation">The <see cref="Compilation"/> to consider for analysis.</param>
+    /// <param name="fullyQualifiedMetadataName">The fully-qualified metadata type name to find.</param>
+    /// <returns>Whether a type with the specified metadata name can be accessed from the given compilation.</returns>
+    public static bool HasAccessibleTypeWithMetadataName(this Compilation compilation, string fullyQualifiedMetadataName)
+    {
+        // Try to get the unique type with this name
+        INamedTypeSymbol? type = compilation.GetTypeByMetadataName(fullyQualifiedMetadataName);
+
+        // If there is only a single matching symbol, check its accessibility
+        if (type is not null)
+        {
+            return type.CanBeAccessedFrom(compilation.Assembly);
+        }
+
+        // Otherwise, try to get the unique type with this name originally defined in 'compilation'
+        type ??= compilation.Assembly.GetTypeByMetadataName(fullyQualifiedMetadataName);
+
+        if (type is not null)
+        {
+            return type.CanBeAccessedFrom(compilation.Assembly);
+        }
+
+        // Otherwise, check whether the type is defined and accessible from any of the referenced assemblies
+        foreach (IModuleSymbol module in compilation.Assembly.Modules)
+        {
+            foreach (IAssemblySymbol referencedAssembly in module.ReferencedAssemblySymbols)
+            {
+                if (referencedAssembly.GetTypeByMetadataName(fullyQualifiedMetadataName) is not INamedTypeSymbol currentType)
+                {
+                    continue;
+                }
+
+                switch (currentType.GetEffectiveAccessibility())
+                {
+                    case Accessibility.Public:
+                    case Accessibility.Internal when referencedAssembly.GivesAccessTo(compilation.Assembly):
+                        return true;
+                    default:
+                        continue;
+                }
+            }
+        }
+
+        return false;
+    }
+}

CommunityToolkit.Mvvm.SourceGenerators/Extensions/ISymbolExtensions.cs

@@ -31,4 +31,57 @@ public static bool HasFullyQualifiedName(this ISymbol symbol, string name)
     {
         return symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) == name;
     }
+
+    /// <summary>
+    /// Calculates the effective accessibility for a given symbol.
+    /// </summary>
+    /// <param name="symbol">The <see cref="ISymbol"/> instance to check.</param>
+    /// <returns>The effective accessibility for <paramref name="symbol"/>.</returns>
+    public static Accessibility GetEffectiveAccessibility(this ISymbol symbol)
+    {
+        // Start by assuming it's visible
+        Accessibility visibility = Accessibility.Public;
+
+        // Handle special cases
+        switch (symbol.Kind)
+        {
+            case SymbolKind.Alias: return Accessibility.Private;
+            case SymbolKind.Parameter: return GetEffectiveAccessibility(symbol.ContainingSymbol);
+            case SymbolKind.TypeParameter: return Accessibility.Private;
+        }
+
+        // Traverse the symbol hierarchy to determine the effective accessibility
+        while (symbol is not null && symbol.Kind != SymbolKind.Namespace)
+        {
+            switch (symbol.DeclaredAccessibility)
+            {
+                case Accessibility.NotApplicable:
+                case Accessibility.Private:
+                    return Accessibility.Private;
+                case Accessibility.Internal:
+                case Accessibility.ProtectedAndInternal:
+                    visibility = Accessibility.Internal;
+                    break;
+            }
+
+            symbol = symbol.ContainingSymbol;
+        }
+
+        return visibility;
+    }
+
+    /// <summary>
+    /// Checks whether or not a given symbol can be accessed from a specified assembly.
+    /// </summary>
+    /// <param name="symbol">The input <see cref="ISymbol"/> instance to check.</param>
+    /// <param name="assembly">The assembly to check the accessibility of <paramref name="symbol"/> for.</param>
+    /// <returns>Whether <paramref name="assembly"/> can access <paramref name="symbol"/>.</returns>
+    public static bool CanBeAccessedFrom(this ISymbol symbol, IAssemblySymbol assembly)
+    {
+        Accessibility accessibility = symbol.GetEffectiveAccessibility();
+
+        return
+            accessibility == Accessibility.Public ||
+            accessibility == Accessibility.Internal && symbol.ContainingAssembly.GivesAccessTo(assembly);
+    }
 }