azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR] Add diagnostic CONFLICTING_OVERLOADS & REDECLARATION

Browse Source
This commit is contained in:
Nick
2020-08-05 09:35:10 +03:00
parent 36984009e9
commit 4669e019d1
72 changed files with 681 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/testData/extendedCheckers/RedundantSetterParameterTypeChecker.kt
Vendored
+4 -4
View File
@@ -2,15 +2,15 @@
@Target(AnnotationTarget.CLASS)
annotation class Ann
var x: Int
<!REDECLARATION!>var x: Int
get() = 1
set(@Ann private x) { }
set(@Ann private x) { }<!>
var x: String = ""
<!REDECLARATION!>var x: String = ""
set(param: <!REDUNDANT_SETTER_PARAMETER_TYPE!>String<!>) {
field = "$param "
}
}<!>
class My {
var y: Int = 1
compiler/fir/analysis-tests/testData/extendedCheckers/RedundantVisibilityModifierChecker.kt
Vendored
+4 -4
View File
@@ -11,11 +11,11 @@ internal inline fun internal() {
f()
}
class C {
<!REDECLARATION!>class C {
internal val z = object {
fun foo() = 13
}
}
}<!>
class Foo2<
T1,
@@ -27,12 +27,12 @@ class Foo2<
internal inner class B<T,T2,>
}
<!REDUNDANT_VISIBILITY_MODIFIER!>public<!> class C {
<!REDECLARATION!><!REDUNDANT_VISIBILITY_MODIFIER!>public<!> class C {
<!REDUNDANT_VISIBILITY_MODIFIER!>public<!> val foo: Int = 0
<!REDUNDANT_VISIBILITY_MODIFIER!>public<!> fun bar() {}
}
}<!>
open class D {
protected open fun willRemainProtected() {
compiler/fir/analysis-tests/testData/extendedCheckers/VariableAssignmentChecker.kt
Vendored
+3 -3
View File
@@ -17,7 +17,7 @@ class LocalFreezableVar<T>(private var value: T) {
}
class C
<!REDECLARATION!>class C<!>
operator fun C.plus(a: Any): C = this
operator fun C.plusAssign(a: Any) {}
@@ -172,14 +172,14 @@ fun notAssignedWhenNotUsed(p: Int) {
var global = 1
class C {
<!REDECLARATION!>class C {
var field = 2
fun foo() {
print(field)
print(global)
}
}
}<!>
fun withDelegate() {
var s: String by Delegates.notNull()
compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt
Vendored
+68
View File
@@ -0,0 +1,68 @@
<!CONFLICTING_OVERLOADS!>fun test(x: Int) {}<!>
<!CONFLICTING_OVERLOADS!>fun test(y: Int) {}<!>
fun test() {}
fun test(z: Int, c: Char) {}
<!REDECLARATION!>open class A {
open fun rest(s: String) {}
open val u = 20
}<!>
<!REDECLARATION!>class A {
}<!>
<!REDECLARATION!>class B : A {
<!CONFLICTING_OVERLOADS!>override fun rest(s: String) {}<!>
<!CONFLICTING_OVERLOADS!>fun rest(s: String) {}<!>
fun rest(l: Long) {}
override val u = 310
}<!>
<!REDECLARATION!>interface B<!>
<!REDECLARATION!>enum class B<!>
<!REDECLARATION!>val u = 10<!>
<!REDECLARATION!>val u = 20<!>
<!REDECLARATION!>typealias TA = A<!>
<!REDECLARATION!>typealias TA = B<!>
typealias BA = A
fun <T> kek(t: T) where T : (String) -> Any?, T : Char {}
fun <T> kek(t: T) where T : () -> Boolean, T : String {}
fun <T : Int> kek(t: T) {}
fun lol(a: Array<Int>) {}
fun lol(a: Array<Boolean>) {}
<!CONFLICTING_OVERLOADS!>fun <T> mem(t: T) where T : () -> Boolean, T : String {}<!>
<!CONFLICTING_OVERLOADS!>fun <T> mem(t: T) where T : String, T : () -> Boolean {}<!>
class M {
companion <!REDECLARATION!>object<!> {}
<!REDECLARATION!>val Companion = object : Any {}<!>
}
fun B.foo() {}
class L {
fun B.foo() {}
}
fun mest()
class mest
fun() {}
private fun() {}
compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.txt
Vendored
+124
View File
@@ -0,0 +1,124 @@
FILE: conflictingOverloads.kt
public final fun test(x: R|kotlin/Int|): R|kotlin/Unit| {
}
public final fun test(y: R|kotlin/Int|): R|kotlin/Unit| {
}
public final fun test(): R|kotlin/Unit| {
}
public final fun test(z: R|kotlin/Int|, c: R|kotlin/Char|): R|kotlin/Unit| {
}
public open class A : R|kotlin/Any| {
public constructor(): R|A| {
super<R|kotlin/Any|>()
}
public open fun rest(s: R|kotlin/String|): R|kotlin/Unit| {
}
public open val u: R|kotlin/Int| = Int(20)
public get(): R|kotlin/Int|
}
public final class A : R|kotlin/Any| {
public constructor(): R|A| {
super<R|kotlin/Any|>()
}
}
public final class B : R|A| {
public constructor(): R|B| {
super<R|A|>()
}
public final override fun rest(s: R|kotlin/String|): R|kotlin/Unit| {
}
public final fun rest(s: R|kotlin/String|): R|kotlin/Unit| {
}
public final fun rest(l: R|kotlin/Long|): R|kotlin/Unit| {
}
public final override val u: R|kotlin/Int| = Int(310)
public get(): R|kotlin/Int|
}
public abstract interface B : R|kotlin/Any| {
}
public final enum class B : R|kotlin/Enum<B>| {
private constructor(): R|B| {
super<R|kotlin/Enum<B>|>()
}
public final static fun values(): R|kotlin/Array<B>| {
}
public final static fun valueOf(value: R|kotlin/String|): R|B| {
}
}
public final val u: R|kotlin/Int| = Int(10)
public get(): R|kotlin/Int|
public final val u: R|kotlin/Int| = Int(20)
public get(): R|kotlin/Int|
public final typealias TA = R|A|
public final typealias TA = R|B|
public final typealias BA = R|A|
public final fun <T : R|(kotlin/String) -> kotlin/Any?|, R|kotlin/Char|> kek(t: R|T|): R|kotlin/Unit| {
}
public final fun <T : R|() -> kotlin/Boolean|, R|kotlin/String|> kek(t: R|T|): R|kotlin/Unit| {
}
public final fun <T : R|kotlin/Int|> kek(t: R|T|): R|kotlin/Unit| {
}
public final fun lol(a: R|kotlin/Array<kotlin/Int>|): R|kotlin/Unit| {
}
public final fun lol(a: R|kotlin/Array<kotlin/Boolean>|): R|kotlin/Unit| {
}
public final fun <T : R|() -> kotlin/Boolean|, R|kotlin/String|> mem(t: R|T|): R|kotlin/Unit| {
}
public final fun <T : R|kotlin/String|, R|() -> kotlin/Boolean|> mem(t: R|T|): R|kotlin/Unit| {
}
public final class M : R|kotlin/Any| {
public constructor(): R|M| {
super<R|kotlin/Any|>()
}
public final companion object Companion : R|kotlin/Any| {
private constructor(): R|M.Companion| {
super<R|kotlin/Any|>()
}
}
public final val Companion: R|<anonymous>| = object : R|kotlin/Any| {
private constructor(): R|<anonymous>| {
super<R|kotlin/Any|>()
}
}
public get(): R|<anonymous>|
}
public final fun R|B|.foo(): R|kotlin/Unit| {
}
public final class L : R|kotlin/Any| {
public constructor(): R|L| {
super<R|kotlin/Any|>()
}
public final fun R|B|.foo(): R|kotlin/Unit| {
}
}
public final fun mest(): R|kotlin/Unit|
public final class mest : R|kotlin/Any| {
public constructor(): R|mest| {
super<R|kotlin/Any|>()
}
}
public final fun <no name provided>(): R|kotlin/Unit| {
}
private final fun <no name provided>(): R|kotlin/Unit| {
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt
Vendored
+2 -2
View File
@@ -1,9 +1,9 @@
class A {
companion object {
companion <!REDECLARATION!>object<!> {
}
companion <!MANY_COMPANION_OBJECTS!>object<!> {
companion <!MANY_COMPANION_OBJECTS, REDECLARATION!>object<!> {
}
}
compiler/fir/analysis-tests/testData/resolve/expresssions/objectVsProperty.kt
Vendored
+2 -2
View File
@@ -1,6 +1,6 @@
object A
<!REDECLARATION!>object A<!>
val A = 10
<!REDECLARATION!>val A = 10<!>
fun foo() = A
compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
fun takeString(s: String) {}
<!CONFLICTING_OVERLOADS!>fun takeString(s: String) {}<!>
class Wrapper(val s: String?) {
fun withThis() {
@@ -11,4 +11,4 @@ class Wrapper(val s: String?) {
}
}
fun takeString(s: String) {}
<!CONFLICTING_OVERLOADS!>fun takeString(s: String) {}<!>
compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt
Vendored
+4 -4
View File
@@ -23,11 +23,11 @@ fun test_2(a: A?) {
}
}
fun test_3(x: Any?) {
<!CONFLICTING_OVERLOADS!>fun test_3(x: Any?) {
val a = x as? A ?: return
a.foo() // Should be OK
x.foo() // Should be OK
}
}<!>
// ----------------- Unstable -----------------
@@ -53,8 +53,8 @@ fun test_2(a: B?) {
}
}
fun test_3(x: Any?) {
<!CONFLICTING_OVERLOADS!>fun test_3(x: Any?) {
val a = x as? B ?: return
a.foo() // Should be OK
x.foo() // Should be OK
}
}<!>
compiler/fir/analysis-tests/testData/resolve/whenElse.kt
Vendored
+4 -4
View File
@@ -13,7 +13,7 @@ class B()
class C(val b : B)
fun get(f: Boolean) = if (f) {A.A1} else {""}
fun case2() {
<!CONFLICTING_OVERLOADS!>fun case2() {
val flag: Any = get(false) //string
val l1 = when (flag!!) { // should be NO_ELSE_IN_WHEN
@@ -25,9 +25,9 @@ fun case2() {
A.A1 -> B()
A.A2 -> B()
}
}
}<!>
fun case2() {
<!CONFLICTING_OVERLOADS!>fun case2() {
val flag: Any = get(true) //A
val l1 = when (flag!!) {// should be NO_ELSE_IN_WHEN
@@ -39,7 +39,7 @@ fun case2() {
A.A1 -> B()
A.A2 -> B()
}
}
}<!>
fun case3() {
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/beyoundCalls.kt
Vendored
+2 -2
View File
@@ -1,5 +1,5 @@
fun bar(x: String): Int = 1
fun bar(x: String): Double = 1
<!CONFLICTING_OVERLOADS!>fun bar(x: String): Int = 1<!>
<!CONFLICTING_OVERLOADS!>fun bar(x: String): Double = 1<!>
fun baz(x: String): Int = 1
fun <T, R> foobaz(x: T): R = TODO()
compiler/fir/analysis-tests/testData/resolveWithStdlib/lowPriorityInResolution.kt
Vendored
+3 -3
View File
@@ -1,8 +1,8 @@
@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
<!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
<!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
fun foo(): Int = 1
fun foo(): Int = 1<!>
fun foo(): String = ""
<!CONFLICTING_OVERLOADS!>fun foo(): String = ""<!>
fun test() {
val s = foo()
compiler/fir/analysis-tests/testData/resolveWithStdlib/problems.kt
Vendored
+2 -2
View File
@@ -13,7 +13,7 @@ fun test() {
val Any.bar get() = "456"
val String.bar get() = "987"
val t = "".bar
<!REDECLARATION!>val t = "".bar<!>
val p = Pair(0, "")
@@ -21,4 +21,4 @@ class Base<T>(val x: T)
class Derived : Base<Int>(10)
val xx = Derived().x + 1
val t = throw AssertionError("")
<!REDECLARATION!>val t = throw AssertionError("")<!>
compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java
Generated
+5
View File
@@ -916,6 +916,11 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt");
}
@TestMetadata("conflictingOverloads.kt")
public void testConflictingOverloads() throws Exception {
runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt");
}
@TestMetadata("cyclicConstructorDelegationCall.kt")
public void testCyclicConstructorDelegationCall() throws Exception {
runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt");
compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java
Generated
+5
View File
@@ -916,6 +916,11 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt");
}
@TestMetadata("conflictingOverloads.kt")
public void testConflictingOverloads() throws Exception {
runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt");
}
@TestMetadata("cyclicConstructorDelegationCall.kt")
public void testCyclicConstructorDelegationCall() throws Exception {
runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt");
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/CheckersComponent.kt
+8 -2
View File
@@ -53,25 +53,31 @@ fun FirSession.registerCheckersComponent() {
}
private class ComposedDeclarationCheckers : DeclarationCheckers() {
override val fileCheckers: List<FirFileChecker>
get() = _fileCheckers
override val declarationCheckers: List<FirBasicDeclarationChecker>
get() = _declarationCheckers
override val memberDeclarationCheckers: List<FirMemberDeclarationChecker>
get() = _memberDeclarationCheckers
override val regularClassCheckers: List<FirRegularClassChecker>
get() = _regularClassCheckers
override val constructorCheckers: List<FirConstructorChecker>
get() = _constructorCheckers
override val controlFlowAnalyserCheckers: List<FirControlFlowChecker>
get() = _controlFlowAnalyserCheckers
private val _fileCheckers: MutableList<FirFileChecker> = mutableListOf()
private val _declarationCheckers: MutableList<FirBasicDeclarationChecker> = mutableListOf()
private val _memberDeclarationCheckers: MutableList<FirMemberDeclarationChecker> = mutableListOf()
private val _regularClassCheckers: MutableList<FirRegularClassChecker> = mutableListOf()
private val _constructorCheckers: MutableList<FirConstructorChecker> = mutableListOf()
private val _controlFlowAnalyserCheckers: MutableList<FirControlFlowChecker> = mutableListOf()
fun register(checkers: DeclarationCheckers) {
_fileCheckers += checkers.allFileCheckers
_declarationCheckers += checkers.declarationCheckers
_memberDeclarationCheckers += checkers.allMemberDeclarationCheckers
_regularClassCheckers += checkers.allRegularClassCheckers
_constructorCheckers += checkers.allConstructorCheckers
_controlFlowAnalyserCheckers += checkers.controlFlowAnalyserCheckers
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirDeclarationInspector.kt
+146
View File
@@ -0,0 +1,146 @@
/*
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.analysis.checkers
import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.symbols.CallableId
import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
private open class RepresentationBuilder {
var receiver = ""
var name = ""
open fun build() = "[$receiver] $name"
}
private fun buildRepresentation(init: RepresentationBuilder.() -> Unit): String {
return RepresentationBuilder().apply(init).build()
}
private class FunctionRepresentationBuilder : RepresentationBuilder() {
var typeArguments = ""
var parameters = ""
override fun build() = "<$typeArguments> [$receiver] $name ($parameters)"
}
private fun buildFunctionRepresentation(init: FunctionRepresentationBuilder.() -> Unit): String {
return FunctionRepresentationBuilder().apply(init).build()
}
private fun ClassId.represent() = packageFqName.asString() + '/' + relativeClassName.asString()
private fun CallableId.represent() = if (className != null) {
packageName.asString() + '/' + className + '.' + callableName
} else {
packageName.asString() + '/' + callableName
}
private fun FirTypeRef.represent() = when (this) {
is FirResolvedTypeRef -> type.toString()
is FirErrorTypeRef -> "ERROR"
else -> "?"
}
private fun FirTypeParameter.represent() = name.asString() + " : " + bounds
.map { it.represent() }
.sorted()
.joinToString()
private fun FirValueParameter.represent(): String {
val prefix = if (this.isVararg) "vararg " else ""
return prefix + " " + this.returnTypeRef.represent()
}
private fun FirProperty.represent() = buildRepresentation {
receiver = receiverTypeRef?.represent() ?: ""
name = symbol.callableId.represent()
}
private fun FirSimpleFunction.represent() = buildFunctionRepresentation {
typeArguments = typeParameters.joinToString { it.represent() }
receiver = receiverTypeRef?.represent() ?: ""
name = symbol.callableId.represent()
parameters = valueParameters.joinToString { it.represent() }
}
private fun FirTypeAlias.represent() = buildRepresentation {
name = symbol.classId.represent()
}
private fun FirRegularClass.represent() = buildRepresentation {
name = symbol.classId.represent()
}
private val NO_NAME_PROVIDED = Name.special("<no name provided>")
// - see testEnumValuesValueOf.
// it generates a static function that has
// the same signature as the function defined
// explicitly.
// - see tests with `fun () {}`.
// you can't redeclare something that has no name.
private fun FirDeclaration.isCollectable() = when (this) {
is FirSimpleFunction -> source?.kind !is FirFakeSourceElementKind && name != NO_NAME_PROVIDED
is FirRegularClass -> name != NO_NAME_PROVIDED
else -> true
}
class FirDeclarationInspector {
val otherDeclarations = mutableMapOf<String, MutableList<FirDeclaration>>()
val functionDeclarations = mutableMapOf<String, MutableList<FirSimpleFunction>>()
fun collect(declaration: FirDeclaration) {
if (!declaration.isCollectable()) {
return
}
if (declaration is FirSimpleFunction) {
return collectFunction(declaration)
}
val key = when (declaration) {
is FirRegularClass -> declaration.represent()
is FirTypeAlias -> declaration.represent()
is FirProperty -> declaration.represent()
else -> return
}
var value = otherDeclarations[key]
if (value == null) {
value = mutableListOf()
otherDeclarations[key] = value
}
value.add(declaration)
}
private fun collectFunction(declaration: FirSimpleFunction) {
val key = declaration.represent()
var value = functionDeclarations[key]
if (value == null) {
value = mutableListOf()
functionDeclarations[key] = value
}
value.add(declaration)
}
private fun contains(declaration: FirDeclaration) = when (declaration) {
is FirSimpleFunction -> declaration.represent() in functionDeclarations
is FirRegularClass -> declaration.represent() in otherDeclarations
is FirTypeAlias -> declaration.represent() in otherDeclarations
is FirProperty -> declaration.represent() in otherDeclarations
else -> false
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt
+4
View File
@@ -12,11 +12,15 @@ abstract class DeclarationCheckers {
val EMPTY: DeclarationCheckers = object : DeclarationCheckers() {}
}
open val fileCheckers: List<FirFileChecker> = emptyList()
open val declarationCheckers: List<FirBasicDeclarationChecker> = emptyList()
open val memberDeclarationCheckers: List<FirMemberDeclarationChecker> = emptyList()
open val regularClassCheckers: List<FirRegularClassChecker> = emptyList()
open val constructorCheckers: List<FirConstructorChecker> = emptyList()
open val controlFlowAnalyserCheckers: List<FirControlFlowChecker> = emptyList()
internal val allFileCheckers: List<FirFileChecker> get() = fileCheckers + declarationCheckers
internal val allMemberDeclarationCheckers: List<FirMemberDeclarationChecker> get() = memberDeclarationCheckers + declarationCheckers
internal val allRegularClassCheckers: List<FirRegularClassChecker> get() = regularClassCheckers + allMemberDeclarationCheckers
internal val allConstructorCheckers: List<FirConstructorChecker> get() = constructorCheckers + allMemberDeclarationCheckers
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DefaultDeclarationCheckers.kt
+9
View File
@@ -9,12 +9,17 @@ import org.jetbrains.kotlin.fir.analysis.cfa.FirPropertyInitializationAnalyzer
import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
object CommonDeclarationCheckers : DeclarationCheckers() {
override val fileCheckers: List<FirFileChecker> = listOf(
)
override val declarationCheckers: List<FirBasicDeclarationChecker> = listOf(
FirAnnotationClassDeclarationChecker,
FirModifierChecker,
FirManyCompanionObjectsChecker,
FirLocalEntityNotAllowedChecker,
FirTypeParametersInObjectChecker,
FirConflictsChecker,
)
override val memberDeclarationCheckers: List<FirMemberDeclarationChecker> = listOf(
@@ -26,6 +31,10 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
FirPrimaryConstructorRequiredForDataClassChecker,
)
override val regularClassCheckers: List<FirRegularClassChecker> = listOf(
)
override val constructorCheckers: List<FirConstructorChecker> = listOf(
FirConstructorAllowedChecker,
)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt
+67
View File
@@ -0,0 +1,67 @@
/*
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.analysis.checkers.declaration
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.analysis.checkers.FirDeclarationInspector
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
object FirConflictsChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
val inspector = FirDeclarationInspector()
when (declaration) {
is FirFile -> checkFile(declaration, inspector)
is FirRegularClass -> checkRegularClass(declaration, inspector)
else -> return
}
inspector.functionDeclarations.forEachNonSingle { it, hint ->
reporter.reportConflictingOverloads(it.source, hint)
}
inspector.otherDeclarations.forEachNonSingle { it, hint ->
reporter.reportConflictingDeclarations(it.source, hint)
}
}
private fun Map<String, List<FirDeclaration>>.forEachNonSingle(action: (FirDeclaration, String) -> Unit) {
for (value in values) {
if (value.size > 1) {
val hint = value.joinToString { that -> that.toString() }
value.forEach {
action(it, hint)
}
}
}
}
private fun checkFile(declaration: FirFile, inspector: FirDeclarationInspector) {
for (it in declaration.declarations) {
inspector.collect(it)
}
}
private fun checkRegularClass(declaration: FirRegularClass, inspector: FirDeclarationInspector) {
for (it in declaration.declarations) {
inspector.collect(it)
}
}
private fun DiagnosticReporter.reportConflictingOverloads(source: FirSourceElement?, declarations: String) {
source?.let { report(FirErrors.CONFLICTING_OVERLOADS.on(it, declarations)) }
}
private fun DiagnosticReporter.reportConflictingDeclarations(source: FirSourceElement?, declarations: String) {
source?.let { report(FirErrors.REDECLARATION.on(it, declarations)) }
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationChecker.kt
+3 -4
View File
@@ -7,15 +7,14 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.declarations.FirConstructor
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.*
abstract class FirDeclarationChecker<in D : FirDeclaration> {
abstract fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter)
}
typealias FirFileChecker = FirDeclarationChecker<FirFile>
typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration>
typealias FirMemberDeclarationChecker = FirDeclarationChecker<FirMemberDeclaration>
typealias FirRegularClassChecker = FirDeclarationChecker<FirRegularClass>
typealias FirConstructorChecker = FirDeclarationChecker<FirConstructor>
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirModifierChecker.kt
+3 -4
View File
@@ -14,10 +14,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.getModifierList
import org.jetbrains.kotlin.fir.analysis.checkers.source
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
import org.jetbrains.kotlin.lexer.KtTokens.*
@@ -167,6 +164,8 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
}
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirFile) return
val source = declaration.source ?: return
if (!isDeclarationMappedToSourceCorrectly(declaration, source)) return
if (context.containingDeclarations.last() is FirDefaultPropertyAccessor) return
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt
+5 -1
View File
@@ -17,12 +17,16 @@ class DeclarationCheckersDiagnosticComponent(
) : AbstractDiagnosticCollectorComponent(collector) {
private val checkers = session.checkersComponent.declarationCheckers
override fun visitFile(file: FirFile, data: CheckerContext) {
runCheck { checkers.fileCheckers.check(file, data, it) }
}
override fun visitProperty(property: FirProperty, data: CheckerContext) {
runCheck { checkers.memberDeclarationCheckers.check(property, data, it) }
}
override fun visitRegularClass(regularClass: FirRegularClass, data: CheckerContext) {
runCheck { checkers.memberDeclarationCheckers.check(regularClass, data, it) }
runCheck { checkers.regularClassCheckers.check(regularClass, data, it) }
}
override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: CheckerContext) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
+4
View File
@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_CLASS_
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGN_OPERATOR_AMBIGUITY
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.BREAK_OR_CONTINUE_OUTSIDE_A_LOOP
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONFLICTING_OVERLOADS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONSTRUCTOR_IN_INTERFACE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONSTRUCTOR_IN_OBJECT
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CYCLIC_CONSTRUCTOR_DELEGATION_CALL
@@ -65,6 +66,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROJECTION_ON_NON
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_IMPLICIT_TYPES
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_SUPERTYPES
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDECLARATION
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_MODIFIER
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REPEATED_MODIFIER
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_NOT_ALLOWED
@@ -193,6 +195,8 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
// Redeclarations
map.put(MANY_COMPANION_OBJECTS, "Only one companion object is allowed per class")
map.put(CONFLICTING_OVERLOADS, "Conflicting overloads: {0}", TO_STRING) // *
map.put(REDECLARATION, "Conflicting declarations: {0}", TO_STRING) // *
// Invalid local declarations
map.put(LOCAL_OBJECT_NOT_ALLOWED, "Named object ''{0}'' is a singleton and cannot be local. Try to use anonymous object instead", TO_STRING) // +
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+2
View File
@@ -118,6 +118,8 @@ object FirErrors {
// Redeclarations
val MANY_COMPANION_OBJECTS by error0<FirSourceElement, PsiElement>()
val CONFLICTING_OVERLOADS by error1<FirSourceElement, PsiElement, String>()
val REDECLARATION by error1<FirSourceElement, PsiElement, String>()
// Invalid local declarations
val LOCAL_OBJECT_NOT_ALLOWED by error1<FirSourceElement, PsiElement, Name>()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ArrayUtils.kt
+1 -1
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.symbols.StandardClassIds
fun ConeTypeProjection.createArrayOf(nullable: Boolean = false): ConeKotlinType {
if (this is ConeKotlinTypeProjection) {
val type = type.lowerBoundIfFlexible()
if (type is ConeClassLikeType) {
if (type is ConeClassLikeType && type.nullability != ConeNullability.NULLABLE) {
val classId = type.lookupTag.classId
val primitiveArrayId =
StandardClassIds.primitiveArrayTypeByElementType[classId] ?: StandardClassIds.unsignedArrayTypeByElementType[classId]
compiler/testData/codegen/box/unsignedTypes/varargsOfUnsignedTypes.kt
Vendored
-1
View File
@@ -1,4 +1,3 @@
// IGNORE_BACKEND_FIR: JVM_IR
// WITH_RUNTIME
// KJS_WITH_FULL_RUNTIME
compiler/testData/diagnostics/tests/classObjects/ClassObjects.fir.kt
Vendored
+2 -2
View File
@@ -2,10 +2,10 @@
package Jet86
class A {
companion object {
companion <!REDECLARATION!>object<!> {
val x = 1
}
companion <!MANY_COMPANION_OBJECTS!>object<!> {
companion <!MANY_COMPANION_OBJECTS, REDECLARATION!>object<!> {
val x = 1
}
}
compiler/testData/diagnostics/tests/classObjects/classObjectRedeclaration.fir.kt
Vendored
+6 -6
View File
@@ -2,19 +2,19 @@
package test
class A {
object Companion
<!REDECLARATION!>object Companion<!>
companion object
companion <!REDECLARATION!>object<!>
}
class B {
companion object Named
companion <!REDECLARATION!>object Named<!>
object Named
<!REDECLARATION!>object Named<!>
}
class C {
class Named
<!REDECLARATION!>class Named<!>
companion object Named
companion <!REDECLARATION!>object Named<!>
}
compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.fir.kt
Vendored
+2 -2
View File
@@ -1,6 +1,6 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
data class A(val x: Int, val y: String) {
fun copy(x: Int, y: String) = x
fun copy(x: Int, y: String) = A(x, y)
<!CONFLICTING_OVERLOADS!>fun copy(x: Int, y: String) = x<!>
<!CONFLICTING_OVERLOADS!>fun copy(x: Int, y: String) = A(x, y)<!>
}
compiler/testData/diagnostics/tests/dataClasses/repeatedProperties.fir.kt
Vendored
+4 -4
View File
@@ -1,9 +1,9 @@
data class A1(val x: Int, val y: String, val x: Int) {
data class A1(<!REDECLARATION!>val x: Int<!>, val y: String, <!REDECLARATION!>val x: Int<!>) {
val z = ""
}
data class A2(val x: Int, val y: String) {
val x = ""
data class A2(<!REDECLARATION!>val x: Int<!>, val y: String) {
<!REDECLARATION!>val x = ""<!>
}
data class A3(val<!SYNTAX!><!> :Int, val<!SYNTAX!><!> : Int)
data class A3(<!REDECLARATION!>val<!SYNTAX!><!> :Int<!>, <!REDECLARATION!>val<!SYNTAX!><!> : Int<!>)
compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt
Vendored
+2 -2
View File
@@ -7,8 +7,8 @@ class MyClass {
class MyClass2 {}
fun MyClass2.component1() = 1.2
fun MyClass2.component1() = 1.3
<!CONFLICTING_OVERLOADS!>fun MyClass2.component1() = 1.2<!>
<!CONFLICTING_OVERLOADS!>fun MyClass2.component1() = 1.3<!>
fun test(mc1: MyClass, mc2: MyClass2) {
val (<!INAPPLICABLE_CANDIDATE!>a<!>, <!UNRESOLVED_REFERENCE!>b<!>) = mc1
compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.fir.kt
Vendored
+2 -2
View File
@@ -1,6 +1,6 @@
class A {
operator fun component1() = 1
operator fun component1() = 1
<!CONFLICTING_OVERLOADS!>operator fun component1() = 1<!>
<!CONFLICTING_OVERLOADS!>operator fun component1() = 1<!>
operator fun component2() = 1
}
compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.fir.kt
Vendored
+4 -4
View File
@@ -3,10 +3,10 @@
// KT-3464 Front-end shouldn't allow override modifier in class declaration
override class A {
override companion object {}
open companion <!MANY_COMPANION_OBJECTS!>object<!> {}
abstract companion <!MANY_COMPANION_OBJECTS!>object<!> {}
final companion <!MANY_COMPANION_OBJECTS!>object<!> {}
override companion <!REDECLARATION!>object<!> {}
open companion <!MANY_COMPANION_OBJECTS, REDECLARATION!>object<!> {}
abstract companion <!MANY_COMPANION_OBJECTS, REDECLARATION!>object<!> {}
final companion <!MANY_COMPANION_OBJECTS, REDECLARATION!>object<!> {}
}
override object B1 {}
compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.fir.kt
Vendored
+2 -2
View File
@@ -1,5 +1,5 @@
class C {
companion object {}
companion <!REDECLARATION!>object<!> {}
val Companion = C
<!REDECLARATION!>val Companion = C<!>
}
compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.fir.kt
Vendored
+2 -2
View File
@@ -1,8 +1,8 @@
class B {
companion object A {
companion <!REDECLARATION!>object A<!> {
}
val A = this
<!REDECLARATION!>val A = this<!>
}
class C {
compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.fir.kt
Vendored
+1 -1
View File
@@ -10,5 +10,5 @@ fun test1(a: Array<out Int?>) {
fun test2(vararg a: Int?) {
val list = a.<!INAPPLICABLE_CANDIDATE!>filterNotNull<!>()
list checkType { <!INAPPLICABLE_CANDIDATE!>_<!><List<Int>>() }
list checkType { _<List<Int>>() }
}
compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.fir.kt
Vendored
+4 -4
View File
@@ -15,15 +15,15 @@ inline operator fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.plus(p:
this - p
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
<!CONFLICTING_OVERLOADS!>inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s + s
ext + ext
}
}<!>
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
<!CONFLICTING_OVERLOADS!>inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s + s
ext + ext
}
}<!>
inline fun <T, U> Function1<T, U>.submit() {
this + this
compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.fir.kt
Vendored
+2 -2
View File
@@ -23,6 +23,6 @@ actual var s: String = "value"
fun foo2(): Int = 0
actual class Foo3
<!REDECLARATION!>actual class Foo3<!>
class Foo3
<!REDECLARATION!>class Foo3<!>
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingHeaderDeclarations.fir.kt
Vendored
-8
View File
@@ -1,8 +0,0 @@
// !LANGUAGE: +MultiPlatformProjects
// MODULE: m1-common
// FILE: common.kt
expect fun foo()
expect fun foo()
expect fun foo(x: Int)
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingHeaderDeclarations.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +MultiPlatformProjects
// MODULE: m1-common
// FILE: common.kt
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.fir.kt
Vendored
+4 -4
View File
@@ -7,11 +7,11 @@ expect fun foo()
// MODULE: m2-jvm(m1-common)
// FILE: jvm.kt
actual fun foo() {}
actual fun foo() {}
<!CONFLICTING_OVERLOADS!>actual fun foo() {}<!>
<!CONFLICTING_OVERLOADS!>actual fun foo() {}<!>
// MODULE: m3-js(m1-common)
// FILE: js.kt
actual fun foo() {}
actual fun foo() {}
<!CONFLICTING_OVERLOADS!>actual fun foo() {}<!>
<!CONFLICTING_OVERLOADS!>actual fun foo() {}<!>
compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerDeclarationWithBody.fir.kt
Vendored
+2 -2
View File
@@ -2,8 +2,8 @@
// MODULE: m1-common
// FILE: common.kt
expect fun foo()
<!CONFLICTING_OVERLOADS!>expect fun foo()<!>
expect fun foo() {}
<!CONFLICTING_OVERLOADS!>expect fun foo() {}<!>
expect fun bar() {}
compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInClass.fir.kt
Vendored
+3 -3
View File
@@ -1,6 +1,6 @@
class A {
fun a(a: Int): Int = 0
<!CONFLICTING_OVERLOADS!>fun a(a: Int): Int = 0<!>
fun a(a: Int) {
}
<!CONFLICTING_OVERLOADS!>fun a(a: Int) {
}<!>
}
compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInPackage.fir.kt
Vendored
+4 -4
View File
@@ -1,7 +1,7 @@
package qwertyuiop
fun c(s: String) {
}
<!CONFLICTING_OVERLOADS!>fun c(s: String) {
}<!>
fun c(s: String) {
}
<!CONFLICTING_OVERLOADS!>fun c(s: String) {
}<!>
compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalExtFunsInPackage.fir.kt
Vendored
+2 -2
View File
@@ -1,5 +1,5 @@
package extensionFunctions
fun Int.qwe(a: Float) = 1
<!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float) = 1<!>
fun Int.qwe(a: Float) = 2
<!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float) = 2<!>
compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsInClass.fir.kt
Vendored
+4 -4
View File
@@ -1,7 +1,7 @@
class A() {
fun b() {
}
<!CONFLICTING_OVERLOADS!>fun b() {
}<!>
fun b() {
}
<!CONFLICTING_OVERLOADS!>fun b() {
}<!>
}
compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalValsInClass.fir.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
class Aaa() {
val a = 1
val a = 1
<!REDECLARATION!>val a = 1<!>
<!REDECLARATION!>val a = 1<!>
}
compiler/testData/diagnostics/tests/overload/ConflictingOverloadsValsDifferentTypeInClass.fir.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
class Aaa() {
val a = 1
val a = ""
<!REDECLARATION!>val a = 1<!>
<!REDECLARATION!>val a = ""<!>
}
compiler/testData/diagnostics/tests/overload/TypeParameterMultipleBounds.fir.kt
Vendored
+4 -4
View File
@@ -1,8 +1,8 @@
import java.io.Serializable
interface Test1 {
fun <T> foo(t: T) where T : Cloneable, T : Serializable
fun <T> foo(t: T) where T : Serializable, T : Cloneable
<!CONFLICTING_OVERLOADS!>fun <T> foo(t: T) where T : Cloneable, T : Serializable<!>
<!CONFLICTING_OVERLOADS!>fun <T> foo(t: T) where T : Serializable, T : Cloneable<!>
}
@@ -10,6 +10,6 @@ interface I1
interface I2 : I1
interface Test2 {
fun <T> foo(t: T) where T : I1, T : I2
fun <T> foo(t: T) where T : I2, T : I1
<!CONFLICTING_OVERLOADS!>fun <T> foo(t: T) where T : I1, T : I2<!>
<!CONFLICTING_OVERLOADS!>fun <T> foo(t: T) where T : I2, T : I1<!>
}
compiler/testData/diagnostics/tests/override/DuplicateMethod.fir.kt
Vendored
+2 -2
View File
@@ -3,6 +3,6 @@ interface Some {
}
class SomeImpl : Some {
override fun test() {}
override fun test() {}
<!CONFLICTING_OVERLOADS!>override fun test() {}<!>
<!CONFLICTING_OVERLOADS!>override fun test() {}<!>
}
compiler/testData/diagnostics/tests/redeclarations/ConflictingExtensionProperties.fir.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
package foo
val Int.foo: Int get() = 2
val Int.foo: Int get() = 3
<!REDECLARATION!>val Int.foo: Int get() = 2<!>
<!REDECLARATION!>val Int.foo: Int get() = 3<!>
compiler/testData/diagnostics/tests/redeclarations/PropertyAndInnerClass.fir.kt
Vendored
+4 -4
View File
@@ -1,13 +1,13 @@
public class A() {
public val FOO: String = "test"
<!REDECLARATION!>public val FOO: String = "test"<!>
public class FOO() { }
<!REDECLARATION!>public class FOO() { }<!>
}
public class B() {
companion object {
public val FOO: String = "test"
<!REDECLARATION!>public val FOO: String = "test"<!>
public class FOO() { }
<!REDECLARATION!>public class FOO() { }<!>
}
}
compiler/testData/diagnostics/tests/redeclarations/RedeclarationInDefaultObject.fir.kt
Vendored
+2 -2
View File
@@ -1,6 +1,6 @@
class A {
companion object B {
class G
val G = 1
<!REDECLARATION!>class G<!>
<!REDECLARATION!>val G = 1<!>
}
}
compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInFile.fir.kt
Vendored
+2 -2
View File
@@ -1,5 +1,5 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
// KT-9733 No error shown for 2 "main" functions in the same file
fun main(args: Array<String>) {}
fun main(args: Array<String>) {}
<!CONFLICTING_OVERLOADS!>fun main(args: Array<String>) {}<!>
<!CONFLICTING_OVERLOADS!>fun main(args: Array<String>) {}<!>
compiler/testData/diagnostics/tests/redeclarations/Redeclarations.fir.kt
Vendored
+3 -3
View File
@@ -1,14 +1,14 @@
// FILE: f.kt
package redeclarations
object A {
<!REDECLARATION!>object A<!> {
val x : Int = 0
val A = 1
}
class A {}
<!REDECLARATION!>class A {}<!>
val A = 1
<!REDECLARATION!>val A = 1<!>
// FILE: f.kt
package redeclarations.A
compiler/testData/diagnostics/tests/redeclarations/RedeclarationsInObjects.fir.kt
Vendored
+4 -4
View File
@@ -1,9 +1,9 @@
// !DIAGNOSTICS: -DUPLICATE_CLASS_NAMES
// KT-3525
object B {
class C
class C
<!REDECLARATION!>class C<!>
<!REDECLARATION!>class C<!>
val a : Int = 1
val a : Int = 1
<!REDECLARATION!>val a : Int = 1<!>
<!REDECLARATION!>val a : Int = 1<!>
}
compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.fir.kt
Vendored
+6 -6
View File
@@ -14,16 +14,16 @@ private val invalidProp0 = 1
fun useInvalidFun0() = invalidFun0()
fun useInvalidProp0() = invalidProp0
private fun invalidFun1() {}
private fun invalidFun1() {}
<!CONFLICTING_OVERLOADS!>private fun invalidFun1() {}<!>
<!CONFLICTING_OVERLOADS!>private fun invalidFun1() {}<!>
private fun invalidFun2() {}
public fun invalidFun2() {}
<!CONFLICTING_OVERLOADS!>private fun invalidFun2() {}<!>
<!CONFLICTING_OVERLOADS!>public fun invalidFun2() {}<!>
public fun invalidFun3() {}
private fun invalidFun4() {}
public fun invalidFun4() {}
<!CONFLICTING_OVERLOADS!>private fun invalidFun4() {}<!>
<!CONFLICTING_OVERLOADS!>public fun invalidFun4() {}<!>
public fun validFun2(a: A) = a
public fun validFun2(b: B) = b
compiler/testData/diagnostics/tests/redeclarations/TopLevelPropertyVsClassifier.fir.kt
Vendored
+10 -10
View File
@@ -1,13 +1,13 @@
val Test1 = null
class Test1
<!REDECLARATION!>val Test1 = null<!>
<!REDECLARATION!>class Test1<!>
val Test2 = null
interface Test2
<!REDECLARATION!>val Test2 = null<!>
<!REDECLARATION!>interface Test2<!>
val Test3 = null
object Test3
<!REDECLARATION!>val Test3 = null<!>
<!REDECLARATION!>object Test3<!>
val Test4 = null
class Test4
interface Test4
object Test4
<!REDECLARATION!>val Test4 = null<!>
<!REDECLARATION!>class Test4<!>
<!REDECLARATION!>interface Test4<!>
<!REDECLARATION!>object Test4<!>
compiler/testData/diagnostics/tests/redeclarations/TypeAliasVsClass.fir.kt
Vendored
+8 -8
View File
@@ -1,17 +1,17 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
// FILE: file1.kt
class SomeClass
<!REDECLARATION!>class SomeClass<!>
typealias SomeClass = Any
typealias SomeClass = Any
typealias SomeClass = Any
<!REDECLARATION!>typealias SomeClass = Any<!>
<!REDECLARATION!>typealias SomeClass = Any<!>
<!REDECLARATION!>typealias SomeClass = Any<!>
class Outer {
class Nested
<!REDECLARATION!>class Nested<!>
typealias Nested = Any
typealias Nested = Any
typealias Nested = Any
<!REDECLARATION!>typealias Nested = Any<!>
<!REDECLARATION!>typealias Nested = Any<!>
<!REDECLARATION!>typealias Nested = Any<!>
}
// FILE: file2.kt
compiler/testData/diagnostics/tests/redeclarations/TypeAliasVsProperty.fir.kt
Vendored
+4 -4
View File
@@ -1,13 +1,13 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
// FILE: file1.kt
typealias Test = String
<!REDECLARATION!>typealias Test = String<!>
val Test = 42
<!REDECLARATION!>val Test = 42<!>
class Outer {
typealias Test = String
<!REDECLARATION!>typealias Test = String<!>
val Test = 42
<!REDECLARATION!>val Test = 42<!>
}
typealias Test2 = String
compiler/testData/diagnostics/tests/redeclarations/kt2438.fir.kt
Vendored
+6 -6
View File
@@ -4,19 +4,19 @@
package kt2438
class B {
class C
class C
<!REDECLARATION!>class C<!>
<!REDECLARATION!>class C<!>
}
class A {
class B
<!REDECLARATION!>class B<!>
companion object {
class B
class B
<!REDECLARATION!>class B<!>
<!REDECLARATION!>class B<!>
}
class B
<!REDECLARATION!>class B<!>
}
compiler/testData/diagnostics/tests/redeclarations/kt470.fir.kt
Vendored
+28 -28
View File
@@ -1,37 +1,37 @@
val a : Int = 1
val a : Int = 1
val a : Int = 1
<!REDECLARATION!>val a : Int = 1<!>
<!REDECLARATION!>val a : Int = 1<!>
<!REDECLARATION!>val a : Int = 1<!>
val b : Int = 1
val b : Int = 1
val b : Int = 1
val b : Int = 1
<!REDECLARATION!>val b : Int = 1<!>
<!REDECLARATION!>val b : Int = 1<!>
<!REDECLARATION!>val b : Int = 1<!>
<!REDECLARATION!>val b : Int = 1<!>
fun foo() {} // and here too
fun foo() {} // and here
fun foo() {} // and here
fun foo() {} // and here
<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here too
<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
fun bar() {} // and here
fun bar() {} // and here
fun bar() {} // and here
<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
class A {
val a : Int = 1
val a : Int = 1
val a : Int = 1
<!REDECLARATION!>val a : Int = 1<!>
<!REDECLARATION!>val a : Int = 1<!>
<!REDECLARATION!>val a : Int = 1<!>
val b : Int = 1
val b : Int = 1
val b : Int = 1
val b : Int = 1
<!REDECLARATION!>val b : Int = 1<!>
<!REDECLARATION!>val b : Int = 1<!>
<!REDECLARATION!>val b : Int = 1<!>
<!REDECLARATION!>val b : Int = 1<!>
fun foo() {} // and here too
fun foo() {} // and here
fun foo() {} // and here
fun foo() {} // and here
<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here too
<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
fun bar() {} // and here
fun bar() {} // and here
fun bar() {} // and here
<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
}
compiler/testData/diagnostics/tests/regressions/Jet11.fir.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
// JET-11 Redeclaration & Forward reference for classes cause an exception
open class NoC
<!REDECLARATION!>open class NoC<!>
class NoC1 : NoC()
open class NoC
<!REDECLARATION!>open class NoC<!>
compiler/testData/diagnostics/tests/resolve/resolveWithRedeclarationError.fir.kt
Vendored
+27 -27
View File
@@ -3,32 +3,32 @@ package c
fun z(view: () -> Unit) {}
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
fun x() = z { z { z { z { z { z { z { z { } } } } } } } }
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
class x() {}
compiler/testData/diagnostics/tests/secondaryConstructors/redeclarationsOfConstructorsIgnored.fir.kt
Vendored
+3 -3
View File
@@ -1,7 +1,7 @@
class A
class A {
<!REDECLARATION!>class A<!>
<!REDECLARATION!>class A {
constructor()
}
}<!>
class B
class Outer {
compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendConflictsWithNoSuspend.fir.kt
Vendored
+6 -6
View File
@@ -1,15 +1,15 @@
// FILE: main.kt
interface A {
suspend fun foo()
fun foo()
<!CONFLICTING_OVERLOADS!>suspend fun foo()<!>
<!CONFLICTING_OVERLOADS!>fun foo()<!>
}
interface B : A {
suspend override fun foo() {
<!CONFLICTING_OVERLOADS!>suspend override fun foo() {
}
}<!>
override fun foo() {
<!CONFLICTING_OVERLOADS!>override fun foo() {
}
}<!>
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.fir.kt
Vendored
+4 -4
View File
@@ -1,13 +1,13 @@
//!DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
// !WITH_NEW_INFERENCE
@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
<!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
@kotlin.jvm.JvmName("containsAny")
<!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
public fun <T> Iterable<T>.contains1(element: T): Int = null!!
public fun <T> Iterable<T>.contains1(element: T): Int = null!!<!>
@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
public fun <T> Iterable<T>.contains1(element: @kotlin.internal.NoInfer T): Boolean = null!!
<!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
public fun <T> Iterable<T>.contains1(element: @kotlin.internal.NoInfer T): Boolean = null!!<!>
fun test() {
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.fir.kt
Vendored
+4 -4
View File
@@ -2,13 +2,13 @@
// !WITH_NEW_INFERENCE
// !LANGUAGE: -NonStrictOnlyInputTypesChecks
@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
<!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
@kotlin.jvm.JvmName("containsAny")
<!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
public fun <T> Iterable<T>.contains1(element: T): Int = null!!
public fun <T> Iterable<T>.contains1(element: T): Int = null!!<!>
@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> Iterable<T>.contains1(element: T): Boolean = null!!
<!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> Iterable<T>.contains1(element: T): Boolean = null!!<!>
@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
@JvmName("getAny")
compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.4.fir.kt
Vendored
+2 -2
View File
@@ -54,9 +54,9 @@ class Case2() {
* TESTCASE NUMBER: 3
* NOTE: check abstract member cannot be accessed directly
*/
class Case3(override val boo: String) : BaseCase3() {
class Case3(<!REDECLARATION!>override val boo: String<!>) : BaseCase3() {
override val zoo: String = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
override val boo: String = super.<!ABSTRACT_SUPER_CALL!>boo<!>
<!REDECLARATION!>override val boo: String = super.<!ABSTRACT_SUPER_CALL!>boo<!><!>
override val value: String = super.<!ABSTRACT_SUPER_CALL!>zoo<!>
val hoo: String = super.<!ABSTRACT_SUPER_CALL!>zoo<!>
compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg/1.1.fir.kt
Vendored
+2 -2
View File
@@ -18,7 +18,7 @@ class Case2() {
fun foo(vararg x: Int?): Unit = TODO() // (1.2)
fun case(){
foo(1, 1)
<!AMBIGUITY!>foo<!>(1, 1)
}
}
// TESTCASE NUMBER: 3
@@ -27,7 +27,7 @@ class Case3() {
fun foo(vararg x: Int?): Unit = TODO() // (1.2)
fun case(){
foo(1, 1)
<!AMBIGUITY!>foo<!>(1, 1)
}
}
compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/14.fir.kt
Vendored
+3 -3
View File
@@ -5,7 +5,7 @@
// TESTCASE NUMBER: 1
fun case_1(vararg x: Int?) {
if (x != null) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.IntArray & kotlin.IntArray")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Array<out kotlin.Int?> & kotlin.Array<out kotlin.Int?>")!>x<!>
x[0]
}
}
@@ -21,8 +21,8 @@ fun case_2(vararg x: Int?) {
x[0].also {
if (it != null) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int")!>it<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int")!>it<!>.inv()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>it<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>it<!>.inv()
}
}
}