Improve diagnostic quality for less accessible base type argument

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -8202,4 +8202,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_ExplicitInterfaceMemberReturnTypeMismatch" xml:space="preserve">
     <value>'{0}': return type must be '{1}' to match implemented member '{2}'</value>
   </data>
-</root>
+  <data name="ERR_BadVisBaseType" xml:space="preserve">
+    <value>Inconsistent accessibility: type '{1}' is less accessible than class '{0}' </value>
+  </data>
+</root>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2429,6 +2429,7 @@ internal enum ErrorCode
         ERR_BadSpreadInCatchFilter = 9332,
         ERR_ExplicitInterfaceMemberTypeMismatch = 9333,
         ERR_ExplicitInterfaceMemberReturnTypeMismatch = 9334,
+        ERR_BadVisBaseType = 9335,
 
         // Note: you will need to do the following after adding errors:
         //  1) Update ErrorFacts.IsBuildOnlyDiagnostic (src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs)

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -2538,6 +2538,7 @@ or ErrorCode.ERR_AttributeCannotBeAppliedManually
                 or ErrorCode.ERR_BadSpreadInCatchFilter
                 or ErrorCode.ERR_ExplicitInterfaceMemberTypeMismatch
                 or ErrorCode.ERR_ExplicitInterfaceMemberReturnTypeMismatch
+                or ErrorCode.ERR_BadVisBaseType
                     => false,
             };
 #pragma warning restore CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.

src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs

@@ -386,10 +386,20 @@ static bool containsOnlyOblivious(TypeSymbol type)
                     diagnostics.Add(ErrorCode.ERR_StaticBaseClass, baseTypeLocation, baseType, this);
                 }
 
-                if (!this.IsNoMoreVisibleThan(baseType, ref useSiteInfo))
+                var lessVisibleTypes = this.FindAllLessVisible(baseType, ref useSiteInfo);
+                foreach (var lessVisibleType in lessVisibleTypes)
                 {
-                    // Inconsistent accessibility: base class '{1}' is less accessible than class '{0}'
-                    diagnostics.Add(ErrorCode.ERR_BadVisBaseClass, baseTypeLocation, this, baseType);
+                    if (Equals(baseType, lessVisibleType, TypeCompareKind.ConsiderEverything))
+                    {
+                        // Inconsistent accessibility: base class '{1}' is less accessible than class '{0}'
+                        diagnostics.Add(ErrorCode.ERR_BadVisBaseClass, baseTypeLocation, this, lessVisibleType);
+                    }
+                    else
+                    {
+                        // Inconsistent accessibility: type '{1}' is less accessible than class '{0}'
+                        var lessVisibleTypeLocation = lessVisibleType.GetFirstLocation();
+                        diagnostics.Add(ErrorCode.ERR_BadVisBaseType, baseTypeLocation, this, lessVisibleType);
+                    }
                 }
 
                 if (baseType.HasFileLocalTypes() && !this.HasFileLocalTypes())

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

@@ -695,6 +695,41 @@ public static bool IsAtLeastAsVisibleAs(this TypeSymbol type, Symbol sym, ref Co
             }
         }
 
+        public static List<TypeSymbol> FindAllLessVisible(this TypeSymbol type, TypeSymbol sym, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        {
+            List<TypeSymbol> result = [];
+            var visitTypeData = s_visitTypeDataPool.Allocate();
+
+            try
+            {
+                visitTypeData.UseSiteInfo = useSiteInfo;
+                visitTypeData.Symbol = type;
+
+                sym.VisitType(addToResultIfLessVisibleAndContinueSearchPredicate,
+                              arg: visitTypeData,
+                              canDigThroughNullable: true); // System.Nullable is public
+
+                useSiteInfo = visitTypeData.UseSiteInfo;
+                return result;
+            }
+            finally
+            {
+                visitTypeData.UseSiteInfo = default;
+                visitTypeData.Symbol = null;
+                s_visitTypeDataPool.Free(visitTypeData);
+            }
+
+            bool addToResultIfLessVisibleAndContinueSearchPredicate(TypeSymbol type1, VisitTypeData arg, bool unused)
+            {
+                if (IsTypeLessVisibleThan(type1, arg.Symbol!, ref arg.UseSiteInfo))
+                {
+                    result.Add(type1);
+                }
+
+                return false;
+            }
+        }
+
         private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             switch (type.TypeKind)