[Spec tests] Add diag tests for abstract classes and prefix increment

2019-12-02 17:20:28 +03:00
parent 44d0a99875
commit 86d072e3aa
17 changed files with 1568 additions and 376 deletions
@@ -0,0 +1,38 @@
+// !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
+ * ISSUES: KT-27825
+ */
+
+// TESTCASE NUMBER: 1
+
+abstract class Base() {
+    <!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun foo() = {}
+    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>fun boo() : Unit<!>
+    abstract val a = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>""<!>
+    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val b<!>
+    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>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()
+}
@@ -0,0 +1,32 @@
+// !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
+ * ISSUES: KT-27825
+ */
+
+// 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 = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>Base0()<!>
+    val b1 = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>Base1()<!>
+    val b2 = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>Base2(1, "1")<!>
+}
+
@@ -0,0 +1,35 @@
+// !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 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check abstract classes can have abstract not implemented members
+ * ISSUES: KT-27825
+ */
+
+// TESTCASE NUMBER: 1
+
+abstract class Base() {
+    abstract fun foo()
+
+    abstract val a: String
+}
+
+class Impl : Base() {
+    override fun foo(): Unit {
+        TODO("not implemented")
+    }
+
+    override val a: String
+        get() = TODO("not implemented")
+
+}
+
+fun case1() {
+    val impl = Impl()
+}
@@ -0,0 +1,129 @@
+// !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
+ * ISSUES: KT-27825
+ */
+
+// 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
+    <!VAR_OVERRIDDEN_BY_VAL!>val<!>  b: Any, override var c: Any, override
+
+ <!VAR_OVERRIDDEN_BY_VAL!>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
+
+     <!VAR_OVERRIDDEN_BY_VAL!>val<!>  b: Any
+        get() = TODO()
+    override var c: Any
+        get() = TODO()
+        set(value) {}
+    override
+
+     <!VAR_OVERRIDDEN_BY_VAL!>val<!>  d: Any
+        get() = TODO()
+
+    override fun foo() {}
+
+    override fun boo(): Any {
+        return ""
+    }
+}
+
+/*
+* TESTCASE NUMBER: 3
+* NOTE: property is not implemented
+*/
+fun case3() {
+    ImplBaseCase3()
+}
+
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>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()
+}
+
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>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() {}
@@ -0,0 +1,100 @@
+// !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
+ * ISSUES: KT-27825
+ */
+
+// 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 <!VAR_OVERRIDDEN_BY_VAL!>val<!> b: Any
+            get() = TODO()
+        override var c: Any
+            get() = TODO()
+            set(value) {}
+        override <!VAR_OVERRIDDEN_BY_VAL!>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 = <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>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 = <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>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
+        }
+    }
+}
@@ -0,0 +1,67 @@
+// !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
+ * ISSUES: KT-27825
+ */
+
+// TESTCASE NUMBER: 1
+abstract class Base {
+    abstract val a: CharSequence
+    abstract var b: CharSequence
+
+    abstract fun foo(): CharSequence
+}
+
+class Case1 : Base() {
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Any<!>
+    {
+        return ""
+    }
+
+    override val a: <!PROPERTY_TYPE_MISMATCH_ON_OVERRIDE!>Any?<!>
+    get() = TODO()
+    override var b: <!VAR_TYPE_MISMATCH_ON_OVERRIDE!>String<!>
+    get() = TODO()
+    set(value)
+    {}
+}
+
+
+/*
+* TESTCASE NUMBER: 2
+*/
+
+class Case2(override val a: String, override var b: <!VAR_TYPE_MISMATCH_ON_OVERRIDE!>String<!>) : Base() {
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>CharSequence?<!> {
+        return ""
+    }
+}
+
+/*
+* TESTCASE NUMBER: 3
+* NOTE: abstract nested class members are not implemented
+*/
+
+class Case3 {
+    <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class ImplBase1<!> : MainClass.Base1() {}
+}
+
+class MainClass {
+    abstract class Base1() {
+        abstract val a: CharSequence
+        abstract var b: CharSequence
+
+        abstract fun foo(): CharSequence
+    }
+
+}
+
+
@@ -0,0 +1,122 @@
+// !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
+ * ISSUES: KT-27825
+ */
+
+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
+
+    <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>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 = <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>object<!> : Impl("a") {
+            override fun foo(): CharSequence = "foo"
+        }
+    }
+}
+
+/*
+* TESTCASE NUMBER: 3
+* NOTE: check abstract member cannot be accessed directly
+*/
+class Case3(override val <!REDECLARATION!>boo<!>: String) : BaseCase3() {
+    override val zoo: String = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
+    override val <!REDECLARATION!>boo<!>: String = super.<!ABSTRACT_SUPER_CALL!>boo<!>
+    override val value: String = super.<!ABSTRACT_SUPER_CALL!>zoo<!>
+    val hoo: String = super.<!ABSTRACT_SUPER_CALL!>zoo<!>
+
+    override fun foo(): String {
+        super.<!ABSTRACT_SUPER_CALL!>foo<!>()
+        super.<!ABSTRACT_SUPER_CALL!>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
+*/
+
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>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
+*/
+
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>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
+*/
+
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class Case6<!>(a: String) : BaseCase6(a) {}
+
+abstract class BaseCase6(val a: String) : java.util.AbstractCollection<String>() {}
+
@@ -0,0 +1,58 @@
+// !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
+ * 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
+
+<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case1<!> : BaseJava() {}
+
+fun case1() {
+    val v = Case1()
+    v.boo(true)
+}
+
+/*
+* TESTCASE NUMBER: 2
+*/
+abstract class AbstractClassCase2 : BaseJava() {}
+
+<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case2<!> : AbstractClassCase2() {}
+
+fun case2() {
+    val v = Case2()
+    v.boo(true)
+}
+
@@ -0,0 +1,83 @@
+// !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() {
+    <!CANNOT_OVERRIDE_INVISIBLE_MEMBER!>override<!> fun foo(b: Boolean?) {}
+}
+
+fun case1() {
+    val v = Case1()
+    v.boo(true)
+}
+
+/*
+* TESTCASE NUMBER: 2
+*/
+abstract class AbstractClassCase2 : BaseJava() {}
+
+class Case2: AbstractClassCase2() {
+    <!CANNOT_OVERRIDE_INVISIBLE_MEMBER!>override<!> fun foo(b: Boolean?) {}
+}
+
+fun case2() {
+    val v = Case2()
+    v.boo(true)
+}
+
+// TESTCASE NUMBER: 3
+
+<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case3<!> : BaseJava() {}
+
+fun case3() {
+    val v = Case3()
+    v.boo(true)
+}
+
+/*
+* TESTCASE NUMBER: 4
+*/
+abstract class AbstractClassCase4 : BaseJava() {}
+
+<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case4<!> : AbstractClassCase4() {}
+
+fun case4() {
+    val v = Case4()
+    v.boo(true)
+}
+
@@ -0,0 +1,97 @@
+// !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() {
+    <!CANNOT_OVERRIDE_INVISIBLE_MEMBER!>override<!> fun foo(b: Boolean?) {}
+}
+
+fun case1() {
+    val v = Case1()
+    v.boo(true)
+
+    val o = object :  BaseKotlin() {
+        <!CANNOT_OVERRIDE_INVISIBLE_MEMBER!>override<!> fun foo(b: Boolean?) {}
+    }
+}
+
+/*
+* TESTCASE NUMBER: 2
+*/
+abstract class AbstractClassCase2 : BaseKotlin() {}
+
+class Case2: AbstractClassCase2() {
+    <!CANNOT_OVERRIDE_INVISIBLE_MEMBER!>override<!> fun foo(b: Boolean?) {}
+}
+
+fun case2() {
+    val v = Case2()
+    v.boo(true)
+
+    val o = object : AbstractClassCase2() {
+        <!CANNOT_OVERRIDE_INVISIBLE_MEMBER!>override<!> fun foo(b: Boolean?) {}
+    }
+}
+
+// TESTCASE NUMBER: 3
+
+<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case3<!> : BaseKotlin() {}
+
+fun case3() {
+    val v = Case3()
+    v.boo(true)
+
+    val o = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>object<!> : BaseKotlin() {}
+}
+
+/*
+* TESTCASE NUMBER: 4
+*/
+abstract class AbstractClassCase4 : BaseKotlin() {}
+
+<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case4<!> : AbstractClassCase4() {}
+
+fun case4() {
+    val v = Case4()
+    v.boo(true)
+    val o = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>object<!> : AbstractClassCase4() {}
+
+}
+
+
+
+
@@ -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
+}
+
+<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>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.<!INVISIBLE_MEMBER!>priv<!>()
+    a.<!INVISIBLE_MEMBER!>prot<!>()
+    a.int()
+    a.pub()
+
+    a.<!INVISIBLE_MEMBER!>priv1<!>
+    a.<!INVISIBLE_MEMBER!>prot1<!>
+    a.int1
+    a.pub1
+}
+
+//MODULE: implBase(base)
+//FILE: Impl.kt
+package implBase
+import base.*
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val a = Case1()
+    a.<!INVISIBLE_MEMBER!>priv<!>()
+    a.<!INVISIBLE_MEMBER!>prot<!>()
+    a.<!INVISIBLE_MEMBER!>int<!>()
+    a.pub()
+
+    a.<!INVISIBLE_MEMBER!>priv1<!>
+    a.<!INVISIBLE_MEMBER!>prot1<!>
+    a.<!INVISIBLE_MEMBER!>int1<!>
+    a.pub1
+}
@@ -0,0 +1,77 @@
+// !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: 1
+ * DESCRIPTION: Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class
+ * ISSUES: KT-27825
+ */
+
+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()
+}
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    val base: Base = BaseImplCase1()
+    val base1: BaseImplCase1 = BaseImplCase1()
+}
+
+class BaseImplCase1() : Base() {
+    override val a: Any
+        get() = TODO()
+    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() {
+        TODO()
+    }
+}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    val base0: Base = BaseImplCase2(1, "1", 1.2, mutableListOf({ 1 }, { 4 }, { throw Exception() }))
+    val base1 = BaseImplCase2(1, "1", 1.2, mutableListOf({ 1 }, { 4 }, { throw Exception() }))
+    val base: BaseImplCase2 = BaseImplCase2(1, "1", 1.2, mutableListOf({ 1 }, { 4 }, { throw Exception() }))
+
+    val a1: Any = base.a
+    base.a = 123
+
+    val b1: Any = base.b
+    base.b = 3
+
+    val c1 = base.c
+    base.c = Exception ()
+
+    val d1 = base.d
+    base.d = ""
+}
+
+class BaseImplCase2(override var a: Any, override var b: Any, override var c: Any, override var d: Any = "5") : Base() {
+    override fun foo() {}
+
+    override fun boo() {}
+}
@@ -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(){
+    <!DEBUG_INFO_EXPRESSION_TYPE("OtherClass.ImplBase2")!>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
+    }
+}
@@ -0,0 +1,116 @@
+{
+  "1": {
+    "neg": {
+      "2": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "check abstract classes cannot be instantiated directly",
+          "unexpectedBehaviour": false
+        }
+      ],
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "check abstract classes cannot be instantiated directly",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg/2.1.kt",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "check abstract classes can have abstract not implemented members",
+          "unexpectedBehaviour": false
+        }
+      ]
+    },
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "check abstract classes can have abstract not implemented members",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  },
+  "2": {
+    "neg": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "check abstract classes can have abstract not implemented members",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg/1.1.kt",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 2,
+          "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "Abstract classes may contain abstract members, which should be implemented in an anonymous class that inherits from that abstract type",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "attempt to implement abstract members with invalid types",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 2,
+          "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "Abstract classes may contain abstract members, which should be implemented in an inner class that inherits from that abstract type",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 2,
+          "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class",
+          "unexpectedBehaviour": false
+        }
+      ]
+    },
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 1,
+          "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 2,
+          "description": "Abstract classes may contain one or more abstract members, which should be implemented in a subtype of this abstract class",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}