[C#] 型が同一アセンブリ内 internal アクセスできるか判定する

namespace AccessibilityClassLibrary1
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Enum)]
    public class TypeAccessibilityAttribute : Attribute
    {
        public Accessibility Accessibility { get; }
        public bool IsPublic => Accessibility == Accessibility.Public;
        public bool IsInternal => Accessibility == Accessibility.Internal;
        public TypeAccessibilityAttribute(Accessibility accessibility = Accessibility.None)
        {
            Accessibility = accessibility;
        }
    }

    public enum Accessibility
    {
        None,
        // Private,
        Public,
        // Protected,
        Internal,
        // ProtectedOrInternal,
        // ProtectedAndInternal,
    }

    public static class AccessibilityExtensions
    {
        public static bool IsInternalVisible(this Type type)
        {
            return type.GetAccessibility() == Accessibility.Internal;
        }

        public static Accessibility GetAccessibility(this Type type)
        {
            // public
            if (type.IsVisible)
                return Accessibility.Public;

            // public or internal
            var accessibility = GetCore(type);
            if (accessibility == Accessibility.None)
                return Accessibility.None;

            if (!type.IsNested)
                return accessibility;

            // Nested
            var declaringType = type.DeclaringType;
            while (declaringType is not null)
            {
                accessibility = GetCore(declaringType) switch
                {
                    Accessibility.Public => accessibility,
                    Accessibility.Internal => Accessibility.Internal,
                    _ => Accessibility.None,
                };

                if (accessibility == Accessibility.None)
                    return Accessibility.None;

                declaringType = declaringType.DeclaringType;
            }

            return accessibility;

            static Accessibility GetCore(Type type)
            {
                if (type.IsPublic || type.IsNestedPublic)
                    return Accessibility.Public;

                if (type.IsNotPublic || type.IsNestedAssembly || type.IsNestedFamORAssem)
                    return Accessibility.Internal;

                return Accessibility.None;
            }
        }
    }
}

[TypeAccessibility(Accessibility.Public)]
public enum RootPublicEnum
{
}
[TypeAccessibility(Accessibility.Internal)]
internal enum RootInternalEnum
{
}

[TypeAccessibility(Accessibility.Public)]
public class RootPublicClass
{
    [TypeAccessibility(Accessibility.Public)]
    public enum PublicEnumNested
    {
    }

    [TypeAccessibility(Accessibility.Internal)]
    internal enum InternalEnumNested
    {
    }

    [TypeAccessibility(Accessibility.Public)]
    public class PublicNestedClass
    {
        [TypeAccessibility(Accessibility.Public)] public interface IPublicNested { }
        [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
    }

    protected class ProtectedNestedClass
    {
        public interface IPublicNested { }
        internal interface IInternalNested { }
    }

    [TypeAccessibility(Accessibility.Internal)]
    protected internal class ProtectedInternalNestedClass
    {
        [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
        [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
    }

    [TypeAccessibility(Accessibility.Internal)]
    internal class InternalNestedClass
    {
        [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
        [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
    }

    private protected class PrivateProtectedNestedClass
    {
        public interface IPublicNested { }
        internal interface IInternalNested { }
    }

    private class PrivateNestedClass
    {
        public interface IPublicNested { }
        internal interface IInternalNested { }
    }
}

[TypeAccessibility(Accessibility.Internal)]
internal class RootInternalClass
{
    [TypeAccessibility(Accessibility.Internal)]
    public enum PublicEnumNested
    {
    }

    [TypeAccessibility(Accessibility.Internal)]
    internal enum InternalEnumNested
    {
    }

    [TypeAccessibility(Accessibility.Internal)]
    public class PublicNestedClass
    {
        [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
        [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
    }

    protected class ProtectedNestedClass
    {
        public interface IPublicNested { }
        internal interface IInternalNested { }
    }

    [TypeAccessibility(Accessibility.Internal)]
    protected internal class ProtectedInternalNestedClass
    {
        [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
        [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
    }

    [TypeAccessibility(Accessibility.Internal)]
    internal class InternalNestedClass
    {
        [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
        [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
    }

    private protected class PrivateProtectedNestedClass
    {
        public interface IPublicNested { }
        internal interface IInternalNested { }
    }

    private class PrivateNestedClass
    {
        public interface IPublicNested { }
        internal interface IInternalNested { }
    }
}

namespace My
{
    [TypeAccessibility(Accessibility.Public)]
    public enum PublicEnumNested
    {
    }

    [TypeAccessibility(Accessibility.Internal)]
    internal enum InternalEnumNested
    {
    }

    [TypeAccessibility(Accessibility.Public)]
    public class MyPublicClass
    {
        [TypeAccessibility(Accessibility.Public)]
        public class PublicNestedClass
        {
            [TypeAccessibility(Accessibility.Public)] public interface IPublicNested { }
            [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
        }

        protected class ProtectedNestedClass
        {
            public interface IPublicNested { }
            internal interface IInternalNested { }
        }

        [TypeAccessibility(Accessibility.Internal)]
        protected internal class ProtectedInternalNestedClass
        {
            [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
            [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
        }

        [TypeAccessibility(Accessibility.Internal)]
        internal class InternalNestedClass
        {
            [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
            [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
        }

        private protected class PrivateProtectedNestedClass
        {
            public interface IPublicNested { }
            internal interface IInternalNested { }
        }

        private class PrivateNestedClass
        {
            public interface IPublicNested { }
            internal interface IInternalNested { }
        }

        [TypeAccessibility(Accessibility.Public)] public enum PublicEnumNested { }
        [TypeAccessibility(Accessibility.Internal)] internal enum InternalEnumNested { }
    }

    [TypeAccessibility(Accessibility.Internal)]
    internal class MyInternalClass
    {
        [TypeAccessibility(Accessibility.Internal)]
        public class PublicNestedClass
        {
            [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
            [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
        }

        protected class ProtectedNestedClass
        {
            public interface IPublicNested { }
            internal interface IInternalNested { }
        }

        [TypeAccessibility(Accessibility.Internal)]
        protected internal class ProtectedInternalNestedClass
        {
            [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
            [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
        }

        [TypeAccessibility(Accessibility.Internal)]
        internal class InternalNestedClass
        {
            [TypeAccessibility(Accessibility.Internal)] public interface IPublicNested { }
            [TypeAccessibility(Accessibility.Internal)] internal interface IInternalNested { }
        }

        private protected class PrivateProtectedNestedClass
        {
            public interface IPublicNested { }
            internal interface IInternalNested { }
        }

        private class PrivateNestedClass
        {
            public interface IPublicNested { }
            internal interface IInternalNested { }
        }

        [TypeAccessibility(Accessibility.Internal)] public enum PublicEnumNested { }
        [TypeAccessibility(Accessibility.Internal)] internal enum InternalEnumNested { }
    }
}

void Main()
{
    var exportedTypes = typeof(TypeAccessibilityAttribute).Assembly.GetExportedTypes().ToHashSet();

    typeof(TypeAccessibilityAttribute).Assembly
        .GetTypes()
        .Where(x => x.FullName.StartsWith("My") || x.FullName.StartsWith("Root"))
        .Select(t =>
        {
            var info = t.GetTypeInfo();
            return new
            {
                t.FullName,
                Aacessibility = GetAccessibility(t)?.Accessibility.ToString() ?? "",
                GetAacessibility = t.GetAccessibility(),
                IsExported = exportedTypes.Contains(t),
                t.IsVisible,
                t.IsPublic,
                t.IsNotPublic,
                t.IsNested,
                t.IsNestedPublic,
                t.IsNestedFamily,
                t.IsNestedPrivate,
                t.IsNestedAssembly,
                t.IsNestedFamORAssem,
                t.IsNestedFamANDAssem,
                t.Attributes,
            };
        })
        .OrderBy(x => x.FullName)
        .Dump();
}

TypeAccessibilityAttribute? GetAccessibility(Type type)
{
    return type.GetCustomAttribute<TypeAccessibilityAttribute>();
}