FIR: Adjust testData for spec tests: declarations

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg/1.1.fir.kt

@@ -0,0 +1,37 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 1 -> sentence 1
+ * RELEVANT PLACES: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check abstract classes can have abstract not implemented members
+ */
+
+// TESTCASE NUMBER: 1
+
+abstract class Base() {
+    abstract fun foo() = {}
+    fun boo() : Unit
+    abstract val a = ""
+    val b
+    var d
+}
+
+class Impl : Base() {
+    override fun foo(): () -> Unit {
+        TODO("not implemented")
+    }
+
+    override val a: String
+        get() = TODO("not implemented")
+
+}
+
+fun case1() {
+    val impl = Impl()
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg/2.1.fir.kt

@@ -0,0 +1,30 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 1 -> sentence 2
+ * RELEVANT PLACES: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check abstract classes cannot be instantiated directly
+ */
+
+// TESTCASE NUMBER: 1
+abstract class Base0()
+
+abstract class Base1() {
+    abstract fun foo()
+}
+
+abstract class Base2(var b1: Any, val a1: Any) {
+    abstract fun foo()
+}
+
+fun case1() {
+    val b0 = Base0()
+    val b1 = Base1()
+    val b2 = Base2(1, "1")
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.1.fir.kt

@@ -0,0 +1,128 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ */
+
+// TESTCASE NUMBER: 1
+
+<!REDUNDANT_MODIFIER!>open<!>     abstract class Base {
+
+    abstract val a: Any
+    abstract var b: Any
+    internal abstract val c: Any
+    internal abstract var d: Any
+
+
+    abstract fun foo()
+    internal abstract fun boo(): Any
+}
+
+fun case1() {
+    val impl = BaseImplCase2(1, "1", 1.0)
+}
+
+class BaseImplCase2(
+    override var a: Any, override
+    val  b: Any, override var c: Any, override
+
+ val  d: Any = "5") : Base()
+{
+    override fun foo() {}
+    override internal fun boo() {}
+}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    val impl = ImplBaseCase2()
+}
+
+class ImplBaseCase2() : Base() {
+    override var a: Any
+        get() = TODO()
+        set(value) {}
+    override
+
+     val  b: Any
+        get() = TODO()
+    override var c: Any
+        get() = TODO()
+        set(value) {}
+    override
+
+     val  d: Any
+        get() = TODO()
+
+    override fun foo() {}
+
+    override fun boo(): Any {
+        return ""
+    }
+}
+
+/*
+* TESTCASE NUMBER: 3
+* NOTE: property is not implemented
+*/
+fun case3() {
+    ImplBaseCase3()
+}
+
+class ImplBaseCase3() : Base() {
+    override var b: Any
+        get() = TODO()
+        set(value) {}
+    override val c: Any
+        get() = TODO()
+    override var d: Any
+        get() = TODO()
+        set(value) {}
+
+    override fun foo() {
+        TODO()
+    }
+
+    override fun boo(): Any {
+        TODO()
+    }
+}
+
+/*
+* TESTCASE NUMBER: 4
+* NOTE: function is not implemented
+*/
+
+fun case4() {
+    ImplBaseCase4()
+}
+
+class ImplBaseCase4() : Base() {
+    override var b: Any
+        get() = TODO()
+        set(value) {}
+    override val c: Any
+        get() = TODO()
+    override var d: Any
+        get() = TODO()
+        set(value) {}
+
+    override fun foo() {}
+
+    override fun boo(): Any {
+        return 1
+    }
+}
+
+/*
+* TESTCASE NUMBER: 5
+* NOTE: incompatible modifiers final and abstract
+*/
+<!INCOMPATIBLE_MODIFIERS!>final<!>   <!INCOMPATIBLE_MODIFIERS!>abstract<!>   class Case5() {}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.10.fir.kt

@@ -0,0 +1,62 @@
+// !LANGUAGE: +NewInference +ProhibitInvisibleAbstractMethodsInSuperclasses
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+// FULL_JDK
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * RELEVANT PLACES: inheritance, overriding -> paragraph 7 -> sentence 1
+ * NUMBER: 10
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ * ISSUES: KT-27825
+ */
+
+// TESTCASE NUMBER: 1
+class Case1() : BaseCase1(), InterfaceCase1 {}
+
+abstract class BaseCase1() {
+    abstract fun foo(): String
+    abstract val a: String
+}
+
+interface InterfaceCase1 {
+    fun foo() = "foo"
+    val a: String
+        get() = "a"
+}
+
+// TESTCASE NUMBER: 2
+class Case2Outer {
+    val v = "v"
+
+    abstract class Case2Base() {
+        abstract fun foo(): String
+    }
+
+    inner
+    class A() : Case2Base() {
+
+    }
+}
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    object : CaseOuter.CaseBase() {}.outerFoo()
+}
+
+class B() : CaseOuter.CaseBase() {}
+
+sealed class CaseOuter {
+    val v = "v"
+    abstract fun outerFoo();
+
+    abstract class CaseBase() : CaseOuter() {
+        abstract fun foo(): String
+    }
+
+    class A() : CaseBase() {
+    }
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.2.fir.kt

@@ -0,0 +1,99 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Abstract classes may contain abstract members, which should be implemented in an anonymous class that inherits from that abstract type
+ */
+
+// TESTCASE NUMBER: 1
+private abstract class Base {
+
+    abstract val a: Any
+    abstract var b: Any
+    internal abstract val c: Any
+    internal abstract var d: Any
+
+
+    abstract fun foo()
+    internal abstract fun boo(): Any
+}
+
+
+fun case1() {
+    val impl = object : Base() {
+        override var a: Any
+            get() = TODO()
+            set(value) {}
+        override val b: Any
+            get() = TODO()
+        override var c: Any
+            get() = TODO()
+            set(value) {}
+        override val d: Any
+            get() = TODO()
+
+        override fun foo() {}
+
+        override fun boo(): Any {
+            return ""
+        }
+    }
+}
+
+
+
+/*
+* TESTCASE NUMBER: 2
+* NOTE: property is not implemented
+*/
+fun case2() {
+    val impl = object : Base() {
+        override var b: Any
+            get() = TODO()
+            set(value) {}
+        override val c: Any
+            get() = TODO()
+        override var d: Any
+            get() = TODO()
+            set(value) {}
+
+        override fun foo() {
+            TODO()
+        }
+
+        override fun boo(): Any {
+            TODO()
+        }
+    }
+}
+
+
+/*
+* TESTCASE NUMBER: 3
+* NOTE: function is not implemented
+*/
+
+fun case3() {
+    val impl = object : Base() {
+        override var b: Any
+            get() = TODO()
+            set(value) {}
+        override val c: Any
+            get() = TODO()
+        override var d: Any
+            get() = TODO()
+            set(value) {}
+
+        override fun foo() {}
+
+        override fun boo(): Any {
+            return 1
+        }
+    }
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.3.fir.kt

@@ -0,0 +1,64 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 3
+ * DESCRIPTION: attempt to implement abstract members with invalid types
+ */
+
+// TESTCASE NUMBER: 1
+abstract class Base {
+    abstract val a: CharSequence
+    abstract var b: CharSequence
+
+    abstract fun foo(): CharSequence
+}
+
+class Case1 : Base() {
+    override fun foo(): Any
+    {
+        return ""
+    }
+
+    override val a: Any?
+    get() = TODO()
+    override var b: String
+    get() = TODO()
+    set(value)
+    {}
+}
+
+
+/*
+* TESTCASE NUMBER: 2
+*/
+
+class Case2(override val a: String, override var b: String) : Base() {
+    override fun foo(): CharSequence? {
+        return ""
+    }
+}
+
+/*
+* TESTCASE NUMBER: 3
+* NOTE: abstract nested class members are not implemented
+*/
+
+class Case3 {
+    class ImplBase1 : MainClass.Base1() {}
+}
+
+class MainClass {
+    abstract class Base1() {
+        abstract val a: CharSequence
+        abstract var b: CharSequence
+
+        abstract fun foo(): CharSequence
+    }
+
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.4.fir.kt

@@ -0,0 +1,120 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+// FULL_JDK
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 4
+ * DESCRIPTION: Abstract classes may contain abstract members, which should be implemented in an inner class that inherits from that abstract type
+ */
+
+class MainClass {
+    abstract class Base1() {
+        abstract val a: CharSequence
+        abstract var b: CharSequence
+        abstract fun foo(): CharSequence
+    }
+
+    abstract class Base2 : Base1() {
+        abstract fun boo(x: Int = 10)
+    }
+
+    abstract class Base3(override val a: CharSequence) : Base1() {}
+}
+
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE: absctract class member is not implemented in inner class
+ */
+class Case1 {
+
+    abstract inner class ImplBase2() : MainClass.Base2() {
+        override var b: CharSequence = ""
+        override val a: CharSequence = ""
+        override fun boo(x: Int) {}
+    }
+
+    inner
+
+    class ImplBase2_1 : ImplBase2() {
+        override var b: CharSequence = ""
+        override fun boo(x: Int) {}
+    }
+}
+
+/*
+* TESTCASE NUMBER: 2
+* NOTE:absctract class member is not implemented in anonymos class
+*/
+class Case2() {
+    abstract inner class Impl(override val a: CharSequence) : MainClass.Base3(a) {}
+
+    fun boo() {
+        val impl = object : Impl("a") {
+            override fun foo(): CharSequence = "foo"
+        }
+    }
+}
+
+/*
+* TESTCASE NUMBER: 3
+* NOTE: check abstract member cannot be accessed directly
+*/
+class Case3(override val boo: String) : BaseCase3() {
+    override val zoo: String = super.foo()
+    override val boo: String = super.boo
+    override val value: String = super.zoo
+    val hoo: String = super.zoo
+
+    override fun foo(): String {
+        super.foo()
+        super.boo
+        super.value
+        return ""
+    }
+}
+
+abstract class BaseCase3{
+    abstract fun foo(): String
+    open val value: String get() = "value"
+    abstract val boo: String
+    abstract val zoo: String
+}
+
+/*
+* TESTCASE NUMBER: 4
+* NOTE: abstract class implements kotlin interface
+*/
+
+class Case4(a: String) : BaseCase4(a) {}
+
+interface InterfaceCase4 {
+    fun foo(): String
+
+    fun boo() {
+        foo()
+    }
+}
+
+abstract class BaseCase4(val a: String) : InterfaceCase4 {}
+
+/*
+* TESTCASE NUMBER: 5
+* NOTE: abstract class implements java interface
+*/
+
+class Case5(a: String) : BaseCase5(a) {}
+
+abstract class BaseCase5(val a: String) : java.util.Deque<String> {}
+
+/*
+* TESTCASE NUMBER: 6
+* NOTE: abstract class implements java abstract class
+*/
+
+class Case6(a: String) : BaseCase6(a) {}
+
+abstract class BaseCase6(val a: String) : java.util.AbstractCollection<String>() {}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.5.fir.kt

@@ -0,0 +1,56 @@
+// !LANGUAGE: +NewInference +ProhibitInvisibleAbstractMethodsInSuperclasses
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+// FULL_JDK
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 5
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ */
+
+
+// FILE: base/BaseJava.java
+package base;
+
+public abstract class BaseJava {
+
+    public BaseJavaCase1()
+    {}
+
+    public BaseJavaCase1(Boolean b)
+    { foo(b); }
+
+    public void boo(Boolean b)
+    { foo(b); }
+
+    abstract void foo(Boolean b);
+}
+
+// FILE: Impl.kt
+package implBase
+import base.*
+
+// TESTCASE NUMBER: 1
+
+class Case1 : BaseJava() {}
+
+fun case1() {
+    val v = Case1()
+    v.boo(true)
+}
+
+/*
+* TESTCASE NUMBER: 2
+*/
+abstract class AbstractClassCase2 : BaseJava() {}
+
+class Case2 : AbstractClassCase2() {}
+
+fun case2() {
+    val v = Case2()
+    v.boo(true)
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.6.fir.kt

@@ -0,0 +1,82 @@
+// !LANGUAGE: +NewInference +ProhibitInvisibleAbstractMethodsInSuperclasses
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+// FULL_JDK
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 6
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ * ISSUES: KT-27825
+ */
+
+
+// FILE: base/BaseJava.java
+package base;
+
+public abstract class BaseJava {
+
+    public BaseJavaCase1()
+    {}
+
+    public BaseJavaCase1(Boolean b)
+    { foo(b); }
+
+    public void boo(Boolean b)
+    { foo(b); }
+
+    abstract void foo(Boolean b);
+}
+
+// FILE: Impl.kt
+package implBase
+import base.*
+
+// TESTCASE NUMBER: 1
+
+class Case1 : BaseJava() {
+    override fun foo(b: Boolean?) {}
+}
+
+fun case1() {
+    val v = Case1()
+    v.boo(true)
+}
+
+/*
+* TESTCASE NUMBER: 2
+*/
+abstract class AbstractClassCase2 : BaseJava() {}
+
+class Case2: AbstractClassCase2() {
+    override fun foo(b: Boolean?) {}
+}
+
+fun case2() {
+    val v = Case2()
+    v.boo(true)
+}
+
+// TESTCASE NUMBER: 3
+
+class Case3 : BaseJava() {}
+
+fun case3() {
+    val v = Case3()
+    v.boo(true)
+}
+
+/*
+* TESTCASE NUMBER: 4
+*/
+abstract class AbstractClassCase4 : BaseJava() {}
+
+class Case4 : AbstractClassCase4() {}
+
+fun case4() {
+    val v = Case4()
+    v.boo(true)
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.7.fir.kt

@@ -0,0 +1,93 @@
+// !LANGUAGE: +NewInference +ProhibitInvisibleAbstractMethodsInSuperclasses
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+// FULL_JDK
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 7
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ * ISSUES: KT-27825
+ */
+
+// MODULE: base
+// FILE: BaseKotlin.kt
+package base
+abstract class BaseKotlin() {
+
+    fun boo(b: Boolean?) {
+        foo(b)
+    }
+
+    internal abstract fun foo(b: Boolean?)
+}
+
+
+//MODULE: implBase(base)
+//FILE: Impl.kt
+
+
+package implBase
+import base.*
+
+
+// TESTCASE NUMBER: 1
+
+class Case1 : BaseKotlin() {
+    override fun foo(b: Boolean?) {}
+}
+
+fun case1() {
+    val v = Case1()
+    v.boo(true)
+
+    val o = object :  BaseKotlin() {
+        override fun foo(b: Boolean?) {}
+    }
+}
+
+/*
+* TESTCASE NUMBER: 2
+*/
+abstract class AbstractClassCase2 : BaseKotlin() {}
+
+class Case2: AbstractClassCase2() {
+    override fun foo(b: Boolean?) {}
+}
+
+fun case2() {
+    val v = Case2()
+    v.boo(true)
+
+    val o = object : AbstractClassCase2() {
+        override fun foo(b: Boolean?) {}
+    }
+}
+
+// TESTCASE NUMBER: 3
+
+class Case3 : BaseKotlin() {}
+
+fun case3() {
+    val v = Case3()
+    v.boo(true)
+
+    val o = object : BaseKotlin() {}
+}
+
+/*
+* TESTCASE NUMBER: 4
+*/
+abstract class AbstractClassCase4 : BaseKotlin() {}
+
+class Case4 : AbstractClassCase4() {}
+
+fun case4() {
+    val v = Case4()
+    v.boo(true)
+    val o = object : AbstractClassCase4() {}
+
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.fir.kt

@@ -0,0 +1,84 @@
+// !LANGUAGE: +NewInference +ProhibitInvisibleAbstractMethodsInSuperclasses
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+// FULL_JDK
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * RELEVANT PLACES: inheritance, overriding -> paragraph 7 -> sentence 1
+ * NUMBER: 8
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ * ISSUES: KT-27825
+ */
+
+
+
+// MODULE: base
+// FILE: AbstractClassCase1.kt
+package base
+
+// TESTCASE NUMBER: 1
+abstract class AbstractClassCase1() {
+    <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> fun priv()
+    protected abstract fun prot()
+    internal abstract fun int()
+    public abstract fun pub()
+
+    <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> val priv1: String
+    protected abstract val prot1: String
+    internal abstract val int1: String
+    public abstract val pub1: String
+}
+
+class Case1 : AbstractClassCase1(){
+    override fun prot() {}
+
+    override fun int() {
+        prot()
+    }
+
+    override fun pub() {}
+
+    override val prot1: String
+        get() = ""
+    override val int1: String
+        get() = ""
+    override val pub1: String
+        get() = ""
+
+}
+
+fun case1(){
+    val a = Case1()
+    a.<!INAPPLICABLE_CANDIDATE!>priv<!>()
+    a.prot()
+    a.int()
+    a.pub()
+
+    a.<!INAPPLICABLE_CANDIDATE!>priv1<!>
+    a.prot1
+    a.int1
+    a.pub1
+}
+
+//MODULE: implBase(base)
+//FILE: Impl.kt
+package implBase
+import base.*
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val a = Case1()
+    a.<!INAPPLICABLE_CANDIDATE!>priv<!>()
+    a.prot()
+    a.int()
+    a.pub()
+
+    a.<!INAPPLICABLE_CANDIDATE!>priv1<!>
+    a.prot1
+    a.int1
+    a.pub1
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.9.fir.kt

@@ -0,0 +1,76 @@
+// !LANGUAGE: +NewInference +ProhibitInvisibleAbstractMethodsInSuperclasses
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+// FULL_JDK
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * RELEVANT PLACES: inheritance, overriding -> paragraph 7 -> sentence 1
+ * NUMBER: 9
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ * ISSUES: KT-27825, KT-35325
+ */
+
+// MODULE: libModule
+// FILE: libModule/BaseJava1.java
+package libModule;
+
+public abstract class BaseJava1 {
+    /*package-private*/ abstract void boojava();
+}
+
+
+// FILE: BaseKotlin1.kt
+package libModule
+
+public abstract class BaseKotlin1 {
+    internal abstract fun bookotlin()
+}
+
+// MODULE: mainModule(libModule)
+// FILE: JavaClassWithAbstractKotlinClass.java
+package mainModule
+import libModule.*
+
+/*
+ * TESTCASE NUMBER: 1
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-35325
+ */
+public class JavaClassWithAbstractKotlinClass {
+
+    public void zoo()
+    {
+        //todo: INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER should be expected
+        BaseKotlin1 baseKotlin = new BaseKotlin1() {};
+
+        BaseKotlin1 baseKotlin = new BaseKotlinImpl();
+        baseKotlin.bookotlin$libModule(); //highlight Error: usage of Kotlin internal declaration from different module
+
+        BaseKotlinImpl baseKotlinImpl = new BaseKotlinImpl();
+        baseKotlinImpl.bookotlin$libModule();  //there is no any Error, but should be
+    }
+
+    class BaseKotlinImpl extends BaseKotlin1 {
+        @Override
+        public void bookotlin$libModule() {
+            System.out.println("wefrgth");
+        }
+    }
+
+}
+
+// FILE: KotlinClassWithAbstractJavaClass.kt
+package mainModule
+import libModule.*
+
+// TESTCASE NUMBER: 2
+class KotlinClassWithAbstractJavaClass() {
+    fun foo() {
+        val baseJava1 = object : BaseJava1() {}
+        val baseKotlin = object : BaseKotlin1() {}
+    }
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.2.fir.kt

@@ -0,0 +1,57 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ * HELPERS: checkType, functions
+ * ISSUES: KT-27825
+ */
+
+// TESTCASE NUMBER: 1
+
+fun case1(){
+    OtherClass().zoooo()
+    checkSubtype<MainClass.Base2>(OtherClass().zoooo())
+}
+
+class MainClass {
+    abstract class Base1() {
+        abstract val a: CharSequence
+        abstract var b: CharSequence
+
+        abstract fun foo(): CharSequence
+    }
+
+    abstract class Base2 : Base1() {
+        abstract fun boo(x: Int = 10)
+    }
+
+}
+
+class OtherClass {
+
+    abstract inner class ImplBase2() : MainClass.Base2() {
+        override var b: CharSequence
+            get() = TODO()
+            set(value) {}
+        override val a: CharSequence = ""
+
+        override fun boo(x: Int) {
+            TODO()
+        }
+
+    }
+
+    fun zoooo(): ImplBase2 {
+        val k = object : ImplBase2() {
+            override fun foo(): CharSequence = ""
+        }
+        return k
+    }
+}

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.3.fir.kt

@@ -0,0 +1,124 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: declarations, classifier-declaration, class-declaration, abstract-classes -> paragraph 2 -> sentence 1
+ * NUMBER: 3
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ * HELPERS: checkType, functions
+ */
+
+
+// TESTCASE NUMBER: 1
+// NOTE: attempt to implement inner abstract class as anonymous class
+open class MainCase1() {
+    private val priv = "privet"
+
+    val implVal = object : MainCase1.InnerAbstractBase() {
+        override fun foo(s: String) {
+            println("object {$s}")
+        }
+    }
+
+    abstract inner class InnerAbstractBase() {
+        protected abstract fun foo(s: String)
+        fun boo() {
+            foo(priv)
+        }
+    }
+}
+
+fun case1() {
+    val main = MainCase1()
+    main.implVal.boo()
+}
+
+
+
+// TESTCASE NUMBER: 2
+//NOTE: attempt to implement inner abstract class in init block
+fun case2() {
+    val main = MainCase2()
+    main.impl.boo()
+}
+
+
+open class MainCase2() {
+    private val priv = "privet"
+
+    abstract inner class InnerAbstractBase() {
+        protected abstract fun foo(s: String)
+        fun boo() {
+            foo(priv)
+        }
+    }
+
+    var impl: InnerAbstractBase
+
+    init {
+        impl = object : MainCase2.InnerAbstractBase() {
+            override fun foo(s: String) {
+            }
+        }
+    }
+}
+
+
+
+//TESTCASE NUMBER: 3
+// NOTE: attempt to inherit inner abstract class as another inner class
+fun case3() {
+    val main = MainCase3()
+    main.ImplInnerAbstractBase().boo()
+}
+
+open class MainCase3() {
+    private val priv = "privet"
+
+    abstract inner class InnerAbstractBase() {
+        protected abstract fun foo(s: String)
+        fun boo() {
+            foo(priv)
+        }
+    }
+
+    inner class ImplInnerAbstractBase : MainCase3.InnerAbstractBase() {
+        override fun foo(s: String) {
+            println("ImplInnerAbstractBase {$s}")
+        }
+    }
+}
+
+
+
+// TESTCASE NUMBER: 4
+// NOTE: attempt to inherit inner abstract class in a outer class function
+fun case4() {
+    val main = MainCase4()
+    main.zoo().boo()
+}
+
+
+open class MainCase4() {
+    private val priv = "privet"
+
+    abstract inner class InnerAbstractBase() {
+        protected abstract fun foo(s: String)
+        fun boo() {
+            foo(priv)
+        }
+    }
+
+    fun zoo(): MainCase4.InnerAbstractBase {
+        class ImplInnerAbstractBaseZoo : MainCase4.InnerAbstractBase() {
+            override fun foo(s: String) {
+                println("zoo fun: {$s}")
+            }
+        }
+        return ImplInnerAbstractBaseZoo()
+    }
+}