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

KT-650 Prohibit creating class without constructor

Browse Source
This commit is contained in:
svtk
2012-01-24 15:41:38 +04:00
parent ee5fcccda9
commit 70d0cd882b
43 changed files with 170 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/Bounds.jet
+1 -1
View File
@@ -3,7 +3,7 @@ package boundsWithSubstitutors
open class A<T>
class B<X : A<X>>()
class C : A<C>
class C : A<C>()
val a = B<C>()
val a1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
compiler/testData/diagnostics/tests/Constructors.jet
+12 -12
View File
@@ -1,14 +1,14 @@
open class NoC
class NoC1 : NoC
class NoC1 : <!SUPERTYPE_NOT_INITIALIZED_DEFAULT!>NoC<!>
class WithC0() : NoC<!NO_CONSTRUCTOR!>()<!>
open class WithC1() : NoC
class NoC2 : <!SUPERTYPE_NOT_INITIALIZED!>WithC1<!>
class NoC3 : WithC1<!PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL!>()<!>
class WithC2() : <!SUPERTYPE_NOT_INITIALIZED!>WithC1<!>
class WithC0() : NoC()
open class WithC1() : <!SUPERTYPE_NOT_INITIALIZED_DEFAULT!>NoC<!>
class NoC2 : <!SUPERTYPE_NOT_INITIALIZED_DEFAULT!>WithC1<!>
class NoC3 : WithC1()
class WithC2() : <!SUPERTYPE_NOT_INITIALIZED_DEFAULT!>WithC1<!>
class NoPC {
<!SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY!>this<!>() {}
class <!CONFLICTING_OVERLOADS!>NoPC<!> {
<!CONFLICTING_OVERLOADS!><!SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST!>this<!>() {}<!>
}
class WithPC0() {
@@ -28,7 +28,7 @@ class WithPC1(a : Int) {
}
class Foo() : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>WithPC0<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST, SYNTAX!>this<!>() {
class Foo() : <!SUPERTYPE_NOT_INITIALIZED_DEFAULT, FINAL_SUPERTYPE!>WithPC0<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST, SYNTAX!>this<!>() {
}
@@ -42,9 +42,9 @@ class WithCPI(x : Int) {
val xy : Int = x
}
class <!PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY!>NoCPI<!> {
val a = <!PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR!>1<!>
class NoCPI {
val a = 1
var ab = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1<!>
get() = 1
set(v) {}
}
}
compiler/testData/diagnostics/tests/NamespaceQualified.jet
+2 -2
View File
@@ -40,14 +40,14 @@ abstract class Iteratee<in I, out O> {
abstract fun done() : O
}
class StrangeIterateeImpl<in I, out O>(val obj: O) : Iteratee<I, O> {
class StrangeIterateeImpl<in I, out O>(val obj: O) : Iteratee<I, O>() {
override fun process(item: I): Iteratee<I, O> = StrangeIterateeImpl<I, O>(obj)
override val isDone = true
override val result = obj
override fun done() = obj
}
abstract class Sum() : Iteratee<Int, Int> {
abstract class Sum() : Iteratee<Int, Int>() {
override fun process(item : Int) : Iteratee<Int, Int> {
return foobar.done<Int>(item);
}
compiler/testData/diagnostics/tests/Objects.jet
+1 -1
View File
@@ -71,7 +71,7 @@ package localObjects
fun test() {
A.x
val b = object : Foo {
val b = object : Foo() {
}
b.foo()
compiler/testData/diagnostics/tests/Override.jet
+14 -14
View File
@@ -11,7 +11,7 @@ package override.normal
}
open class MyClass() : MyTrait, MyAbstractClass {
open class MyClass() : MyTrait, MyAbstractClass() {
override fun foo() {}
override fun bar() {}
@@ -21,21 +21,21 @@ package override.normal
class MyChildClass() : MyClass() {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass<!> : MyTrait, MyAbstractClass {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass<!> : MyTrait, MyAbstractClass() {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!>() : MyTrait, MyAbstractClass {
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!>() : MyTrait, MyAbstractClass() {
override fun foo() {}
override val pr : Unit = #()
override val prr : Unit = #()
}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass3<!>() : MyTrait, MyAbstractClass {
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass3<!>() : MyTrait, MyAbstractClass() {
override fun bar() {}
override val pr : Unit = #()
override val prr : Unit = #()
}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass4<!>() : MyTrait, MyAbstractClass {
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass4<!>() : MyTrait, MyAbstractClass() {
fun <!VIRTUAL_MEMBER_HIDDEN!>foo<!>() {}
val <!VIRTUAL_MEMBER_HIDDEN, MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>pr<!> : Unit
<!NOTHING_TO_OVERRIDE!>override<!> fun other() {}
@@ -65,7 +65,7 @@ package override.generics
val p : T
}
open class MyGenericClass<T>(t : T) : MyTrait<T>, MyAbstractClass<T>, MyProps<T> {
open class MyGenericClass<T>(t : T) : MyTrait<T>, MyAbstractClass<T>(), MyProps<T> {
override fun foo(t: T) = t
override fun bar(t: T) = t
override val p : T = t
@@ -81,31 +81,31 @@ package override.generics
override val p : T = t
}
open class MyClass() : MyTrait<Int>, MyAbstractClass<String> {
open class MyClass() : MyTrait<Int>, MyAbstractClass<String>() {
override fun foo(i: Int) = i
override fun bar(s: String) = s
override val pr : String = "1"
}
abstract class MyAbstractClass1 : MyTrait<Int>, MyAbstractClass<String> {
abstract class MyAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {
override fun foo(i: Int) = i
override fun bar(s: String) = s
}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T> {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass2<!><T, R>(r : R) : MyTrait<T>, MyAbstractClass<R> {
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T>() {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass2<!><T, R>(r : R) : MyTrait<T>, MyAbstractClass<R>() {
<!NOTHING_TO_OVERRIDE!>override<!> fun foo(r: R) = r
<!NOTHING_TO_OVERRIDE!>override<!> val <T> pr : R = r
}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String> {}
abstract class MyLegalAbstractClass1 : MyTrait<Int>, MyAbstractClass<String> {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String>() {}
abstract class MyLegalAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!><T>(t : T) : MyTrait<Int>, MyAbstractClass<Int> {
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!><T>(t : T) : MyTrait<Int>, MyAbstractClass<Int>() {
fun foo(t: T) = t
fun bar(t: T) = t
val <R> pr : T = t
}
abstract class MyLegalAbstractClass2<T>(t : T) : MyTrait<Int>, MyAbstractClass<Int> {
abstract class MyLegalAbstractClass2<T>(t : T) : MyTrait<Int>, MyAbstractClass<Int>() {
fun foo(t: T) = t
fun bar(t: T) = t
val <R> pr : T = t
compiler/testData/diagnostics/tests/PrimaryConstructors.jet
+19 -2
View File
@@ -1,4 +1,6 @@
class <!PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY!>X<!> {
//+JDK
class X {
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>x<!> : Int
}
@@ -10,5 +12,20 @@ class Y1 {
val x : Int get() = 1
}
class Z : Y<!PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL!>()<!> {
class Z : Y() {
}
//KT-650 Prohibit creating class without constructor.
class MyIterable<T> : Iterable<T>
{
override fun iterator(): Iterator<T> = MyIterator()
class MyIterator : Iterator<T>
{
override val hasNext: Boolean = false
override fun next(): T {
throw UnsupportedOperationException()
}
}
}
compiler/testData/diagnostics/tests/SupertypeListChecks.jet
+3 -4
View File
@@ -39,13 +39,12 @@ trait Test6 : <!FINAL_SUPERTYPE!>C1<!> {}
class CTest1() : OC1() {}
class CTest2 : C2 {}
class CTest2 : <!SUPERTYPE_NOT_INITIALIZED_DEFAULT!>C2<!> {}
class CTest3 : C2, <!MANY_CLASSES_IN_SUPERTYPE_LIST!>C3<!> {}
class CTest3 : <!SUPERTYPE_NOT_INITIALIZED_DEFAULT!>C2<!>, <!SUPERTYPE_NOT_INITIALIZED_DEFAULT, MANY_CLASSES_IN_SUPERTYPE_LIST!>C3<!> {}
class CTest4 : T1 {}
class CTest5 : T1, <!SUPERTYPE_APPEARS_TWICE!>T1<!> {}
class CTest6 : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>C1<!> {}
class CTest6 : <!SUPERTYPE_NOT_INITIALIZED_DEFAULT, FINAL_SUPERTYPE!>C1<!> {}
compiler/testData/diagnostics/tests/TraitSupertypeList.jet
+2 -2
View File
@@ -7,5 +7,5 @@ trait Foo<!CONSTRUCTOR_IN_TRAIT!>()<!> : bar<!SUPERTYPE_INITIALIZED_IN_TRAIT!>()
trait Foo2 : bar, Foo {
}
open class Foo1() : bar(), <!SUPERTYPE_NOT_INITIALIZED, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!>, Foo, <!SUPERTYPE_APPEARS_TWICE!>Foo<!><!CONSTRUCTOR_IN_TRAIT!>()<!> {}
open class Foo12 : bar<!PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL!>()<!>, <!SUPERTYPE_NOT_INITIALIZED, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!> {}
open class Foo1() : bar(), <!SUPERTYPE_NOT_INITIALIZED_DEFAULT, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!>, Foo, <!SUPERTYPE_APPEARS_TWICE!>Foo<!><!CONSTRUCTOR_IN_TRAIT!>()<!> {}
open class Foo12 : bar(), <!SUPERTYPE_NOT_INITIALIZED_DEFAULT, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!> {}
compiler/testData/diagnostics/tests/cast/IsErasedAllowParameterSubtype.jet
+1 -1
View File
@@ -5,7 +5,7 @@ import java.util.List;
open class A
class B : A
class B : A()
fun ff(l: Collection<B>) = l is List<out A>
compiler/testData/diagnostics/tests/regressions/Jet11.jet
+1 -1
View File
@@ -1,4 +1,4 @@
// JET-11 Redeclaration & Forward reference for classes cause an exception
open class <!REDECLARATION!>NoC<!>
class NoC1 : NoC
class NoC1 : NoC()
open class <!REDECLARATION!>NoC<!>
compiler/testData/diagnostics/tests/regressions/OverrideResolution.jet
+2 -2
View File
@@ -7,10 +7,10 @@ open class A {
open fun foo() {}
}
open class B : A {
open class B : A() {
override fun foo() {}
}
open class C : B {
open class C : B() {
override fun foo() {}
}