[FIR] Check conflicts between nested classes' constructors and member functions

For an example of an object with
an implicit primary constructor,
see `FirPsiOldFrontendDiagnosticsTestGenerated.testSingletonAndFunctionSameName`.

^KT-62005 Fixed


Merge-request: KT-MR-12242
Merged-by: Nikolay Lunyak <Nikolay.Lunyak@jetbrains.com>

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java

@@ -825,6 +825,12 @@ public class DiagnosticCompilerTestFE10TestdataTestGenerated extends AbstractDia
             runTest("compiler/testData/diagnostics/tests/NamedFunctionTypeParameterInSupertype.kt");
         }
 
+        @Test
+        @TestMetadata("nestedClassConstructorVsMemberFunctionConflict.kt")
+        public void testNestedClassConstructorVsMemberFunctionConflict() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/nestedClassConstructorVsMemberFunctionConflict.kt");
+        }
+
         @Test
         @TestMetadata("noLibraryProvidersDuplication.kt")
         public void testNoLibraryProvidersDuplication() throws Exception {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java

@@ -825,6 +825,12 @@ public class LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated
             runTest("compiler/testData/diagnostics/tests/NamedFunctionTypeParameterInSupertype.kt");
         }
 
+        @Test
+        @TestMetadata("nestedClassConstructorVsMemberFunctionConflict.kt")
+        public void testNestedClassConstructorVsMemberFunctionConflict() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/nestedClassConstructorVsMemberFunctionConflict.kt");
+        }
+
         @Test
         @TestMetadata("noLibraryProvidersDuplication.kt")
         public void testNoLibraryProvidersDuplication() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java

@@ -825,6 +825,12 @@ public class FirLightTreeOldFrontendDiagnosticsTestGenerated extends AbstractFir
             runTest("compiler/testData/diagnostics/tests/NamedFunctionTypeParameterInSupertype.kt");
         }
 
+        @Test
+        @TestMetadata("nestedClassConstructorVsMemberFunctionConflict.kt")
+        public void testNestedClassConstructorVsMemberFunctionConflict() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/nestedClassConstructorVsMemberFunctionConflict.kt");
+        }
+
         @Test
         @TestMetadata("noLibraryProvidersDuplication.kt")
         public void testNoLibraryProvidersDuplication() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java

@@ -825,6 +825,12 @@ public class FirPsiOldFrontendDiagnosticsTestGenerated extends AbstractFirPsiDia
             runTest("compiler/testData/diagnostics/tests/NamedFunctionTypeParameterInSupertype.kt");
         }
 
+        @Test
+        @TestMetadata("nestedClassConstructorVsMemberFunctionConflict.kt")
+        public void testNestedClassConstructorVsMemberFunctionConflict() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/nestedClassConstructorVsMemberFunctionConflict.kt");
+        }
+
         @Test
         @TestMetadata("noLibraryProvidersDuplication.kt")
         public void testNoLibraryProvidersDuplication() throws Exception {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConflictsHelpers.kt

@@ -159,7 +159,20 @@ fun FirDeclarationCollector<FirBasedSymbol<*>>.collectClassMembers(klass: FirReg
 
         when (it) {
             is FirSimpleFunction -> collect(it.symbol, FirRedeclarationPresenter.represent(it.symbol), functionDeclarations)
-            is FirRegularClass -> collect(it.symbol, FirRedeclarationPresenter.represent(it.symbol), otherDeclarations)
+            is FirRegularClass -> {
+                collect(it.symbol, FirRedeclarationPresenter.represent(it.symbol), otherDeclarations)
+
+                // Objects have implicit FirPrimaryConstructors
+                if (it.symbol.classKind == ClassKind.OBJECT) {
+                    continue
+                }
+
+                it.symbol.expandedClassWithConstructorsScope(context)?.let { (_, scopeWithConstructors) ->
+                    scopeWithConstructors.processDeclaredConstructors { constructor ->
+                        collect(constructor, FirRedeclarationPresenter.represent(constructor, it.symbol), functionDeclarations)
+                    }
+                }
+            }
             is FirTypeAlias -> collect(it.symbol, FirRedeclarationPresenter.represent(it.symbol), otherDeclarations)
             is FirVariable -> collect(it.symbol, FirRedeclarationPresenter.represent(it.symbol), otherDeclarations)
             else -> {}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsDeclarationChecker.kt

@@ -59,7 +59,13 @@ object FirConflictsDeclarationChecker : FirBasicDeclarationChecker() {
         declarationConflictingSymbols.forEach { (conflictingDeclaration, symbols) ->
             val typeAliasForConstructorSource = (conflictingDeclaration as? FirConstructorSymbol)?.typeAliasForConstructor?.source
             val source = typeAliasForConstructorSource ?: conflictingDeclaration.source
-            if (symbols.isEmpty()) return@forEach
+            if (
+                symbols.isEmpty() ||
+                // For every implicit constructor there is a parent,
+                // FirRegularClass declaration, and those clash too,
+                // resulting in REDECLARATION.
+                conflictingDeclaration.isImplicitConstructor && symbols.all { it.isImplicitConstructor }
+            ) return@forEach
 
             val factory =
                 if (conflictingDeclaration is FirNamedFunctionSymbol || conflictingDeclaration is FirConstructorSymbol) {
@@ -77,6 +83,8 @@ object FirConflictsDeclarationChecker : FirBasicDeclarationChecker() {
         }
     }
 
+    private val FirBasedSymbol<*>.isImplicitConstructor get() = source?.kind is KtFakeSourceElementKind.ImplicitConstructor
+
     private fun checkFile(file: FirFile, inspector: FirDeclarationCollector<FirBasedSymbol<*>>, context: CheckerContext) {
         val packageMemberScope: FirPackageMemberScope = context.sessionHolder.scopeSession.getOrBuild(file.packageFqName, PACKAGE_MEMBER) {
             FirPackageMemberScope(file.packageFqName, context.sessionHolder.session)

compiler/testData/diagnostics/tests/nestedClassConstructorVsMemberFunctionConflict.kt

@@ -0,0 +1,10 @@
+// FIR_IDENTICAL
+// ISSUE: KT-62005
+
+class A {
+    class NestedInA<!CONFLICTING_OVERLOADS!>()<!>
+    <!CONFLICTING_OVERLOADS!>fun NestedInA()<!> {}
+
+    class <!CONFLICTING_OVERLOADS!>NestedInA2<!>
+    <!CONFLICTING_OVERLOADS!>fun NestedInA2()<!> {}
+}

compiler/testData/diagnostics/tests/overload/ConstructorVsFunOverload.fir.kt

@@ -15,16 +15,16 @@ class a<!CONFLICTING_OVERLOADS!>()<!> { }
 <!CONFLICTING_OVERLOADS!>fun a()<!> = 1
 
 class Tram {
-    fun f() { }
+    <!CONFLICTING_OVERLOADS!>fun f()<!> { }
 
-    class f() { }
+    class f<!CONFLICTING_OVERLOADS!>()<!> { }
 }
 
 class Yvayva {
     companion object {
-        fun fghj() { }
+        <!CONFLICTING_OVERLOADS!>fun fghj()<!> { }
 
-        class fghj() { }
+        class fghj<!CONFLICTING_OVERLOADS!>()<!> { }
     }
 }
 

compiler/testData/diagnostics/tests/redeclarations/kt2438.kt

@@ -7,6 +7,10 @@ package kt2438
 class B {
     class <!REDECLARATION!>C<!>
     class <!REDECLARATION!>C<!>
+
+    class <!CONFLICTING_OVERLOADS, REDECLARATION!>D<!>
+    class <!CONFLICTING_OVERLOADS, REDECLARATION!>D<!>
+    <!CONFLICTING_OVERLOADS!>fun D()<!> {}
 }
 
 

compiler/testData/diagnostics/tests/redeclarations/kt2438.txt

@@ -46,6 +46,7 @@ package kt2438 {
 
     public final class B {
         public constructor B()
+        public final fun D(): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -63,5 +64,20 @@ package kt2438 {
             public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
             public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
         }
+
+        public final class D {
+            public constructor D()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+
+        public final class D {
+            public constructor D()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
     }
 }
+

compiler/testData/diagnostics/tests/secondaryConstructors/redeclarations.fir.kt

@@ -13,15 +13,15 @@ class B {
 <!CONFLICTING_OVERLOADS!>fun B(x: Int)<!> {}
 
 class Outer {
-    class A(x: String = "", y: String = "") {
+    class A<!CONFLICTING_OVERLOADS!>(x: String = "", y: String = "")<!> {
-        constructor(x: String, y: String): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>(x, y)
+        <!CONFLICTING_OVERLOADS!>constructor(x: String, y: String)<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>(x, y)
-        constructor(): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
+        <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
-        constructor(): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
+        <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
     }
 
     class B {
-        constructor(x: Int)
+        <!CONFLICTING_OVERLOADS!>constructor(x: Int)<!>
     }
 
-    fun B(x: Int) {}
+    <!CONFLICTING_OVERLOADS!>fun B(x: Int)<!> {}
 }

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -825,6 +825,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
             runTest("compiler/testData/diagnostics/tests/NamedFunctionTypeParameterInSupertype.kt");
         }
 
+        @Test
+        @TestMetadata("nestedClassConstructorVsMemberFunctionConflict.kt")
+        public void testNestedClassConstructorVsMemberFunctionConflict() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/nestedClassConstructorVsMemberFunctionConflict.kt");
+        }
+
         @Test
         @TestMetadata("noLibraryProvidersDuplication.kt")
         public void testNoLibraryProvidersDuplication() throws Exception {