Implement warning when non-abstract classes containing abstract members invisible from that classes

#KT-27825 fixed

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -512,7 +512,10 @@ public interface Errors {
             DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
     DiagnosticFactory2<KtClassOrObject, KtClassOrObject, CallableMemberDescriptor> MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED =
             DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
-
+    DiagnosticFactory2<KtClassOrObject, ClassDescriptor, Collection<CallableMemberDescriptor>> INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER =
+            DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
+    DiagnosticFactory2<KtClassOrObject, ClassDescriptor, Collection<CallableMemberDescriptor>> INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING =
+            DiagnosticFactory2.create(WARNING, DECLARATION_NAME);
 
     DiagnosticFactory1<KtDeclaration, Collection<KotlinType>> AMBIGUOUS_ANONYMOUS_TYPE_INFERRED =
             DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -805,6 +805,8 @@ public class DefaultErrorMessages {
                 RENDER_CLASS_OR_OBJECT, FQ_NAMES_IN_TYPES);
         MAP.put(MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED, "{0} must override {1} because it inherits multiple interface methods of it",
                 RENDER_CLASS_OR_OBJECT, FQ_NAMES_IN_TYPES);
+        MAP.put(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER, "{0} inherits invisible abstract members: {1}", NAME, commaSeparated(FQ_NAMES_IN_TYPES));
+        MAP.put(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING, "{0} inherits invisible abstract members: {1}", NAME, commaSeparated(FQ_NAMES_IN_TYPES));
 
         MAP.put(CONFLICTING_OVERLOADS, "Conflicting overloads: {0}", commaSeparated(FQ_NAMES_IN_TYPES));
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt

@@ -85,6 +85,7 @@ class OverrideResolver(
         fun multipleImplementationsMemberNotImplemented(descriptor: CallableMemberDescriptor)
         fun conflictingInterfaceMemberNotImplemented(descriptor: CallableMemberDescriptor)
         fun typeMismatchOnInheritance(descriptor1: CallableMemberDescriptor, descriptor2: CallableMemberDescriptor)
+        fun abstractInvisibleMember(descriptor: CallableMemberDescriptor)
     }
 
     private class CollectMissingImplementationsStrategy : CheckInheritedSignaturesReportStrategy {
@@ -112,6 +113,10 @@ class OverrideResolver(
             // don't care
         }
 
+        override fun abstractInvisibleMember(descriptor: CallableMemberDescriptor) {
+            // don't care
+        }
+
         override fun abstractMemberWithMoreSpecificType(
             abstractMember: CallableMemberDescriptor,
             concreteMember: CallableMemberDescriptor
@@ -127,6 +132,7 @@ class OverrideResolver(
 
         private val abstractNoImpl = linkedSetOf<CallableMemberDescriptor>()
         private val abstractInBaseClassNoImpl = linkedSetOf<CallableMemberDescriptor>()
+        private val abstractInvisibleSuper = linkedSetOf<CallableMemberDescriptor>()
         private val multipleImplementations = linkedSetOf<CallableMemberDescriptor>()
         private val conflictingInterfaceMembers = linkedSetOf<CallableMemberDescriptor>()
         private val conflictingReturnTypes = linkedSetOf<CallableMemberDescriptor>()
@@ -164,6 +170,10 @@ class OverrideResolver(
             }
         }
 
+        override fun abstractInvisibleMember(descriptor: CallableMemberDescriptor) {
+            abstractInvisibleSuper.add(descriptor)
+        }
+
         override fun abstractMemberWithMoreSpecificType(
             abstractMember: CallableMemberDescriptor,
             concreteMember: CallableMemberDescriptor
@@ -232,6 +242,14 @@ class OverrideResolver(
                 trace.report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(klass, klass, abstractNoImpl.first()))
             }
 
+            if (abstractInvisibleSuper.isNotEmpty() && !canHaveAbstractMembers) {
+                if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitInvisibleAbstractMethodsInSuperclasses)) {
+                    trace.report(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER.on(klass, classDescriptor, abstractInvisibleSuper))
+                } else {
+                    trace.report(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING.on(klass, classDescriptor, abstractInvisibleSuper))
+                }
+            }
+
             conflictingInterfaceMembers.removeAll(conflictingReturnTypes)
             multipleImplementations.removeAll(conflictingReturnTypes)
             if (!conflictingInterfaceMembers.isEmpty()) {
@@ -566,7 +584,6 @@ class OverrideResolver(
         ) {
             val kind = descriptor.kind
             if (kind != FAKE_OVERRIDE && kind != DELEGATION) return
-            if (descriptor.visibility === Visibilities.INVISIBLE_FAKE) return
 
             val directOverridden = descriptor.overriddenDescriptors
             assert(!directOverridden.isEmpty()) { kind.toString() + " " + descriptor.name.asString() + " must override something" }
@@ -584,6 +601,11 @@ class OverrideResolver(
             val relevantDirectlyOverridden =
                 getRelevantDirectlyOverridden(overriddenDeclarationsByDirectParent, allFilteredOverriddenDeclarations)
 
+            if (descriptor.visibility === Visibilities.INVISIBLE_FAKE) {
+                checkInvisibleFakeOverride(descriptor, relevantDirectlyOverridden, reportingStrategy)
+                return
+            }
+
             checkInheritedDescriptorsGroup(descriptor, relevantDirectlyOverridden, reportingStrategy)
 
             if (kind == DELEGATION && overrideReportStrategyForDelegates != null) {
@@ -621,6 +643,23 @@ class OverrideResolver(
             }
         }
 
+        private fun checkInvisibleFakeOverride(
+            descriptor: CallableMemberDescriptor,
+            overriddenDescriptors: Collection<CallableMemberDescriptor>,
+            reportingStrategy: CheckInheritedSignaturesReportStrategy
+        ) {
+            // the checks below are only relevant for non-abstract classes or objects
+            if ((descriptor.containingDeclaration as? ClassDescriptor)?.modality === Modality.ABSTRACT) return
+
+            val abstractOverrides = overriddenDescriptors.filter { it.modality === Modality.ABSTRACT }
+
+            if (abstractOverrides.size != overriddenDescriptors.size) return // has non-abstract override
+
+            for (override in abstractOverrides) {
+                reportingStrategy.abstractInvisibleMember(override)
+            }
+        }
+
         private fun checkMissingOverridesByJava8Restrictions(
             relevantDirectlyOverridden: Set<CallableMemberDescriptor>,
             reportingStrategy: CheckInheritedSignaturesReportStrategy