Marco Pennekamp
5909b191a5
- `REDUNDANT_MODIFIER_FOR_TARGET` is already reported for `open` interfaces, but for consistency and IDE support, the compiler now reports `REDUNDANT_MODALITY_MODIFIER` as well via the extended checker. - `REDUNDANT_MODIFIER_FOR_TARGET` cannot be disabled for this case because it's reported via a basic checker while `REDUNDANT_MODALITY_MODIFIER` is reported via an extended checker. - Rename `implicitModality` to `redundantModalities` and return a set of modalities. The idea of a *single* implicit/redundant modality doesn't stand up to scrutiny. For example, for interfaces with `ABSTRACT` implicit modality, `OPEN` is also a redundant modifier. But this is not necessarily the case for all kinds of declarations. Hypothetically, if it was possible to declare a class that is abstract by default, adding an `open` modifier to that class would not be redundant, as it would make the class instantiable.
93 lines
2.7 KiB
Kotlin
Vendored
93 lines
2.7 KiB
Kotlin
Vendored
object O {
|
|
fun foo() {}
|
|
}
|
|
|
|
// Interface
|
|
interface Interface {
|
|
// Questionable cuz compiler reports warning here in FE 1.0
|
|
<!REDUNDANT_MODALITY_MODIFIER!>open<!> val gav: Int
|
|
get() = 42
|
|
// Redundant
|
|
<!REDUNDANT_MODALITY_MODIFIER!>abstract<!> fun foo()
|
|
// error
|
|
<!PRIVATE_FUNCTION_WITH_NO_BODY!>private<!> <!WRONG_MODIFIER_CONTAINING_DECLARATION!>final<!> fun bar()
|
|
|
|
<!REDUNDANT_MODALITY_MODIFIER, REDUNDANT_OPEN_IN_INTERFACE!>open<!> fun loo()
|
|
<!REDUNDANT_MODALITY_MODIFIER!>open<!> fun goo() {}
|
|
<!REDUNDANT_MODALITY_MODIFIER!>abstract<!> fun tar()
|
|
|
|
// error
|
|
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun too() {}
|
|
}
|
|
interface B {
|
|
<!REDUNDANT_MODALITY_MODIFIER!>abstract<!> var bar: Unit
|
|
<!REDUNDANT_MODALITY_MODIFIER!>abstract<!> fun foo()
|
|
}
|
|
interface Foo
|
|
|
|
expect abstract class AbstractClass : Foo {
|
|
abstract <!NOTHING_TO_OVERRIDE!>override<!> fun foo()
|
|
|
|
abstract fun bar()
|
|
|
|
abstract val baz: Int
|
|
}
|
|
|
|
|
|
// Abstract
|
|
abstract class Base {
|
|
// Redundant final
|
|
<!REDUNDANT_MODALITY_MODIFIER!>final<!> fun foo() {}
|
|
// Abstract
|
|
abstract fun bar()
|
|
// Open
|
|
open val gav = 42
|
|
}
|
|
|
|
class FinalDerived : Base() {
|
|
// Redundant final
|
|
override <!REDUNDANT_MODALITY_MODIFIER!>final<!> fun bar() {}
|
|
// Non-final member in final class
|
|
override <!NON_FINAL_MEMBER_IN_FINAL_CLASS!>open<!> val gav = 13
|
|
}
|
|
// Open
|
|
open class OpenDerived : Base() {
|
|
// Final
|
|
override final fun bar() {}
|
|
// Redundant open
|
|
override <!REDUNDANT_MODALITY_MODIFIER!>open<!> val gav = 13
|
|
|
|
private <!REDUNDANT_MODALITY_MODIFIER!>final<!> fun fan() {}
|
|
}
|
|
// Redundant final
|
|
<!REDUNDANT_MODALITY_MODIFIER!>final<!> class Final
|
|
// Derived interface
|
|
interface Derived : Interface {
|
|
// Redundant
|
|
override <!REDUNDANT_MODALITY_MODIFIER!>open<!> fun foo() {}
|
|
// error
|
|
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>final<!> class Nested
|
|
}
|
|
// Derived abstract class
|
|
abstract class AbstractDerived1(override final val gav: Int) : Interface {
|
|
// Redundant
|
|
override <!REDUNDANT_MODALITY_MODIFIER!>open<!> fun foo() {}
|
|
}
|
|
// Derived abstract class
|
|
abstract class AbstractDerived2 : Interface {
|
|
// Final
|
|
override final fun foo() {}
|
|
// Redundant
|
|
override <!REDUNDANT_MODALITY_MODIFIER!>open<!> val gav = 13
|
|
}
|
|
// Redundant abstract interface
|
|
<!REDUNDANT_MODALITY_MODIFIER!>abstract<!> interface AbstractInterface
|
|
// Redundant final object
|
|
<!REDUNDANT_MODALITY_MODIFIER!>final<!> object FinalObject
|
|
// Open interface
|
|
<!REDUNDANT_MODALITY_MODIFIER, REDUNDANT_MODIFIER_FOR_TARGET!>open<!> interface OpenInterface
|
|
|
|
class FinalDerived2(override <!REDUNDANT_MODALITY_MODIFIER!>final<!> val gav: Int) : Base() {
|
|
override fun bar() {}
|
|
}
|