Skip containing type accessibility check when resolving overridden members

src/Compilers/CSharp/Portable/Binder/Semantics/AccessCheck.cs

@@ -38,10 +38,11 @@
             Symbol symbol,
             NamedTypeSymbol within,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo,
-            TypeSymbol throughTypeOpt = null)
+            TypeSymbol throughTypeOpt = null,
+            bool skipContainingTypeCheck = false)
         {
             bool failedThroughTypeCheck;
-            return IsSymbolAccessibleCore(symbol, within, throughTypeOpt, out failedThroughTypeCheck, within.DeclaringCompilation, ref useSiteInfo);
+            return IsSymbolAccessibleCore(symbol, within, throughTypeOpt, out failedThroughTypeCheck, within.DeclaringCompilation, ref useSiteInfo, basesBeingResolved: null, skipContainingTypeCheck);
         }
 
         /// <summary>
@@ -55,9 +56,10 @@
             TypeSymbol throughTypeOpt,
             out bool failedThroughTypeCheck,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo,
-            ConsList<TypeSymbol> basesBeingResolved = null)
+            ConsList<TypeSymbol> basesBeingResolved = null,
+            bool skipContainingTypeCheck = false)
         {
-            return IsSymbolAccessibleCore(symbol, within, throughTypeOpt, out failedThroughTypeCheck, within.DeclaringCompilation, ref useSiteInfo, basesBeingResolved);
+            return IsSymbolAccessibleCore(symbol, within, throughTypeOpt, out failedThroughTypeCheck, within.DeclaringCompilation, ref useSiteInfo, basesBeingResolved, skipContainingTypeCheck);
         }
 
         /// <summary>
@@ -137,7 +139,8 @@
             out bool failedThroughTypeCheck,
             CSharpCompilation compilation,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo,
-            ConsList<TypeSymbol> basesBeingResolved = null)
+            ConsList<TypeSymbol> basesBeingResolved = null,
+            bool skipContainingTypeCheck = false)
         {
             Debug.Assert((object)symbol != null);
             Debug.Assert((object)within != null);
@@ -209,7 +212,7 @@
                         throughTypeOpt = null;
                     }
 
-                    return IsMemberAccessible(symbol.ContainingType, symbol.DeclaredAccessibility, within, throughTypeOpt, out failedThroughTypeCheck, compilation, ref useSiteInfo);
+                    return IsMemberAccessible(symbol.ContainingType, symbol.DeclaredAccessibility, within, throughTypeOpt, out failedThroughTypeCheck, compilation, ref useSiteInfo, basesBeingResolved, skipContainingTypeCheck);
 
                 default:
                     throw ExceptionUtilities.UnexpectedValue(symbol.Kind);
@@ -302,7 +305,8 @@
             out bool failedThroughTypeCheck,
             CSharpCompilation compilation,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo,
-            ConsList<TypeSymbol> basesBeingResolved = null)
+            ConsList<TypeSymbol> basesBeingResolved = null,
+            bool skipContainingTypeCheck = false)
         {
             Debug.Assert(within is NamedTypeSymbol || within is AssemblySymbol);
             Debug.Assert((object)containingType != null);
@@ -316,7 +320,9 @@
             }
 
             // A nested symbol is only accessible to us if its container is accessible as well.
-            if (!IsNamedTypeAccessible(containingType, within, ref useSiteInfo, basesBeingResolved))
+            // Skip this check when checking overridden members, as the containing type could have
+            // type arguments from unrelated assemblies.
+            if (!skipContainingTypeCheck && !IsNamedTypeAccessible(containingType, within, ref useSiteInfo, basesBeingResolved))
             {
                 return false;
             }
@@ -336,7 +342,8 @@
                 out failedThroughTypeCheck,
                 compilation,
                 ref useSiteInfo,
-                basesBeingResolved);
+                basesBeingResolved,
+                skipContainingTypeCheck);
         }
 
         private static bool IsNonPublicMemberAccessible(
@@ -347,7 +354,8 @@
             out bool failedThroughTypeCheck,
             CSharpCompilation compilation,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo,
-            ConsList<TypeSymbol> basesBeingResolved = null)
+            ConsList<TypeSymbol> basesBeingResolved = null,
+            bool skipContainingTypeCheck = false)
         {
             failedThroughTypeCheck = false;
 

src/Compilers/CSharp/Portable/Symbols/EventSymbol.cs

@@ -194,7 +194,7 @@ internal EventSymbol GetLeastOverriddenEvent(NamedTypeSymbol? accessingTypeOpt)
                 EventSymbol? overridden = e.OverriddenEvent;
                 var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
                 if ((object?)overridden == null ||
-                    (accessingTypeOpt is { } && !AccessCheck.IsSymbolAccessible(overridden, accessingTypeOpt, ref discardedUseSiteInfo)))
+                    (accessingTypeOpt is { } && !AccessCheck.IsSymbolAccessible(overridden, accessingTypeOpt, ref discardedUseSiteInfo, skipContainingTypeCheck: true)))
                 {
                     break;
                 }

src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs

@@ -457,7 +457,7 @@ private MethodSymbol GetLeastOverriddenMethodCore(NamedTypeSymbol accessingTypeO
                 MethodSymbol overridden = m.OverriddenMethod;
                 var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
                 if ((object)overridden == null ||
-                    (accessingTypeOpt is { } && !AccessCheck.IsSymbolAccessible(overridden, accessingTypeOpt, ref discardedUseSiteInfo)) ||
+                    (accessingTypeOpt is { } && !AccessCheck.IsSymbolAccessible(overridden, accessingTypeOpt, ref discardedUseSiteInfo, skipContainingTypeCheck: true)) ||
                     (requireSameReturnType && !this.ReturnType.Equals(overridden.ReturnType, TypeCompareKind.AllIgnoreOptions)))
                 {
                     break;

src/Compilers/CSharp/Portable/Symbols/PropertySymbol.cs

@@ -290,7 +290,7 @@ internal PropertySymbol GetLeastOverriddenProperty(NamedTypeSymbol accessingType
                 PropertySymbol overridden = p.OverriddenProperty;
                 var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
                 if ((object)overridden == null ||
-                    (accessingTypeOpt is { } && !AccessCheck.IsSymbolAccessible(overridden, accessingTypeOpt, ref discardedUseSiteInfo)))
+                    (accessingTypeOpt is { } && !AccessCheck.IsSymbolAccessible(overridden, accessingTypeOpt, ref discardedUseSiteInfo, skipContainingTypeCheck: true)))
                 {
                     break;
                 }

src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs

@@ -3096,5 +3096,50 @@ static void validate(ModuleSymbol m)
                     m.GlobalNamespace.GetMember("Test1.<P1>k__BackingField").GetAttributes().Select(a => a.ToString()));
             }
         }
+
+        [Fact]
+        public void PropertyIsReadOnly_WithTypeArgumentFromUnrelatedAssembly()
+        {
+            // This test verifies that checking PropertySymbol.IsReadOnly doesn't trigger
+            // an assertion when the containing type has type arguments from unrelated assemblies.
+            // Based on issue #81937 pattern where overridden members cause accessibility checks
+            // on type arguments that may be from unrelated assemblies.
+            string source1 = """
+                public class C0<T>
+                {
+                    public virtual int P { get; set; }
+                }
+
+                public class C1<T> : C0<T>
+                {
+                    public override int P { get; set; }
+                }
+                """;
+            var comp1 = CreateCompilation(source1);
+            comp1.VerifyDiagnostics();
+
+            string source2 = """
+                internal class C2 { }
+
+                internal class C3 : C1<C2>
+                {
+                    public override int P { get; set; }
+                }
+                """;
+
+            var comp2 = CreateCompilation(source2, references: [comp1.ToMetadataReference()]);
+            comp2.VerifyDiagnostics();
+
+            // Get the property symbol and check IsReadOnly
+            var c3 = comp2.GlobalNamespace.GetTypeMember("C3");
+            var property = c3.GetMember<PropertySymbol>("P");
+
+            // This should not throw an assertion
+            var isReadOnly = property.IsReadOnly;
+            Assert.False(isReadOnly);
+
+            var isWriteOnly = property.IsWriteOnly;
+            Assert.False(isWriteOnly);
+        }
     }
 }