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

Test directory renamed to 'diagnostics' which reflects its contents

Browse Source
This commit is contained in:
Andrey Breslav
2011-12-01 14:39:14 +03:00
parent 8cee193f47
commit 8e8d74e199
212 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/checkerTestUtil/test.jet
+15
View File
@@ -0,0 +1,15 @@
fun foo(u : Unit) : Int = 1
fun test() : Int {
foo(1)
val a : fun() : Unit = {
foo(1)
}
return 1 - "1"
}
class A() {
val x : Int = foo1(xx)
}
fun foo1() {}
compiler/testData/diagnostics/quick/Abstract.jet
+243
View File
@@ -0,0 +1,243 @@
// +JDK
namespace abstract
class MyClass() {
//properties
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
val a1: Int = 1
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a2: Int
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a3: Int = 1
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int private set
var b1: Int = 0; private set
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b2: Int private set
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b3: Int = 0; private set
var <!MUST_BE_INITIALIZED!>c<!>: Int set(v: Int) { $c = v }
var c1: Int = 0; set(v: Int) { $c1 = v }
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c2: Int set(v: Int) { $c2 = v }
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e2: Int get() = a
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e3: Int = 0; get() = a
//methods
fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
fun g() {}
<!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> fun h()
<!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
abstract class MyAbstractClass() {
//properties
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
val a1: Int = 1
abstract val a2: Int
abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int private set
var b1: Int = 0; private set
abstract var b2: Int private set
abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
var <!MUST_BE_INITIALIZED!>c<!>: Int set(v: Int) { $c = v }
var c1: Int = 0; set(v: Int) { $c1 = v }
abstract var c2: Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
abstract val e2: Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
//methods
fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
fun g() {}
abstract fun h()
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
trait MyTrait {
//properties
val a: Int
val a1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>1<!>
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val a2: Int
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
var b: Int private set
var b1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; private set
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var b2: Int private set
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
var <!BACKING_FIELD_IN_TRAIT!>c<!>: Int set(v: Int) { $c = v }
var <!BACKING_FIELD_IN_TRAIT!>c1<!>: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; set(v: Int) { $c1 = v }
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var c2: Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; get() = a
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val e2: Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
//methods
fun f()
fun g() {}
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> fun h()
<!REDUNDANT_MODIFIER_IN_TRAIT, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var k: Int <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
enum class MyEnum() {
//properties
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
val a1: Int = 1
abstract val a2: Int
abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int private set
var b1: Int = 0; private set
abstract var b2: Int private set
abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
var <!MUST_BE_INITIALIZED!>c<!>: Int set(v: Int) { $c = v }
var c1: Int = 0; set(v: Int) { $c1 = v }
abstract var c2: Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
abstract val e2: Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
//methods
fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
fun g() {}
abstract fun h()
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
abstract enum class MyAbstractEnum() {}
namespace MyNamespace {
//properties
val <!MUST_BE_INITIALIZED!>a<!>: Int
val a1: Int = 1
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val a2: Int
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val a3: Int = 1
var <!MUST_BE_INITIALIZED!>b<!>: Int private set
var b1: Int = 0; private set
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var b2: Int private set
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var b3: Int = 0; private set
var <!MUST_BE_INITIALIZED!>c<!>: Int set(v: Int) { $c = v }
var c1: Int = 0; set(v: Int) { $c1 = v }
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var c2: Int set(v: Int) { $c2 = v }
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val e2: Int get() = a
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val e3: Int = 0; get() = a
//methods
fun <!NON_MEMBER_FUNCTION_NO_BODY!>f<!>()
fun g() {}
<!NON_MEMBER_ABSTRACT_FUNCTION!>abstract<!> fun h()
<!NON_MEMBER_ABSTRACT_FUNCTION!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var <!MUST_BE_INITIALIZED!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
//creating an instance
abstract class B1(
val i: Int,
val s: String
) {
}
class B2() : B1(1, "r") {}
abstract class B3(i: Int) {
this(): this(1)
}
fun foo(<!UNUSED_PARAMETER!>c<!>: B3) {
val <!UNUSED_VARIABLE!>a<!> = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B3()<!>
val <!UNUSED_VARIABLE!>b<!> = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B1(2, "s")<!>
}
compiler/testData/diagnostics/quick/AnonymousInitializerVarAndConstructor.jet
+10
View File
@@ -0,0 +1,10 @@
// http://youtrack.jetbrains.net/issue/KT-419
class A(w: Int) {
var c = w
{
c = 81
}
}
compiler/testData/diagnostics/quick/AnonymousInitializers.jet
+34
View File
@@ -0,0 +1,34 @@
class NoC {
<!ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR!>{
}<!>
val a : Int get() = 1
<!ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR!>{
}<!>
}
class WithC() {
val x : Int
{
$x = 1
<!UNRESOLVED_REFERENCE!>$y<!> = 2
val b = x
}
val a : Int get() = 1
{
val z = <!UNRESOLVED_REFERENCE!>b<!>
val zz = x
val zzz = <!NO_BACKING_FIELD!>$a<!>
}
this(a : Int) : this() {
val <!UNUSED_VARIABLE!>b<!> = x
}
}
compiler/testData/diagnostics/quick/AutoCreatedIt.jet
+32
View File
@@ -0,0 +1,32 @@
fun text() {
"direct:a" to "mock:a"
"direct:a" on {it.body == "<hello/>"} to "mock:a"
"direct:a" on {it => it.body == "<hello/>"} to "mock:a"
bar <!TYPE_MISMATCH!>{1}<!>
bar <!TYPE_MISMATCH!>{<!UNRESOLVED_REFERENCE!>it<!> + 1}<!>
bar {it, it1 => it}
bar1 {1}
bar1 {it + 1}
bar2 <!TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>
bar2 {1}
bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> => it}<!>
}
fun bar(<!UNUSED_PARAMETER!>f<!> : fun (Int, Int) : Int) {}
fun bar1(<!UNUSED_PARAMETER!>f<!> : fun (Int) : Int) {}
fun bar2(<!UNUSED_PARAMETER!>f<!> : fun () : Int) {}
fun String.to(<!UNUSED_PARAMETER!>dest<!> : String) {
}
fun String.on(<!UNUSED_PARAMETER!>predicate<!> : fun (s : URI) : Boolean) : URI {
return URI(this)
}
class URI(val body : Any) {
fun to(<!UNUSED_PARAMETER!>dest<!> : String) {}
}
compiler/testData/diagnostics/quick/AutocastAmbiguitites.jet
+16
View File
@@ -0,0 +1,16 @@
trait B {
fun bar() {}
}
class C() {
fun bar() {
}
}
fun test(a : Any?) {
if (a is B) {
if (a is C) {
a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar()<!>;
}
}
}
compiler/testData/diagnostics/quick/AutocastsForStableIdentifiers.jet
+91
View File
@@ -0,0 +1,91 @@
namespace example;
namespace ns {
val y : Any? = 2
}
object Obj {
val y : Any? = 2
}
class AClass() {
class object {
val y : Any? = 2
}
}
val x : Any? = 1
fun Any?.vars(<!UNUSED_PARAMETER!>a<!>: Any?) : Int {
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>b<!>: Int = 0
if (ns.y is Int) {
b = <!UNUSED_VALUE!>ns.y<!>
}
if (ns.y is Int) {
b = <!UNUSED_VALUE!>example.ns.y<!>
}
if (example.ns.y is Int) {
b = <!UNUSED_VALUE!>ns.y<!>
}
if (example.ns.y is Int) {
b = <!UNUSED_VALUE!>example.ns.y<!>
}
// if (namespace.bottles.ns.y is Int) {
// b = ns.y
// }
if (Obj.y is Int) {
b = <!UNUSED_VALUE!>Obj.y<!>
}
if (example.Obj.y is Int) {
b = <!UNUSED_VALUE!>Obj.y<!>
}
if (AClass.y is Int) {
b = <!UNUSED_VALUE!>AClass.y<!>
}
if (example.AClass.y is Int) {
b = <!UNUSED_VALUE!>AClass.y<!>
}
if (x is Int) {
b = <!UNUSED_VALUE!>x<!>
}
if (example.x is Int) {
b = <!UNUSED_VALUE!>x<!>
}
if (example.x is Int) {
b = <!UNUSED_VALUE!>example.x<!>
}
return 1
}
fun Any?.foo() : Int {
if (this is Int)
return this
if (this@foo is Int)
return this
if (this@foo is Int)
return this@foo
if (this is Int)
return this@foo
return 1
}
trait T {}
open class C {
fun foo() {
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>t<!> : T? = null
if (this is T) {
t = <!UNUSED_VALUE!>this<!>
}
if (this is T) {
t = <!UNUSED_VALUE!>this@C<!>
}
if (this@C is T) {
t = <!UNUSED_VALUE!>this<!>
}
if (this@C is T) {
t = <!UNUSED_VALUE!>this@C<!>
}
}
}
compiler/testData/diagnostics/quick/Basic.jet
+15
View File
@@ -0,0 +1,15 @@
fun foo(<!UNUSED_PARAMETER!>u<!> : Unit) : Int = 1
fun test() : Int {
foo(<!TYPE_MISMATCH!>1<!>)
val <!UNUSED_VARIABLE!>a<!> : fun() : Unit = {
foo(<!TYPE_MISMATCH!>1<!>)
}
return 1 <!NONE_APPLICABLE!>-<!> "1"
}
class A() {
val x : Int = <!TYPE_MISMATCH!>foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)<!>
}
fun foo1() {}
compiler/testData/diagnostics/quick/BinaryCallsOnNullableValues.jet
+41
View File
@@ -0,0 +1,41 @@
class A() {
fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Boolean = false
}
class B() {
fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Boolean? = false
}
class C() {
fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Int = 0
}
fun f(): Unit {
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>x<!>: Int? = 1
x = 1
x <!UNSAFE_INFIX_CALL!>+<!> 1
x <!UNSAFE_INFIX_CALL!>plus<!> 1
x <!UNSAFE_INFIX_CALL!><<!> 1
x <!UNSAFE_INFIX_CALL!>+=<!> 1
x == 1
x != 1
<!EQUALITY_NOT_APPLICABLE!>A() == 1<!>
B() <!RESULT_TYPE_MISMATCH!>==<!> 1
C() <!RESULT_TYPE_MISMATCH!>==<!> 1
<!EQUALITY_NOT_APPLICABLE!>x === "1"<!>
<!EQUALITY_NOT_APPLICABLE!>x !== "1"<!>
x === 1
x !== 1
x<!UNSAFE_INFIX_CALL!>..<!>2
<!TYPE_MISMATCH!>x<!> in 1..2
val y : Boolean? = true
false || <!TYPE_MISMATCH!>y<!>
<!TYPE_MISMATCH!>y<!> && true
<!TYPE_MISMATCH!>y<!> && <!TYPE_MISMATCH!>1<!>
}
compiler/testData/diagnostics/quick/Bounds.jet
+40
View File
@@ -0,0 +1,40 @@
namespace boundsWithSubstitutors {
open class A<T>
class B<X : A<X>>()
class C : A<C>
val a = B<C>()
val a1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
class X<A, B : A>()
val b = X<Any, X<A<C>, C>>
val b0 = X<Any, <!UPPER_BOUND_VIOLATED!>Any?<!>>
val b1 = X<Any, X<A<C>, <!UPPER_BOUND_VIOLATED!>String<!>>>
}
open class A {}
open class B<T : A>()
abstract class C<T : B<<!UPPER_BOUND_VIOLATED!>Int<!>>, X : fun (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) : (B<<!UPPER_BOUND_VIOLATED!>Any<!>>, B<A>)>() : B<<!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any<!>>() { // 2 errors
val a = B<<!UPPER_BOUND_VIOLATED!>Char<!>>() // error
abstract val x : fun (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) : B<<!UPPER_BOUND_VIOLATED!>Any<!>>
}
fun test() {
foo<<!UPPER_BOUND_VIOLATED!>Int?<!>>()
foo<Int>()
bar<Int?>()
bar<Int>()
bar<<!UPPER_BOUND_VIOLATED!>Double?<!>>()
bar<<!UPPER_BOUND_VIOLATED!>Double<!>>()
1.buzz<<!UPPER_BOUND_VIOLATED!>Double<!>>()
}
fun foo<T : Any>() {}
fun bar<T : Int?>() {}
fun <T : <!FINAL_UPPER_BOUND!>Int<!>> Int.buzz() : Unit {}
compiler/testData/diagnostics/quick/BreakContinue.jet
+85
View File
@@ -0,0 +1,85 @@
class C {
fun f (<!UNUSED_PARAMETER!>a<!> : Boolean, <!UNUSED_PARAMETER!>b<!> : Boolean) {
@b (while (true)
@a {
<!NOT_A_LOOP_LABEL!>break@f<!>
break
break@b
<!NOT_A_LOOP_LABEL!>break@a<!>
})
<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue<!>
@b (while (true)
@a {
<!NOT_A_LOOP_LABEL!>continue@f<!>
continue
continue@b
<!NOT_A_LOOP_LABEL!>continue@a<!>
})
<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break<!>
<!NOT_A_LOOP_LABEL!>continue@f<!>
<!NOT_A_LOOP_LABEL!>break@f<!>
}
fun containsBreak(a: String?, <!UNUSED_PARAMETER!>b<!>: String?) {
while (a == null) {
break;
}
a<!UNSAFE_CALL!>.<!>compareTo("2")
}
fun notContainsBreak(a: String?, b: String?) {
while (a == null) {
while (b == null) {
break;
}
}
a.compareTo("2")
}
fun containsBreakWithLabel(a: String?) {
@loop while(a == null) {
break@loop
}
a?.compareTo("2")
}
fun containsIllegalBreak(a: String?) {
@loop while(a == null) {
<!NOT_A_LOOP_LABEL!>break<!UNRESOLVED_REFERENCE!>@label<!><!>
}
a.compareTo("2")
}
fun containsBreakToOuterLoop(a: String?, b: String?) {
@loop while(b == null) {
while(a == null) {
break@loop
}
a.compareTo("2")
}
}
fun containsBreakInsideLoopWithLabel(a: String?, array: Array<Int>) {
@ while(a == null) {
for (el in array) {
break@
}
}
a<!UNSAFE_CALL!>.<!>compareTo("2")
}
fun unresolvedBreak(a: String?, array: Array<Int>) {
while(a == null) {
@ for (el in array) {
break
}
if (true) break else <!NOT_A_LOOP_LABEL!>break<!UNRESOLVED_REFERENCE!>@<!><!>
}
a<!UNSAFE_CALL!>.<!>compareTo("2")
}
}
compiler/testData/diagnostics/quick/Builders.jet
+123
View File
@@ -0,0 +1,123 @@
// +JDK
import java.util.*
namespace html {
abstract class Factory<T> {
abstract fun create() : T
}
abstract class Element
class TextElement(val text : String) : Element
abstract class Tag(val name : String) : Element {
val children = ArrayList<Element>()
val attributes = HashMap<String, String>()
protected fun initTag<T : Element>(init : fun T.() : Unit) : T
where class object T : Factory<T>{
val tag = T.create()
tag.init()
children.add(tag)
return tag
}
}
abstract class TagWithText(name : String) : Tag(name) {
fun String.plus() {
children.add(TextElement(this))
}
}
class HTML() : TagWithText("html") {
class object : Factory<HTML> {
override fun create() = HTML()
}
fun head(init : fun Head.() : Unit) = initTag<Head>(init)
fun body(init : fun Body.() : Unit) = initTag<Body>(init)
}
class Head() : TagWithText("head") {
class object : Factory<Head> {
override fun create() = Head()
}
fun title(init : fun Title.() : Unit) = initTag<Title>(init)
}
class Title() : TagWithText("title")
abstract class BodyTag(name : String) : TagWithText(name) {
}
class Body() : BodyTag("body") {
class object : Factory<Body> {
override fun create() = Body()
}
fun b(init : fun B.() : Unit) = initTag<B>(init)
fun p(init : fun P.() : Unit) = initTag<P>(init)
fun h1(init : fun H1.() : Unit) = initTag<H1>(init)
fun a(href : String, init : fun A.() : Unit) {
val a = initTag<A>(init)
a.href = href
}
}
class B() : BodyTag("b")
class P() : BodyTag("p")
class H1() : BodyTag("h1")
class A() : BodyTag("a") {
var href : String
get() = attributes["href"]
set(value) { attributes["href"] = value }
}
fun Map<String, String>.set(key : String, value : String) = this.put(key, value)
fun html(init : fun HTML.() : Unit) : HTML {
val html = HTML()
html.init()
return html
}
}
namespace foo {
import html.*
fun result(args : Array<String>) =
html {
head {
title {+"XML encoding with Groovy"}
}
body {
h1 {+"XML encoding with Groovy"}
p {+"this format can be used as an alternative markup to XML"}
// an element with attributes and text content
a(href = "http://groovy.codehaus.org") {+"Groovy"}
// mixed content
p {
+"This is some"
b {+"mixed"}
+"text. For more see the"
a(href = "http://groovy.codehaus.org") {+"Groovy"}
+"project"
}
p {+"some text"}
// content generated by
p {
for (arg in args)
+arg
}
}
}
}
compiler/testData/diagnostics/quick/Casts.jet
+16
View File
@@ -0,0 +1,16 @@
fun test() : Unit {
var x : Int? = 0
var y : Int = 0
x : Int?
y : Int
x as Int : Int
y <!USELESS_CAST!>as<!> Int : Int
x <!USELESS_CAST!>as<!> Int? : Int?
y <!USELESS_CAST_STATIC_ASSERT_IS_FINE!>as<!> Int? : Int?
x as? Int : Int?
y <!USELESS_CAST!>as?<!> Int : Int?
x <!USELESS_CAST!>as?<!> Int? : Int?
y <!USELESS_CAST_STATIC_ASSERT_IS_FINE!>as?<!> Int? : Int?
()
}
compiler/testData/diagnostics/quick/ClassObjectCannotAccessClassFields.jet
+9
View File
@@ -0,0 +1,9 @@
// http://youtrack.jetbrains.net/issue/KT-20
class A() {
val x = 1
class object {
val y = <!UNRESOLVED_REFERENCE!>x<!>
}
}
compiler/testData/diagnostics/quick/ClassObjects.jet
+32
View File
@@ -0,0 +1,32 @@
// +JDK
namespace Jet86
class A {
class object {
val x = 1
}
<!MANY_CLASS_OBJECTS!>class object { // error
val x = 1
}<!>
}
class B() {
val x = 12
}
object b {
<!CLASS_OBJECT_NOT_ALLOWED!>class object {
val x = 1
}<!> // error
}
val a = A.x
val c = <!NO_CLASS_OBJECT!>B<!>.x
val d = b.<!UNRESOLVED_REFERENCE!>x<!>
val s = <!NO_CLASS_OBJECT!>System<!> // error
fun test() {
System.out?.println()
java.lang.System.out?.println()
}
compiler/testData/diagnostics/quick/ConflictingOverloads.jet
+97
View File
@@ -0,0 +1,97 @@
// http://youtrack.jetbrains.net/issue/KT-424
class A {
<!CONFLICTING_OVERLOADS!>fun a(<!UNUSED_PARAMETER!>a<!>: Int): Int<!> = 0
<!CONFLICTING_OVERLOADS!>fun a(<!UNUSED_PARAMETER!>a<!>: Int)<!> {
}
<!CONFLICTING_OVERLOADS!>fun b()<!> {
}
<!CONFLICTING_OVERLOADS!>fun b()<!> {
}
}
namespace deepSpace {
<!CONFLICTING_OVERLOADS!>fun c(<!UNUSED_PARAMETER!>s<!>: String)<!> {
}
<!CONFLICTING_OVERLOADS!>fun c(<!UNUSED_PARAMETER!>s<!>: String)<!> {
}
class B {
<!CONFLICTING_OVERLOADS!>fun d(<!UNUSED_PARAMETER!>s<!>: String)<!> {
}
<!CONFLICTING_OVERLOADS!>fun d(<!UNUSED_PARAMETER!>s<!>: String)<!> {
}
}
}
// check no error in overload in different namespaces
namespace ns1 {
fun e() = 1
}
namespace ns2 {
fun e() = 1
}
namespace ns3 {
namespace ns1 {
fun e() = 1
}
}
// check same rules apply for ext functions
namespace extensionFunctions {
<!CONFLICTING_OVERLOADS!>fun Int.qwe(<!UNUSED_PARAMETER!>a<!>: Float)<!> = 1
<!CONFLICTING_OVERLOADS!>fun Int.qwe(<!UNUSED_PARAMETER!>a<!>: Float)<!> = 2
fun Int.rty() = 3
fun String.rty() = 4
}
// check no error when regular function and extension function have same name
namespace extensionAndRegular {
fun who() = 1
fun Int.who() = 1
}
// constructor vs. fun overload
namespace constructorVsFun {
class <!CONFLICTING_OVERLOADS!>a()<!> { }
<!CONFLICTING_OVERLOADS!>fun a()<!> = 1
class Tram {
<!CONFLICTING_OVERLOADS!>fun f()<!> { }
class <!CONFLICTING_OVERLOADS!>f()<!> { }
}
class Yvayva {
class object {
<!CONFLICTING_OVERLOADS!>fun fghj()<!> { }
class <!CONFLICTING_OVERLOADS!>fghj()<!> { }
}
}
class Rtyu {
fun ololo() { }
class object {
class ololo() { }
}
}
}
compiler/testData/diagnostics/quick/Constants.jet
+8
View File
@@ -0,0 +1,8 @@
fun test() {
1 : Byte
1 : Int
<!TYPE_MISMATCH, TYPE_MISMATCH!>1<!> : Double
1 <!USELESS_CAST!>as<!> Byte
1 <!USELESS_CAST!>as<!> Int
<!ERROR_COMPILE_TIME_VALUE!>1<!> <!CAST_NEVER_SUCCEEDS!>as<!> Double
}
compiler/testData/diagnostics/quick/Constructors.jet
+50
View File
@@ -0,0 +1,50 @@
open class NoC
class NoC1 : 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 NoPC {
<!SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY!>this<!>() {}
}
class WithPC0() {
this(a : Int) : this() {}
}
class WithPC1(a : Int) {
<!SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST!>this<!>() {}
this(b : Long) : this("") {}
this(s : String) : this(1) {}
this(b : Char) : <!NONE_APPLICABLE!>this<!>("", 2) {}
this(b : Byte) : this(""), <!MANY_CALLS_TO_THIS!>this(1)<!> {}
}
class Foo() : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>WithPC0<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST, SYNTAX!>this<!>() {
}
class WithCPI_Dup(x : Int) {
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>x<!> : Int
}
class WithCPI(x : Int) {
val a = 1
val b : Int = $a
val xy : Int = x
}
class <!PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY!>NoCPI<!> {
val a = <!PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR!>1<!>
var ab = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1<!>
get() = 1
set(v) {}
}
compiler/testData/diagnostics/quick/CovariantOverrideType.jet
+29
View File
@@ -0,0 +1,29 @@
// +JDK
trait A {
fun foo() : Int = 1
fun foo2() : Int = 1
fun foo1() : Int = 1
val a : Int
val a1 : Int
val <T> g : Iterator<T>
fun <T> g() : T
fun <T> g1() : T
}
abstract class B() : A {
override fun <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>foo<!>() {
}
override fun foo2() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Unit<!> {
}
override val a : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Double<!> = 1.dbl
override val <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>a1<!> = 1.dbl
abstract override fun <X> g() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Int<!>
abstract override fun <X> g1() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>java.util.List<X><!>
abstract override val <X> g : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Iterator<Int><!>
}
compiler/testData/diagnostics/quick/CyclicHierarchy.jet
+30
View File
@@ -0,0 +1,30 @@
trait A {
fun foo() {}
}
trait B : A, <!CYCLIC_INHERITANCE_HIERARCHY!>E<!> {}
trait C : B {}
trait D : <!CYCLIC_INHERITANCE_HIERARCHY!>B<!> {}
trait E : <!CYCLIC_INHERITANCE_HIERARCHY!>F<!> {}
trait F : <!CYCLIC_INHERITANCE_HIERARCHY!>D<!>, C {}
trait G : F {}
trait H : F {}
val a : A? = null
val b : B? = null
val c : C? = null
val d : D? = null
val e : E? = null
val f : F? = null
val g : G? = null
val h : H? = null
fun test() {
a?.foo()
b?.foo()
c?.foo()
d?.foo()
e?.<!UNRESOLVED_REFERENCE!>foo<!>()
f?.foo()
g?.foo()
h?.foo()
}
compiler/testData/diagnostics/quick/DefaultValuesTypechecking.jet
+5
View File
@@ -0,0 +1,5 @@
val x = ""
fun bar(<!UNUSED_PARAMETER!>x<!> : Int = <!TYPE_MISMATCH!>""<!>, <!UNUSED_PARAMETER!>y<!> : Int = <!TYPE_MISMATCH!>x<!>, <!UNUSED_PARAMETER!>z<!> : String = <!UNRESOLVED_REFERENCE!>y<!>) {
}
compiler/testData/diagnostics/quick/DeferredTypes.jet
+3
View File
@@ -0,0 +1,3 @@
trait T {
val a = <!PROPERTY_INITIALIZER_IN_TRAIT!><!UNRESOLVED_REFERENCE!>Foo<!>.bar()<!>
}
compiler/testData/diagnostics/quick/DelegationAndOverriding.jet
+38
View File
@@ -0,0 +1,38 @@
//namespace override
trait T {
fun foo()
val v : Int
}
open class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Br<!>(t : T) : T {
}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Br3<!>(t : T) : Br(t) {
}
open class Br1(t : T) : T by t {
}
class Br2(t : T) : Br1(t) {
}
trait G<T> {
fun foo(t : T) : T
}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>GC<!>() : G<Int> {
}
open class GC1(g : G<Int>) : G<Int> by g {
}
open class GC2(g : G<Int>) : GC1(g) {
}
compiler/testData/diagnostics/quick/DelegationNotTotrait.jet
+13
View File
@@ -0,0 +1,13 @@
open class Foo() {
}
class Barrr() : <!DELEGATION_NOT_TO_TRAIT!>Foo<!> by Foo() {}
trait T {}
class Br(t : T) : T by t {}
open enum class E() {}
class Test2(e : E) : <!DELEGATION_NOT_TO_TRAIT!>E<!> by e {}
compiler/testData/diagnostics/quick/Dollar.jet
+15
View File
@@ -0,0 +1,15 @@
namespace dollar
open class `$$$$$`() {
}
open class `$`() {
}
open class `$$`(`$$$$` : `$$$$$`?) : `$`() {
val `$$$` : `$$$$$`?
{
$`$$$` = `$$$$`
}
open public fun `$$$$$$`() : `$$$$$`? {
return `$$$`
}
}
compiler/testData/diagnostics/quick/Enums.jet
+10
View File
@@ -0,0 +1,10 @@
enum class List<out T>(val size : Int) {
Nil : List<Nothing>(0) {
val a = 1
}
Cons<out T>(val head : T, val tail : List<T>) : List<T>(tail.size + 1)
}
val foo = List.Nil
val foo1 = foo.a
compiler/testData/diagnostics/quick/ExtensionFunctions.jet
+73
View File
@@ -0,0 +1,73 @@
// +JDK
fun Int?.optint() : Unit {}
val Int?.optval : Unit = ()
fun <T, E> T.foo(<!UNUSED_PARAMETER!>x<!> : E, y : A) : T {
y.plus(1)
y plus 1
y + 1.0
this<!UNNECESSARY_SAFE_CALL!>?.<!>minus<T>(this)
return this
}
class A
fun A.plus(<!UNUSED_PARAMETER!>a<!> : Any) {
1.foo()
true.<!NONE_APPLICABLE!>foo<!>()
1
}
fun A.plus(<!UNUSED_PARAMETER!>a<!> : Int) {
1
}
fun <T> T.minus(<!UNUSED_PARAMETER!>t<!> : T) : Int = 1
fun test() {
val <!UNUSED_VARIABLE!>y<!> = 1.abs
}
val Int.abs : Int
get() = if (this > 0) this else -this;
val <T> T.<!MUST_BE_INITIALIZED!>foo<!> : T
fun Int.foo() = this
namespace null_safety {
fun parse(<!UNUSED_PARAMETER!>cmd<!>: String): Command? { return null }
class Command() {
// fun equals(other : Any?) : Boolean
val foo : Int = 0
}
fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun Any?.equals1(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun Any.equals2(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun main(args: Array<String>) {
System.out?.print(1)
val command = parse("")
command.foo
command.equals(null)
command?.equals(null)
command.equals1(null)
command<!UNNECESSARY_SAFE_CALL!>?.<!>equals1(null)
val c = Command()
c<!UNNECESSARY_SAFE_CALL!>?.<!>equals2(null)
if (command == null) 1
}
}
compiler/testData/diagnostics/quick/ExtensionsCalledOnSuper.jet
+21
View File
@@ -0,0 +1,21 @@
trait T {
fun foo() {}
fun buzz() {}
fun buzz1(i : Int) {}
}
fun T.bar() {}
fun T.buzz() {}
fun T.buzz1() {}
class C : T {
fun test() {
fun T.buzz() {}
fun T.buzz1() {}
super.foo() // OK
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>.bar() // Error
super.buzz() // OK, resolved to a member
super.buzz1<!NO_VALUE_FOR_PARAMETER!>()<!> // Resolved to a member, but error: no parameter passed where required
}
}
compiler/testData/diagnostics/quick/ForRangeConventions.jet
+83
View File
@@ -0,0 +1,83 @@
// +JDK
import java.util.*;
class NotRange1() {
}
abstract class NotRange2() {
abstract fun iterator() : Unit
}
abstract class ImproperIterator1 {
abstract fun hasNext() : Boolean
}
abstract class NotRange3() {
abstract fun iterator() : ImproperIterator1
}
abstract class ImproperIterator2 {
abstract fun next() : Boolean
}
abstract class NotRange4() {
abstract fun iterator() : ImproperIterator2
}
abstract class ImproperIterator3 {
abstract fun hasNext() : Int
abstract fun next() : Int
}
abstract class NotRange5() {
abstract fun iterator() : ImproperIterator3
}
abstract class AmbiguousHasNextIterator {
abstract fun hasNext() : Boolean
val hasNext : Boolean get() = false
abstract fun next() : Int
}
abstract class NotRange6() {
abstract fun iterator() : AmbiguousHasNextIterator
}
abstract class ImproperIterator4 {
val hasNext : Int get() = 1
abstract fun next() : Int
}
abstract class NotRange7() {
abstract fun iterator() : ImproperIterator3
}
abstract class GoodIterator {
abstract fun hasNext() : Boolean
abstract fun next() : Int
}
abstract class Range0() {
abstract fun iterator() : GoodIterator
}
abstract class Range1() {
abstract fun iterator() : Iterator<Int>
}
fun test(notRange1: NotRange1, notRange2: NotRange2, notRange3: NotRange3, notRange4: NotRange4, notRange5: NotRange5, notRange6: NotRange6, notRange7: NotRange7, range0: Range0, range1: Range1) {
for (i in <!ITERATOR_MISSING!>notRange1<!>);
for (i in <!HAS_NEXT_MISSING, NEXT_MISSING!>notRange2<!>);
for (i in <!NEXT_MISSING!>notRange3<!>);
for (i in <!HAS_NEXT_MISSING!>notRange4<!>);
for (i in <!HAS_NEXT_FUNCTION_TYPE_MISMATCH!>notRange5<!>);
for (i in <!HAS_NEXT_PROPERTY_AND_FUNCTION_AMBIGUITY!>notRange6<!>);
for (i in <!HAS_NEXT_FUNCTION_TYPE_MISMATCH!>notRange7<!>);
for (i in range0);
for (i in range1);
for (i in (ArrayList<Int>() : List<Int>));
}
compiler/testData/diagnostics/quick/FunctionCalleeExpressions.jet
+82
View File
@@ -0,0 +1,82 @@
namespace foo
fun Any.foo() : fun() : Unit {
return {}
}
fun Any.foo1() : fun(i : Int) : Unit {
return {}
}
fun foo2() : fun(i : fun()) : Unit {
return {}
}
fun fooT1<T>(t : T) : fun() : T {
return {t}
}
fun fooT2<T>() : fun(t : T) : T {
return {it}
}
fun main(args : Array<String>) {
args.foo()()
args.foo1()<!NO_VALUE_FOR_PARAMETER!>()<!>
<!UNRESOLVED_REFERENCE!>a<!>.foo1()()
<!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
args.foo1()(1)
args.foo1()(<!TYPE_MISMATCH!>"1"<!>)
<!UNRESOLVED_REFERENCE!>a<!>.foo1()("1")
<!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
foo2()({})
foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
(foo2()){}
(foo2())<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>x<!> => }<!>
foo2()(<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>x<!> => }<!>)
val a = fooT1(1)()
a : Int
val b = fooT2<Int>()(1)
b : Int
fooT2()(1) // : Any?
<!CALLEE_NOT_A_FUNCTION!>1<!>()
<!CALLEE_NOT_A_FUNCTION!>1<!>{}
<!CALLEE_NOT_A_FUNCTION!>1<!>(){}
}
fun f() : fun Int.() : Unit = {}
fun main1() {
1.{Int.() => 1}();
{1}()
{(x : Int) => x}(1)
1.{Int.(x : Int) => x}(1)
@l{1}()
1.({Int.() => 1})()
1.(f())()
1.if(true){f()}else{f()}()
1.if(true){Int.() => 1}else{f()}()
1.if(true){Int.() => 1}else{Int.() => 1}()
1.<!CALLEE_NOT_A_FUNCTION!>"sdf"<!>()
1.<!ILLEGAL_SELECTOR!>"sdf"<!>
1.<!ILLEGAL_SELECTOR!>{}<!>
1.<!ILLEGAL_SELECTOR!>if (true) {}<!>
}
fun test() {
{(x : Int) => 1}<!NO_VALUE_FOR_PARAMETER!>()<!>
<!MISSING_RECEIVER!>{Int.() => 1}<!>()
<!TYPE_MISMATCH!>"sd"<!>.{Int.() => 1}()
val i : Int? = null
i<!UNSAFE_CALL!>.<!>{Int.() => 1}()
{}<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>()
1<!UNNECESSARY_SAFE_CALL!>?.<!>{Int.() => 1}()
1.<!NO_RECEIVER_ADMITTED!>{}<!>()
}
compiler/testData/diagnostics/quick/FunctionReturnTypes.jet
+214
View File
@@ -0,0 +1,214 @@
// +JDK
fun none() {}
fun unitEmptyInfer() {}
fun unitEmpty() : Unit {}
fun unitEmptyReturn() : Unit {return}
fun unitIntReturn() : Unit {return <!TYPE_MISMATCH!>1<!>}
fun unitUnitReturn() : Unit {return ()}
fun test1() : Any = {<!RETURN_TYPE_MISMATCH, RETURN_NOT_ALLOWED!>return<!>}
fun test2() : Any = @a {return@a 1}
fun test3() : Any { <!RETURN_TYPE_MISMATCH!>return<!> }
fun test4(): fun(): Unit = { <!RETURN_TYPE_MISMATCH, RETURN_NOT_ALLOWED!>return@test4<!> }
fun test5(): Any = @{ return@ }
fun test6(): Any = {<!RETURN_NOT_ALLOWED!>return 1<!>}
fun bbb() {
return <!TYPE_MISMATCH!>1<!>
}
fun foo(expr: StringBuilder): Int {
val c = 'a'
when(c) {
0.chr => throw Exception("zero")
else => throw Exception("nonzero" + c)
}
}
fun unitShort() : Unit = ()
fun unitShortConv() : Unit = <!TYPE_MISMATCH!>1<!>
fun unitShortNull() : Unit = <!TYPE_MISMATCH!>null<!>
fun intEmpty() : Int <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
fun intShortInfer() = 1
fun intShort() : Int = 1
//fun intBlockInfer() {1}
fun intBlock() : Int {return 1}
fun intBlock1() : Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>1<!>}
fun intString(): Int = <!TYPE_MISMATCH!>"s"<!>
fun intFunctionLiteral(): Int = <!TYPE_MISMATCH!>{ 10 }<!>
fun blockReturnUnitMismatch() : Int {<!RETURN_TYPE_MISMATCH!>return<!>}
fun blockReturnValueTypeMismatch() : Int {return <!ERROR_COMPILE_TIME_VALUE!>3.4<!>}
fun blockReturnValueTypeMatch() : Int {return 1}
fun blockReturnValueTypeMismatchUnit() : Int {return <!TYPE_MISMATCH!>()<!>}
fun blockAndAndMismatch() : Int {
<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>true && false<!>
}
fun blockAndAndMismatch1() : Int {
return <!TYPE_MISMATCH!>true && false<!>
}
fun blockAndAndMismatch2() : Int {
<!UNREACHABLE_CODE!>(return <!ERROR_COMPILE_TIME_VALUE!>true<!>) && (return <!ERROR_COMPILE_TIME_VALUE!>false<!>)<!>
}
fun blockAndAndMismatch3() : Int {
<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>true || false<!>
}
fun blockAndAndMismatch4() : Int {
return <!TYPE_MISMATCH!>true || false<!>
}
fun blockAndAndMismatch5() : Int {
<!UNREACHABLE_CODE!>(return <!ERROR_COMPILE_TIME_VALUE!>true<!>) || (return <!ERROR_COMPILE_TIME_VALUE!>false<!>)<!>
}
fun blockReturnValueTypeMatch1() : Int {
return if (1 > 2) <!ERROR_COMPILE_TIME_VALUE!>1.0<!> else <!ERROR_COMPILE_TIME_VALUE!>2.0<!>
}
fun blockReturnValueTypeMatch2() : Int {
return <!TYPE_MISMATCH!>if (1 > 2) 1<!>
}
fun blockReturnValueTypeMatch3() : Int {
return <!TYPE_MISMATCH!>if (1 > 2) else 1<!>
}
fun blockReturnValueTypeMatch4() : Int {
if (1 > 2)
return <!ERROR_COMPILE_TIME_VALUE!>1.0<!>
else return <!ERROR_COMPILE_TIME_VALUE!>2.0<!>
}
fun blockReturnValueTypeMatch5() : Int {
if (1 > 2)
return <!ERROR_COMPILE_TIME_VALUE!>1.0<!>
return <!ERROR_COMPILE_TIME_VALUE!>2.0<!>
}
fun blockReturnValueTypeMatch6() : Int {
if (1 > 2)
else return <!ERROR_COMPILE_TIME_VALUE!>1.0<!>
return <!ERROR_COMPILE_TIME_VALUE!>2.0<!>
}
fun blockReturnValueTypeMatch7() : Int {
if (1 > 2)
<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>1.0<!>
else <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>2.0<!>
}
fun blockReturnValueTypeMatch8() : Int {
if (1 > 2)
1.0
else 2.0
return 1
}
fun blockReturnValueTypeMatch9() : Int {
<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>if (1 > 2)
<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>1.0<!><!>
}
fun blockReturnValueTypeMatch10() : Int {
return <!TYPE_MISMATCH!>if (1 > 2)
1<!>
}
fun blockReturnValueTypeMatch11() : Int {
<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>if (1 > 2)
else <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>1.0<!><!>
}
fun blockReturnValueTypeMatch12() : Int {
if (1 > 2)
return 1
else return <!ERROR_COMPILE_TIME_VALUE!>1.0<!>
}
fun blockNoReturnIfValDeclaration(): Int {
<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>val <!UNUSED_VARIABLE!>x<!> = 1<!>
}
fun blockNoReturnIfEmptyIf(): Int {
if (1 < 2) <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!> else <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
}
fun blockNoReturnIfUnitInOneBranch(): Int {
if (1 < 2) {
return 1
} else {
if (3 < 4) <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{
}<!> else {
return 2
}
}
}
fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else <!TYPE_MISMATCH!>{}<!>
fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else 2
val a = <!RETURN_NOT_ALLOWED!>return 1<!>
class A() {
this(a : Int) : this() {
if (a == 1)
return
return <!TYPE_MISMATCH!>1<!>
}
}
fun illegalConstantBody(): Int = <!TYPE_MISMATCH!>"s"<!>
fun illegalConstantBlock(): String {
return <!ERROR_COMPILE_TIME_VALUE!>1<!>
}
fun illegalIfBody(): Int =
if (1 < 2) <!ERROR_COMPILE_TIME_VALUE!>'a'<!> else { <!ERROR_COMPILE_TIME_VALUE!>1.0<!> }
fun illegalIfBlock(): Boolean {
if (1 < 2)
return false
else { return <!ERROR_COMPILE_TIME_VALUE!>1<!> }
}
fun illegalReturnIf(): Char {
return if (1 < 2) 'a' else { <!ERROR_COMPILE_TIME_VALUE!>1<!> }
}
fun returnNothing(): Nothing {
throw 1
}
fun f(): Int {
if (1 < 2) { return 1 } else returnNothing()
}
fun f1(): Int = if (1 < 2) 1 else returnNothing()
public fun <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>f2<!>() = 1
class B() {
protected fun <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>f<!>() = "ss"
}
fun testFunctionLiterals() {
val <!UNUSED_VARIABLE!>endsWithVarDeclaration<!> : fun() : Boolean = {
<!EXPECTED_TYPE_MISMATCH!>val x = 2<!>
}
val <!UNUSED_VARIABLE!>endsWithAssignment<!> = { () : Int =>
var x = 1
<!EXPECTED_TYPE_MISMATCH!>x = 333<!>
}
val <!UNUSED_VARIABLE!>endsWithReAssignment<!> = { () : Int =>
var x = 1
<!ASSIGNMENT_TYPE_MISMATCH!>x += 333<!>
}
val <!UNUSED_VARIABLE!>endsWithFunDeclaration<!> : fun() : String = {
var x = 1
x = 333
<!EXPECTED_TYPE_MISMATCH!>fun meow() : Unit {}<!>
}
val <!UNUSED_VARIABLE!>endsWithObjectDeclaration<!> : fun() : Int = {
var x = 1
x = 333
<!EXPECTED_TYPE_MISMATCH!>object A {}<!>
}
val <!UNUSED_VARIABLE!>expectedUnitReturnType1<!> = { () : Unit =>
val x = 1
}
val <!UNUSED_VARIABLE!>expectedUnitReturnType2<!> = { () : Unit =>
fun meow() : Unit {}
object A {}
}
}
compiler/testData/diagnostics/quick/GenericArgumentConsistency.jet
+42
View File
@@ -0,0 +1,42 @@
trait A<in T> {}
trait B<T> : A<Int> {}
trait C<T> : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>B<T>, A<T><!> {}
trait C1<T> : B<T>, A<Any> {}
trait D : <!INCONSISTENT_TYPE_PARAMETER_VALUES, INCONSISTENT_TYPE_PARAMETER_VALUES!>C<Boolean>, B<Double><!>{}
trait A1<out T> {}
trait B1 : A1<Int> {}
trait B2 : A1<Any>, B1 {}
trait BA1<T> {}
trait BB1 : BA1<Int> {}
trait BB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>BA1<Any>, BB1<!> {}
namespace x {
trait AA1<out T> {}
trait AB1 : AA1<Int> {}
trait AB3 : AA1<Comparable<Int>> {}
trait AB2 : AA1<Number>, AB1, AB3 {}
}
namespace x2 {
trait AA1<out T> {}
trait AB1 : AA1<Any> {}
trait AB3 : AA1<Comparable<Int>> {}
trait AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}
}
namespace x3 {
trait AA1<in T> {}
trait AB1 : AA1<Any> {}
trait AB3 : AA1<Comparable<Int>> {}
trait AB2 : AA1<Number>, AB1, AB3 {}
}
namespace sx2 {
trait AA1<in T> {}
trait AB1 : AA1<Int> {}
trait AB3 : AA1<Comparable<Int>> {}
trait AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}
}
compiler/testData/diagnostics/quick/GenericFunctionIsLessSpecific.jet
+8
View File
@@ -0,0 +1,8 @@
// A generic funciton is always less specific than a non-generic one
fun foo<T>(<!UNUSED_PARAMETER!>t<!> : T) : Unit {}
fun foo(<!UNUSED_PARAMETER!>i<!> : Int) : Int = 1
fun test() {
foo(1) : Int
foo("s") : Unit
}
compiler/testData/diagnostics/quick/IllegalModifiers.jet
+21
View File
@@ -0,0 +1,21 @@
namespace illegal_modifiers
abstract class A() {
<!INCOMPATIBLE_MODIFIERS!>abstract<!> <!INCOMPATIBLE_MODIFIERS!>final<!> fun f()
abstract <!REDUNDANT_MODIFIER!>open<!> fun g()
<!INCOMPATIBLE_MODIFIERS!>final<!> <!INCOMPATIBLE_MODIFIERS!>open<!> fun h() {}
open var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>r<!>: String
get
<!ILLEGAL_MODIFIER!>abstract<!> protected set
}
<!TRAIT_CAN_NOT_BE_FINAL!>final<!> trait T {}
class FinalClass() {
<!NON_FINAL_MEMBER_IN_FINAL_CLASS!>open<!> fun foo() {}
val i: Int = 1
<!ILLEGAL_MODIFIER!>open<!> get(): Int = $i
var j: Int = 1
<!ILLEGAL_MODIFIER!>open<!> set(v: Int) {}
}
compiler/testData/diagnostics/quick/ImportResolutionOrder.jet
+23
View File
@@ -0,0 +1,23 @@
// KT-355 Resolve imports after all symbols are built
namespace a {
import b.*
val x : X = X()
}
namespace b {
class X() {
}
}
namespace c {
import d.X
val x : X = X()
}
namespace d {
class X() {
}
}
compiler/testData/diagnostics/quick/IncDec.jet
+46
View File
@@ -0,0 +1,46 @@
class IncDec() {
fun inc() : IncDec = this
fun dec() : IncDec = this
}
fun testIncDec() {
var x = IncDec()
x++
++x
x--
--x
x = <!UNUSED_CHANGED_VALUE!>x++<!>
x = <!UNUSED_CHANGED_VALUE!>x--<!>
x = ++x
x = <!UNUSED_VALUE!>--x<!>
}
class WrongIncDec() {
fun inc() : Int = 1
fun dec() : Int = 1
}
fun testWrongIncDec() {
var x = WrongIncDec()
x<!RESULT_TYPE_MISMATCH!>++<!>
<!RESULT_TYPE_MISMATCH!>++<!>x
x<!RESULT_TYPE_MISMATCH!>--<!>
<!RESULT_TYPE_MISMATCH!>--<!>x
}
class UnitIncDec() {
fun inc() : Unit {}
fun dec() : Unit {}
}
fun testUnitIncDec() {
var x = UnitIncDec()
x++
++x
x--
--x
x = <!TYPE_MISMATCH, UNUSED_CHANGED_VALUE!>x++<!>
x = <!TYPE_MISMATCH, UNUSED_CHANGED_VALUE!>x--<!>
x = <!TYPE_MISMATCH!>++x<!>
x = <!TYPE_MISMATCH, UNUSED_VALUE!>--x<!>
}
compiler/testData/diagnostics/quick/IncorrectCharacterLiterals.jet
+37
View File
@@ -0,0 +1,37 @@
// http://youtrack.jetbrains.net/issue/KT-451
// KT-451 Incorrect character literals cause assertion failures
fun ff() {
val <!UNUSED_VARIABLE!>b<!> = <!ERROR_COMPILE_TIME_VALUE!>''<!>
val <!UNUSED_VARIABLE!>c<!> = <!ERROR_COMPILE_TIME_VALUE!>'23'<!>
val <!UNUSED_VARIABLE!>d<!> = <!ERROR_COMPILE_TIME_VALUE!>'a<!>
val <!UNUSED_VARIABLE!>e<!> = <!ERROR_COMPILE_TIME_VALUE!>'ab<!>
val <!UNUSED_VARIABLE!>f<!> = <!ERROR_COMPILE_TIME_VALUE!>'\'<!>
}
fun test() {
'a'
'\n'
'\t'
'\b'
'\r'
'\"'
'\''
'\\'
'\$'
<!ERROR_COMPILE_TIME_VALUE!>'\x'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\123'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\ra'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\000'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\000'<!>
'\u0000'
'\u000a'
'\u000A'
<!ERROR_COMPILE_TIME_VALUE!>'\u'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\u0'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\u00'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\u000'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\u000z'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\\u000'<!>
<!ERROR_COMPILE_TIME_VALUE!>'\'<!>
}
compiler/testData/diagnostics/quick/InferNullabilityInThenBlock.jet
+9
View File
@@ -0,0 +1,9 @@
fun ff(<!UNUSED_PARAMETER!>a<!>: String) = 1
fun gg() {
val a: String? = ""
if (a != null) {
ff(a)
}
}
compiler/testData/diagnostics/quick/InnerClassClassObject.jet
+20
View File
@@ -0,0 +1,20 @@
// http://youtrack.jetbrains.net/issue/KT-449
class A {
class B {
<!CLASS_OBJECT_NOT_ALLOWED!>class object { }<!>
}
}
class B {
class object {
class B {
class object {
class C {
class object { }
}
}
}
}
}
compiler/testData/diagnostics/quick/IsExpressions.jet
+7
View File
@@ -0,0 +1,7 @@
fun test() {
if (1 is Int) {
if (1 is <!INCOMPATIBLE_TYPES!>Boolean<!>) {
}
}
}
compiler/testData/diagnostics/quick/LValueAssignment.jet
+143
View File
@@ -0,0 +1,143 @@
namespace lvalue_assignment
open class B() {
var b: Int = 2
val c: Int = 34
}
class C() : B() {
var x = 4
fun foo(<!UNUSED_PARAMETER!>c<!>: C) {
this.x = 34
this.b = 123
super.b = 23
<!VAL_REASSIGNMENT!>this.c<!> = 34
super.c = 3535 //repeat for 'c'
<!VARIABLE_EXPECTED!>getInt()<!> = 12
}
fun foo1(<!UNUSED_PARAMETER!>c<!>: C) {
<!VAL_REASSIGNMENT!>super.c<!> = 34
}
fun bar(c: C) {
<!VARIABLE_EXPECTED!>this<!> = c //should be an error
}
}
fun getInt() = 0
class D() {
class B() {
fun foo() {
<!VARIABLE_EXPECTED!>this@D<!> = D()
}
}
}
fun cannotBe(var <!UNUSED_PARAMETER!>i<!>: Int) {
<!UNRESOLVED_REFERENCE!>z<!> = 30;
<!VARIABLE_EXPECTED!>()<!> = ();
(<!VARIABLE_EXPECTED!>i <!USELESS_CAST!>as<!> Int<!>) = 34
(<!VARIABLE_EXPECTED!>i is Int<!>) = false
<!VARIABLE_EXPECTED!>A()<!> = A()
<!VARIABLE_EXPECTED!>5<!> = 34
}
fun canBe(var i: Int, val j: Int) {
(i: Int) = <!UNUSED_VALUE!>36<!>
(@label i) = <!UNUSED_VALUE!>34<!>
(<!VAL_REASSIGNMENT!>j<!>: Int) = <!UNUSED_VALUE!>36<!>
(@label j) = <!UNUSED_VALUE!>34<!> //repeat for j
val a = A()
(@ a.a) = 3894
}
fun canBe2(val j: Int) {
(@label <!VAL_REASSIGNMENT!>j<!>) = <!UNUSED_VALUE!>34<!>
}
class A() {
var a: Int = 3
}
class Test() {
fun testIllegalValues() {
<!VARIABLE_EXPECTED!>1<!> += 23
(<!VARIABLE_EXPECTED!>1<!> : Int) += 43
(@l <!VARIABLE_EXPECTED!>1<!>) += 23
<!VARIABLE_EXPECTED!>getInt()<!> += 343
(@f <!VARIABLE_EXPECTED!>getInt()<!>) += 343
(<!VARIABLE_EXPECTED!>getInt()<!> : Int) += 343
<!VARIABLE_EXPECTED!>1<!>++
(@r <!VARIABLE_EXPECTED!>1<!>)++
(<!VARIABLE_EXPECTED!>1<!> : Int)++
<!VARIABLE_EXPECTED!>getInt()<!>++
(@m <!VARIABLE_EXPECTED!>getInt()<!>)++
(<!VARIABLE_EXPECTED!>getInt()<!> : Int)++
this<!UNRESOLVED_REFERENCE!>++<!>
var s : String = "r"
s += "ss"
s += this
s += (@a 2)
}
fun testVariables() {
var a: Int = 34
val b: Int = 34
a += 34
(@l a) += 34
(a : Int) += 34
<!VAL_REASSIGNMENT!>b<!> += 34
a++
(@ a)++
(a : Int)++
(a)++
}
fun testVariables1() {
val b: Int = 34
(@l <!VAL_REASSIGNMENT!>b<!>) += 34
//repeat for b
(b : Int) += 34
(b) += 3
}
fun testArrays(a: Array<Int>, ab: Ab) {
a[3] = 4
a[4]++
a[6] += 43
<!VARIABLE_EXPECTED!>ab.getArray()<!>[54] = 23
<!VARIABLE_EXPECTED!>ab.getArray()<!>[54]++
(@f a)[3] = 4
(a : Array<Int>)[4]++
(<!VARIABLE_EXPECTED!>ab.getArray()<!> : Array<Int>)[54] += 43
<!UNRESOLVED_REFERENCE!>this[54]<!> = 34
}
}
fun Array<Int>.checkThis() {
this[45] = 34
this[352]++
this[35] += 234
}
abstract class Ab {
abstract fun getArray() : Array<Int>
}
compiler/testData/diagnostics/quick/MultipleBounds.jet
+72
View File
@@ -0,0 +1,72 @@
namespace Jet87
open class A() {
fun foo() : Int = 1
}
trait B {
fun bar() : Double = 1.0;
}
class C() : A(), B
class D() {
class object : A(), B {}
}
class Test1<T : A>()
where
T : B,
<!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T, // error
class object T : A,
class object T : B,
class object <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T
{
fun test(t : T) {
T.foo()
T.bar()
t.foo()
t.bar()
}
}
fun test() {
Test1<<!UPPER_BOUND_VIOLATED!>B<!>>()
Test1<<!UPPER_BOUND_VIOLATED!>A<!>>()
Test1<C>()
}
class Foo() {}
class Bar<T : <!FINAL_UPPER_BOUND!>Foo<!>>
class Buzz<T> where T : <!FINAL_UPPER_BOUND!>Bar<<!UPPER_BOUND_VIOLATED!>Int<!>><!>, T : <!UNRESOLVED_REFERENCE!>nioho<!>
class X<T : <!FINAL_UPPER_BOUND!>Foo<!>>
class Y<<!CONFLICTING_UPPER_BOUNDS!>T<!> : <!FINAL_UPPER_BOUND!>Foo<!>> where T : <!FINAL_UPPER_BOUND!>Bar<Foo><!>
fun <T : A> test2(t : T)
where
T : B,
<!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T,
class object <!NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER!>B<!> : T,
class object T : B,
class object T : A
{
T.foo()
T.bar()
t.foo()
t.bar()
}
val t1 = test2<<!UPPER_BOUND_VIOLATED!>A<!>>(A())
val t2 = test2<<!UPPER_BOUND_VIOLATED!>B<!>>(C())
val t3 = test2<C>(C())
class Test<<!CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS!>T<!>>
where
class object T : <!FINAL_CLASS_OBJECT_UPPER_BOUND!>Foo<!>,
class object T : A {}
val <T, B : T> x : Int = 0
compiler/testData/diagnostics/quick/NamedArgumentsAndDefaultValues.jet
+23
View File
@@ -0,0 +1,23 @@
fun foo(<!UNUSED_PARAMETER!>a<!> : Int = 1, <!UNUSED_PARAMETER!>b<!> : String = "abc") {
}
fun bar(<!UNUSED_PARAMETER!>x<!> : Int = 1, <!UNUSED_PARAMETER!>y<!> : Int = 1, <!UNUSED_PARAMETER!>z<!> : String) {
}
fun test() {
foo()
foo(2)
foo(<!TYPE_MISMATCH!>""<!>)
foo(b = "")
foo(1, "")
foo(a = 2)
foo(1, "", <!TOO_MANY_ARGUMENTS!>""<!>)
bar(z = "")
bar<!NO_VALUE_FOR_PARAMETER!>()<!>
bar<!NO_VALUE_FOR_PARAMETER!>("")<!>
bar(1, 1, "")
bar(1, 1, "")
bar(1, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>z<!> = "")
bar<!NO_VALUE_FOR_PARAMETER!>(1, <!UNRESOLVED_REFERENCE, MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>zz<!> = "", <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!><!UNRESOLVED_REFERENCE!>zz<!>.foo<!>)<!>
}
compiler/testData/diagnostics/quick/NamespaceAsExpression.jet
+8
View File
@@ -0,0 +1,8 @@
namespace root
namespace a {
}
val x = <!EXPRESSION_EXPECTED_NAMESPACE_FOUND!>a<!>
val y2 = <!NAMESPACE_IS_NOT_AN_EXPRESSION!>namespace<!>
compiler/testData/diagnostics/quick/NamespaceInExpressionPosition.jet
+13
View File
@@ -0,0 +1,13 @@
// +JDK
namespace foo
class X {}
val s = <!EXPRESSION_EXPECTED_NAMESPACE_FOUND!>java<!>
val ss = <!NO_CLASS_OBJECT!>System<!>
val sss = <!NO_CLASS_OBJECT!>X<!>
val xs = java.<!EXPRESSION_EXPECTED_NAMESPACE_FOUND!>lang<!>
val xss = java.lang.<!NO_CLASS_OBJECT!>System<!>
val xsss = foo.<!NO_CLASS_OBJECT!>X<!>
val xssss = <!EXPRESSION_EXPECTED_NAMESPACE_FOUND!>foo<!>
compiler/testData/diagnostics/quick/NamespaceQualified.jet
+65
View File
@@ -0,0 +1,65 @@
// +JDK
namespace foobar
namespace a {
import java.*
val a : util.List<Int>? = null
val a1 : <!UNRESOLVED_REFERENCE!>List<!><Int>? = null
}
abstract class Foo<T>() {
abstract val x : T<Int>
}
namespace a {
import java.util.*
val b : List<Int>? = a
val b1 : <!UNRESOLVED_REFERENCE!>util<!>.List<Int>? = a
}
val x1 = a.a
val y1 = a.b
/////////////////////////////////////////////////////////////////////////
fun done<O>(result : O) : Iteratee<Any?, O> = StrangeIterateeImpl<Any?, O>(result)
abstract class Iteratee<in I, out O> {
abstract fun process(item : I) : Iteratee<I, O>
abstract val isDone : Boolean
abstract val result : O
abstract fun done() : 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> {
override fun process(item : Int) : Iteratee<Int, Int> {
return foobar.done<Int>(item);
}
abstract override val isDone : Boolean
abstract override val result : Int
abstract override fun done() : Int
}
abstract class Collection<E> : Iterable<E> {
fun iterate<O>(var iteratee : Iteratee<E, O>) : O {
for (x in this) {
val it = iteratee.process(x)
if (it.isDone) return it.result
iteratee = it
}
return iteratee.done()
}
}
compiler/testData/diagnostics/quick/Nullability.jet
+282
View File
@@ -0,0 +1,282 @@
// +JDK
fun test() {
val a : Int? = 0
if (a != null) {
a.plus(1)
}
else {
a?.plus(1)
}
val out : java.io.PrintStream? = null//= System.out
val ins = System.`in`
out?.println()
ins?.read()
if (ins != null) {
ins.read()
out?.println()
if (out != null) {
ins.read();
out.println();
}
}
if (out != null && ins != null) {
ins.read();
out.println();
}
if (out == null) {
out?.println()
} else {
out.println()
}
if (out != null && ins != null || out != null) {
ins?.read();
out.println();
}
if (out == null || out.println(0) == ()) {
out?.println(1)
}
else {
out.println(2)
}
if (out != null && out.println() == ()) {
out.println();
}
else {
out?.println();
}
if (out == null || out != null && out.println() == ()) {
out?.println();
}
else {
out.println();
}
if (1 == 2 || out != null && out.println(1) == ()) {
out?.println(2);
}
else {
out?.println(3)
}
out?.println()
ins?.read()
if (ins != null) {
ins.read()
out?.println()
if (out != null) {
ins.read();
out.println();
}
}
if (out != null && ins != null) {
ins.read();
out.println();
}
if (out == null) {
out?.println()
} else {
out.println()
}
if (out != null && ins != null || out != null) {
ins?.read();
out.println();
}
if (out == null || out.println(0) == ()) {
out?.println(1)
}
else {
out.println(2)
}
if (out != null && out.println() == ()) {
out.println();
}
else {
out?.println();
}
if (out == null || out != null && out.println() == ()) {
out?.println();
}
else {
out.println();
}
if (1 == 2 || out != null && out.println(1) == ()) {
out?.println(2);
}
else {
out?.println(3)
}
if (1 > 2) {
if (out == null) return;
out.println();
}
out?.println();
while (out != null) {
out.println();
}
out?.println();
while (out == null) {
out?.println();
}
out.println()
}
fun f(out : String?) {
out?.get(0)
if (out != null) else return;
out.get(0)
}
fun f1(out : String?) {
out?.get(0)
if (out != null) else {
1 + 2
return;
}
out.get(0)
}
fun f2(out : String?) {
out?.get(0)
if (out == null) {
1 + 2
return;
}
out.get(0)
}
fun f3(out : String?) {
out?.get(0)
if (out == null) {
1 + 2
return;
}
else {
1 + 2
}
out.get(0)
}
fun f4(s : String?) {
s?.get(0)
while (1 < 2 && s != null) {
s.get(0)
}
s?.get(0)
while (s == null || 1 < 2) {
s?.get(0)
}
s.get(0)
}
fun f5(s : String?) {
s?.get(0)
while (1 < 2 && s != null) {
s.get(0)
}
s?.get(0)
while (s == null || 1 < 2) {
if (1 > 2) break
s?.get(0)
}
s?.get(0);
}
fun f6(s : String?) {
s?.get(0)
do {
s?.get(0)
if (1 < 2) break;
} while (s == null)
s?.get(0)
do {
s?.get(0)
} while (s == null)
s.get(0)
}
fun f7(s : String?, t : String?) {
s?.get(0)
if (!(s == null)) {
s.get(0)
}
s?.get(0)
if (!(s != null)) {
s?.get(0)
}
else {
s.get(0)
}
s?.get(0)
if (!!(s != null)) {
s.get(0)
}
else {
s?.get(0)
}
s?.get(0)
t?.get(0)
if (!(s == null || t == null)) {
s.get(0)
t.get(0)
}
else {
s?.get(0)
t?.get(0)
}
s?.get(0)
t?.get(0)
if (!(s == null && s == null)) {
s.get(0)
t?.get(0)
}
else {
s?.get(0)
t?.get(0)
}
}
fun f8(b : String?, a : String) {
b?.get(0)
if (b == a) {
b.get(0);
}
b?.get(0)
if (a == b) {
b.get(0)
}
if (a != b) {
b?.get(0)
}
else {
b.get(0)
}
}
fun f9(a : Int?) : Int {
if (a != null)
return a
return 1
}
compiler/testData/diagnostics/quick/Objects.jet
+83
View File
@@ -0,0 +1,83 @@
namespace toplevelObjectDeclarations {
open class Foo(y : Int) {
open fun foo() : Int = 1
}
class T : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {}
object A : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {
val x : Int = 2
fun test() : Int {
return x + foo()
}
}
object B : <!UNRESOLVED_REFERENCE!>A<!> {}
val x = A.foo()
val y = object : Foo(x) {
{
x + 12
}
override fun foo() : Int = 1
}
val z = y.foo()
}
namespace nestedObejcts {
object A {
val b = B
val d = A.B.A
object B {
val a = A
val e = B.A
object A {
val a = A
val b = B
val x = nestedObejcts.A.B.A
val y = this<!AMBIGUOUS_LABEL!>@A<!>
}
}
}
object B {
val b = B
val c = A.B
}
val a = A
val b = B
val c = A.B
val d = A.B.A
val e = B.<!UNRESOLVED_REFERENCE!>A<!>.B
}
namespace localObjects {
object A {
val x : Int = 0
}
open class Foo {
fun foo() : Int = 1
}
fun test() {
A.x
val b = object : Foo {
}
b.foo()
object B {
fun foo() {}
}
B.foo()
}
val bb = <!UNRESOLVED_REFERENCE!>B<!>.foo()
}
compiler/testData/diagnostics/quick/Override.jet
+113
View File
@@ -0,0 +1,113 @@
namespace override
namespace normal {
trait MyTrait {
fun foo()
val pr : Unit
}
abstract class MyAbstractClass {
abstract fun bar()
abstract val prr : Unit
}
open class MyClass() : MyTrait, MyAbstractClass {
override fun foo() {}
override fun bar() {}
override val pr : Unit = ()
override val prr : Unit = ()
}
class MyChildClass() : MyClass() {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass<!> : 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 {
override fun bar() {}
override val pr : Unit = ()
override val prr : Unit = ()
}
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() {}
<!NOTHING_TO_OVERRIDE!>override<!> val otherPr : Int = 1
}
class MyChildClass1() : MyClass() {
fun <!VIRTUAL_MEMBER_HIDDEN!>foo<!>() {}
val <!VIRTUAL_MEMBER_HIDDEN!>pr<!> : Unit = ()
override fun bar() {}
override val prr : Unit = ()
}
}
namespace generics {
trait MyTrait<T> {
fun foo(t: T) : T
}
abstract class MyAbstractClass<T> {
abstract fun bar(t: T) : T
abstract val pr : T
}
trait MyProps<T> {
val p : 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
override val pr : T = t
}
class MyChildClass() : MyGenericClass<Int>(1) {}
class MyChildClass1<T>(t : T) : MyGenericClass<T>(t) {}
class MyChildClass2<T>(t : T) : MyGenericClass<T>(t) {
fun <!VIRTUAL_MEMBER_HIDDEN!>foo<!>(t: T) = t
val <!VIRTUAL_MEMBER_HIDDEN!>pr<!> : T = t
override fun bar(t: T) = t
override val p : T = t
}
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> {
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> {
<!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!>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> {
fun foo(t: T) = t
fun bar(t: T) = t
val <R> pr : T = t
}
}
compiler/testData/diagnostics/quick/OverridingVarByVal.jet
+15
View File
@@ -0,0 +1,15 @@
open class Var() {
open var v : Int = 1
}
trait VarT {
var v : Int
}
class Val() : Var(), VarT {
override <!VAR_OVERRIDDEN_BY_VAL!>val<!> v : Int = 1
}
class Var2() : Var() {
override var v : Int = 1
}
compiler/testData/diagnostics/quick/PrimaryConstructors.jet
+14
View File
@@ -0,0 +1,14 @@
class <!PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY!>X<!> {
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>x<!> : Int
}
open class Y() {
val x : Int = 2
}
class Y1 {
val x : Int get() = 1
}
class Z : Y<!PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL!>()<!> {
}
compiler/testData/diagnostics/quick/ProjectionOnFunctionArgumentErrror.jet
+4
View File
@@ -0,0 +1,4 @@
fun test() {
fun <T> foo(){}
foo<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>in Int<!>>()
}
compiler/testData/diagnostics/quick/ProjectionsInSupertypes.jet
+6
View File
@@ -0,0 +1,6 @@
trait A<T> {}
trait B<T> {}
trait C<T> {}
trait D<T> {}
trait Test : A<<!PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE!>in<!> Int>, B<<!PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE!>out<!> Int>, C<<!PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE!>*<!>><!NULLABLE_SUPERTYPE!>?<!><!NULLABLE_SUPERTYPE!>?<!><!NULLABLE_SUPERTYPE!>?<!>, D<Int> {}
compiler/testData/diagnostics/quick/Properties.jet
+29
View File
@@ -0,0 +1,29 @@
var x : Int = 1 + x
get() : Int = 1
set(<!REF_SETTER_PARAMETER!>ref<!> value : <!WRONG_SETTER_PARAMETER_TYPE!>Long<!>) {
$x = value.int
$x = <!TYPE_MISMATCH!>1.lng<!>
}
val xx : Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1 + x<!>
get() : Int = 1
<!VAL_WITH_SETTER!>set(value : Long) {}<!>
val p : Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1<!>
get() = 1
class Test() {
var a : Int = 111
var b : Int get() = <!UNRESOLVED_REFERENCE!>$a<!>; set(x) {a = x; <!UNRESOLVED_REFERENCE!>$a<!> = x}
this(i : Int) : this() {
<!NO_BACKING_FIELD!>$b<!> = $a
$a = <!NO_BACKING_FIELD!>$b<!>
a = <!NO_BACKING_FIELD!>$b<!>
}
fun f() {
<!UNRESOLVED_REFERENCE!>$b<!> = <!UNRESOLVED_REFERENCE!>$a<!>
a = <!UNRESOLVED_REFERENCE!>$b<!>
}
public val <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>i<!> = 1
}
compiler/testData/diagnostics/quick/QualifiedExpressions.jet
+11
View File
@@ -0,0 +1,11 @@
namespace qualified_expressions
fun test(s: String?) {
val <!UNUSED_VARIABLE!>a<!>: Int = <!TYPE_MISMATCH!>s?.length<!>
val b: Int? = s?.length
val <!UNUSED_VARIABLE!>c<!>: Int = s?.length ?: -11
val <!UNUSED_VARIABLE!>d<!>: Int = s?.length ?: <!TYPE_MISMATCH!>"empty"<!>
val e: String = <!TYPE_MISMATCH!>s?.length<!> ?: "empty"
val <!UNUSED_VARIABLE!>f<!>: Int = s?.length ?: b ?: 1
val <!UNUSED_VARIABLE!>g<!>: Int? = e? startsWith("s")?.length
}
compiler/testData/diagnostics/quick/QualifiedThis.jet
+41
View File
@@ -0,0 +1,41 @@
class Dup {
fun Dup() : Unit {
this<!AMBIGUOUS_LABEL!>@Dup<!>
}
}
class A() {
fun foo() : Unit {
this@A
this<!UNRESOLVED_REFERENCE!>@a<!>
this
}
val x = this@A.foo()
val y = this.foo()
val z = foo()
}
fun foo1() : Unit {
<!NO_THIS!>this<!>
this<!UNRESOLVED_REFERENCE!>@a<!>
}
namespace closures {
class A(val a:Int) {
class B() {
val x = this@B : B
val y = this@A : A
val z = this : B
val Int.xx = this : Int
fun Char.xx() : Any {
this : Char
val <!UNUSED_VARIABLE!>a<!> = {Double.() => this : Double + this@xx : Char}
val <!UNUSED_VARIABLE!>b<!> = @a{Double.() => this@a : Double + this@xx : Char}
val <!UNUSED_VARIABLE!>c<!> = @a{() => <!NO_THIS!>this@a<!> + this@xx : Char}
return (@a{Double.() => this@a : Double + this@xx : Char})
}
}
}
}
compiler/testData/diagnostics/quick/RecursiveTypeInference.jet
+42
View File
@@ -0,0 +1,42 @@
namespace a {
val foo = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>
fun bar() = foo
}
namespace b {
fun foo() = bar()
fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo()<!>
}
namespace c {
fun bazz() = bar()
fun foo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bazz()<!>
fun bar() = foo()
}
namespace ok {
namespace a {
val foo = bar()
fun bar() : Int = foo
}
namespace b {
fun foo() : Int = bar()
fun bar() = foo()
}
namespace c {
fun bazz() = bar()
fun foo() : Int = bazz()
fun bar() = foo()
}
}
compiler/testData/diagnostics/quick/Redeclarations.jet
+16
View File
@@ -0,0 +1,16 @@
namespace redeclarations {
object <!REDECLARATION, REDECLARATION!>A<!> {
val x : Int = 0
val A = 1
}
namespace <!REDECLARATION!>A<!> {
class A {}
}
class <!REDECLARATION, REDECLARATION!>A<!> {}
val <!REDECLARATION!>A<!> = 1
}
compiler/testData/diagnostics/quick/ResolveOfJavaGenerics.jet
+22
View File
@@ -0,0 +1,22 @@
// +JDK
// Fixpoint generic in Java: Enum<T extends Enum<T>>
fun test(<!UNUSED_PARAMETER!>a<!> : annotation.RetentionPolicy) {
}
fun test() {
java.util.Collections.emptyList()
}
fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.Comparable<Int>) {
}
fun test(<!UNUSED_PARAMETER!>a<!> : java.util.ArrayList<Int>) {
}
fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.Class<Int>) {
}
compiler/testData/diagnostics/quick/ResolveToJava.jet
+54
View File
@@ -0,0 +1,54 @@
// +JDK
import java.*
import util.*
import <!UNRESOLVED_REFERENCE!>utils<!>.*
import java.io.PrintStream
import java.lang.Comparable as Com
val l : List<in Int> = ArrayList<Int>()
fun test(<!UNUSED_PARAMETER!>l<!> : java.util.List<Int>) {
val <!UNUSED_VARIABLE!>x<!> : java.<!UNRESOLVED_REFERENCE!>List<!>
val <!UNUSED_VARIABLE!>y<!> : java.util.List<Int>
val <!UNUSED_VARIABLE!>b<!> : java.lang.Object
val <!UNUSED_VARIABLE!>a<!> : util.List<Int>
val <!UNUSED_VARIABLE!>z<!> : java.<!UNRESOLVED_REFERENCE!>utils<!>.List<Int>
val <!UNUSED_VARIABLE!>f<!> : java.io.File? = null
Collections.<!UNRESOLVED_REFERENCE!>emptyList<!>
Collections.emptyList<Int>
Collections.emptyList<Int>()
Collections.emptyList()
Collections.singleton<Int>(1) : Set<Int>?
Collections.singleton<Int>(<!ERROR_COMPILE_TIME_VALUE!>1.0<!>)
<!UNRESOLVED_REFERENCE!>List<!><Int>
val <!UNUSED_VARIABLE!>o<!> = "sdf" <!CAST_NEVER_SUCCEEDS!>as<!> Object
try {
// ...
}
catch(e: Exception) {
System.out?.println(e.getMessage())
}
PrintStream("sdf")
val c : Com<Int>? = null
c : java.lang.Comparable<Int>?
// Collections.sort<Integer>(ArrayList<Integer>())
xxx.<!UNRESOLVED_REFERENCE!>Class<!>()
}
namespace xxx {
import java.lang.Class;
}
compiler/testData/diagnostics/quick/Return.jet
+17
View File
@@ -0,0 +1,17 @@
namespace <!SYNTAX!>return<!>
class A {
fun outer() {
fun inner() {
if (1 < 2)
return@inner
else
<!RETURN_NOT_ALLOWED!>return@outer<!>
}
if (1 < 2)
<!RETURN_NOT_ALLOWED!>return@A<!>
else if (2 < 3)
<!RETURN_NOT_ALLOWED!>return<!UNRESOLVED_REFERENCE!>@inner<!><!>
return@outer
}
}
compiler/testData/diagnostics/quick/SafeCallNonNullReceiver.jet
+6
View File
@@ -0,0 +1,6 @@
// http://youtrack.jetbrains.net/issue/KT-418
fun ff() {
val i: Int = 1
val <!UNUSED_VARIABLE!>a<!>: Int = i<!UNNECESSARY_SAFE_CALL!>?.<!>plus(2)
}
compiler/testData/diagnostics/quick/SafeCallNonNullReceiverReturnNull.jet
+6
View File
@@ -0,0 +1,6 @@
fun Int.gg() = null
fun ff() {
val a: Int = 1
val <!UNUSED_VARIABLE!>b<!>: Int = <!TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!>gg()<!>
}
compiler/testData/diagnostics/quick/StringTemplates.jet
+22
View File
@@ -0,0 +1,22 @@
fun demo() {
val abc = 1
val a = ""
val asd = 1
val bar = 5
fun map(f : fun () : Any?) : Int = 1
fun buzz(f : fun () : Any?) : Int = 1
val sdf = 1
val foo = 3;
"$abc"
"$"
"$.$.asdf$\t"
"asd\$"
"asd$a<!ILLEGAL_ESCAPE_SEQUENCE!>\x<!>"
"asd$a$asd$ $<!UNRESOLVED_REFERENCE!>xxx<!>"
"fosdfasdo${1 + bar + 100}}sdsdfgdsfsdf"
"foo${bar + map {foo}}sdfsdf"
"foo${bar + map { "foo" }}sdfsdf"
"foo${bar + map {
"foo$sdf${ buzz{}}" }}sdfsdf"
"a<!ILLEGAL_ESCAPE_SEQUENCE!>\u<!> <!ILLEGAL_ESCAPE_SEQUENCE!>\u<!>0 <!ILLEGAL_ESCAPE_SEQUENCE!>\u<!>00 <!ILLEGAL_ESCAPE_SEQUENCE!>\u<!>000 \u0000 \u0AaA <!ILLEGAL_ESCAPE_SEQUENCE!>\u<!>0AAz.length( ) + \u0022b"
}
compiler/testData/diagnostics/quick/Super.jet
+89
View File
@@ -0,0 +1,89 @@
namespace example;
fun any(<!UNUSED_PARAMETER!>a<!> : Any) {}
fun notAnExpression() {
any(<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>) // not an expression
if (<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>) {} else {} // not an expression
val <!UNUSED_VARIABLE!>x<!> = <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> // not an expression
when (1) {
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!> => 1 // not an expression
}
}
trait T {
fun foo() {}
}
open class C() {
fun bar() {}
}
class A<E>() : C(), T {
fun test() {
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>
<!SUPER_IS_NOT_AN_EXPRESSION!>super<T><!>
<!AMBIGUOUS_SUPER!>super<!>.foo()
super<T>.foo()
super<C>.bar()
super<T>@A.foo()
super<C>@A.bar()
super<<!NOT_A_SUPERTYPE!>E<!>>.bar()
super<<!NOT_A_SUPERTYPE!>E<!>>@A.bar()
super<<!NOT_A_SUPERTYPE!>Int<!>>.foo()
super<<!SYNTAX!><!>>.foo()
super<<!NOT_A_SUPERTYPE!>fun() : Unit<!>>.foo()
super<<!NOT_A_SUPERTYPE!>()<!>>.foo()
super<T><!UNRESOLVED_REFERENCE!>@B<!>.foo()
super<C><!UNRESOLVED_REFERENCE!>@B<!>.bar()
}
class B : T {
fun test() {
super<T>.foo();
super<<!NOT_A_SUPERTYPE!>C<!>>.bar()
super<C>@A.bar()
super<T>@A.foo()
super<T>@B.foo()
super<<!NOT_A_SUPERTYPE!>C<!>>@B.foo()
super.foo()
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>
<!SUPER_IS_NOT_AN_EXPRESSION!>super<T><!>
}
}
}
fun foo() {
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>
super.foo()
super<Nothing>.foo()
}
trait G<T> {
fun foo() {}
}
class CG : G<Int> {
fun test() {
super<G>.foo() // OK
super<G<!TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER!><Int><!>>.foo() // Warning
super<<!NOT_A_SUPERTYPE!>G<<!UNRESOLVED_REFERENCE!>E<!>><!>>.foo() // Error
super<<!NOT_A_SUPERTYPE!>G<String><!>>.foo() // Error
}
}
// The case when no supertype is resolved
class ERROR<E>() : <!UNRESOLVED_REFERENCE!>UR<!> {
fun test() {
super.<!UNRESOLVED_REFERENCE!>foo<!>()
}
}
// No supertype at all
class A1 {
fun test() {
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>.equals(null)
}
}
compiler/testData/diagnostics/quick/SupertypeListChecks.jet
+51
View File
@@ -0,0 +1,51 @@
// KT-286 Check supertype lists
/*
In a supertype list:
Same type should not be mentioned twice
Same type should not be indirectly mentioned with incoherent type arguments
Every trait's required dependencies should be satisfied
No final types should appear
Only one class is allowed
*/
class C1()
open class OC1()
open class C2 {}
open class C3 {}
trait T1 {}
trait T2<T> {}
trait Test<!CONSTRUCTOR_IN_TRAIT!>()<!> {
<!CONSTRUCTOR_IN_TRAIT, SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST!>this<!>(x : Int) {}
}
trait Test1 : C2<!SUPERTYPE_INITIALIZED_IN_TRAIT!>()<!> {}
trait Test2 : C2 {}
trait Test3 : C2, <!MANY_CLASSES_IN_SUPERTYPE_LIST!>C3<!> {}
trait Test4 : T1 {}
trait Test5 : T1, <!SUPERTYPE_APPEARS_TWICE!>T1<!> {}
trait Test6 : <!FINAL_SUPERTYPE!>C1<!> {}
class CTest1() : OC1() {}
class CTest2 : C2 {}
class CTest3 : C2, <!MANY_CLASSES_IN_SUPERTYPE_LIST!>C3<!> {}
class CTest4 : T1 {}
class CTest5 : T1, <!SUPERTYPE_APPEARS_TWICE!>T1<!> {}
class CTest6 : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>C1<!> {}
compiler/testData/diagnostics/quick/SyntaxErrorInTestHighlighting.jet
+5
View File
@@ -0,0 +1,5 @@
// dummy test of syntax error highlighing in tests
fun get() {
1 + 2 <!SYNTAX!>2 3 4<!>
}
compiler/testData/diagnostics/quick/SyntaxErrorInTestHighlightingEof.jet
+1
View File
@@ -0,0 +1 @@
fun f() {<!SYNTAX!><!>
compiler/testData/diagnostics/quick/TraitSupertypeList.jet
+11
View File
@@ -0,0 +1,11 @@
open class bar()
trait Foo<!CONSTRUCTOR_IN_TRAIT!>()<!> : bar<!SUPERTYPE_INITIALIZED_IN_TRAIT!>()<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!> {
<!CONSTRUCTOR_IN_TRAIT, SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST!>this<!>(x : Int) {}
}
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<!> {}
compiler/testData/diagnostics/quick/TypeInference.jet
+18
View File
@@ -0,0 +1,18 @@
class C<T>() {
fun foo() : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
}
fun foo(<!UNUSED_PARAMETER!>c<!>: C<Int>) {}
fun bar<T>() : C<T> <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
fun main(args : Array<String>) {
val <!UNUSED_VARIABLE!>a<!> : C<Int> = C();
val <!UNUSED_VARIABLE!>x<!> : C<in String> = C()
val <!UNUSED_VARIABLE!>y<!> : C<out String> = C()
val <!UNUSED_VARIABLE!>z<!> : C<*> = C()
val <!UNUSED_VARIABLE!>ba<!> : C<Int> = bar();
val <!UNUSED_VARIABLE!>bx<!> : C<in String> = bar()
val <!UNUSED_VARIABLE!>by<!> : C<out String> = bar()
val <!UNUSED_VARIABLE!>bz<!> : C<*> = bar()
}
compiler/testData/diagnostics/quick/UninitializedOrReassignedVariables.jet
+352
View File
@@ -0,0 +1,352 @@
namespace uninitialized_reassigned_variables
fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
// ------------------------------------------------
// uninitialized variables
fun t1(b : Boolean) {
val v : Int
if (<!UNINITIALIZED_VARIABLE!>v<!> == 0) {}
var u: String
if (b) {
u = "s"
}
doSmth(<!UNINITIALIZED_VARIABLE!>u<!>)
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>r<!>: String
if (b) {
r = "s"
}
else {
r = "tg"
}
doSmth(r)
var t: String
if (b)
doSmth(<!UNINITIALIZED_VARIABLE!>t<!>)
else
t = "ss"
doSmth(t) //repeat for t
val i = 3
doSmth(i)
if (b) {
return;
}
doSmth(i)
if (i is Int) {
return;
}
}
fun t2() {
val s = "ss"
for (i in 0..2) {
doSmth(s)
}
}
class A() {}
fun t4(a: A, val b: A, var c: A) {
<!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>A()<!>
<!VAL_REASSIGNMENT!>b<!> = <!UNUSED_VALUE!>A()<!>
c = <!UNUSED_VALUE!>A()<!>
}
// ------------------------------------------------
// reassigned vals
fun t1() {
val <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>a<!> : Int = 1
<!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>2<!>
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>b<!> : Int = 1
b = <!UNUSED_VALUE!>3<!>
}
abstract enum class ProtocolState {
WAITING {
override fun signal() = ProtocolState.TALKING
}
TALKING {
override fun signal() = ProtocolState.WAITING
}
abstract fun signal() : ProtocolState
}
fun t3() {
val x: ProtocolState = ProtocolState.WAITING
<!VAL_REASSIGNMENT!>x<!> = x.signal()
x = <!UNUSED_VALUE!>x.signal()<!> //repeat for x
}
fun t4() {
val x = 1
<!VAL_REASSIGNMENT!>x<!> += 2
val y = 3
<!VAL_REASSIGNMENT!>y<!> *= 4
var z = 5
z -= y
}
fun t5() {
for (i in 0..2) {
<!VAL_REASSIGNMENT!>i<!> += 1
fun t5() {
<!VAL_REASSIGNMENT!>i<!> += 3
}
}
}
// ------------------------------------------------
// backing fields
var x = 10
val y = 10
val z = 10
class AnonymousInitializers(var a: String, val b: String) {
{
$a = "30"
a = "s"
<!VAL_REASSIGNMENT!>$b<!> = "3"
b = "tt" //repeat for b
}
val i: Int
{
$i = 121
}
{
x = 11
<!VAL_REASSIGNMENT!>z<!> = 10
}
val j: Int
get() = 20
{
<!VAL_REASSIGNMENT!>$i<!> = 13
<!NO_BACKING_FIELD, VAL_REASSIGNMENT!>$j<!> = 30
j = 34
}
val k: String
{
if (1 < 3) {
<!INITIALIZATION_USING_BACKING_FIELD!>k<!> = "a"
}
else {
$k = "b"
}
}
val l: String
{
if (1 < 3) {
$l = "a"
}
else {
$l = "b"
}
}
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>o<!>: String
{
if (1 < 3) {
$o = "a"
}
}
var m: Int = 30
{
$m = 400
}
val n: Int
{
while (<!UNINITIALIZED_VARIABLE!>n<!> == 0) {
}
$n = 10
while (n == 0) {
}
}
var p = 1
{
p++
}
}
fun reassignFunParams(val a: Int) {
<!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>1<!>
}
open class Open(a: Int, w: Int) {}
class LocalValsVsProperties(val a: Int, w: Int) : Open(a, w) {
val x : Int
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>y<!> : Int
{
$x = 1
val b = x
}
val b = a
fun foo() {
val r : Int
doSmth(x)
doSmth(y)
doSmth(<!UNINITIALIZED_VARIABLE!>r<!>)
doSmth(a)
}
var xx = w
var yy : Int
{
<!VAL_REASSIGNMENT!>w<!> += 1
$yy = w
}
}
class Outer() {
val a : Int
var b : Int
{
$a = 1
$b = 1
}
class Inner() {
{
<!VAL_REASSIGNMENT!>a<!>++
b++
}
}
fun foo() {
<!VAL_REASSIGNMENT!>a<!>++
b++
}
}
class ForwardAccessToBackingField() { //kt-147
val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, UNINITIALIZED_VARIABLE!>$a<!> // error
val b = <!UNINITIALIZED_VARIABLE!>$c<!> // error
val c = 1
}
class ClassObject() {
class object {
val x : Int
{
$x = 1
}
fun foo() {
val a : Int
doSmth(<!UNINITIALIZED_VARIABLE!>a<!>)
}
}
}
fun foo() {
val <!UNUSED_VARIABLE!>a<!> = object {
val x : Int
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>y<!> : Int
val z : Int
{
$x = 1
$z = 3
}
fun foo() {
<!VAL_REASSIGNMENT!>y<!> = 10
<!VAL_REASSIGNMENT!>z<!> = 13
}
}
}
class TestObjectExpression() {
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!> : Int
fun foo() {
val <!UNUSED_VARIABLE!>a<!> = object {
val x : Int
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>y<!> : Int
{
if (true)
<!INITIALIZATION_USING_BACKING_FIELD!>x<!> = 12
else
$x = 1
}
fun inner1() {
<!VAL_REASSIGNMENT!>y<!> = 101
<!VAL_REASSIGNMENT!>a<!> = 231
}
fun inner2() {
<!VAL_REASSIGNMENT!>y<!> = 101
<!VAL_REASSIGNMENT!>a<!> = 231
}
}
}
}
object TestObjectDeclaration {
val x : Int
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>y<!> : Int
{
$x = 1
}
fun foo() {
<!VAL_REASSIGNMENT!>y<!> = 10
val i: Int
if (1 < 3) {
i = 10
}
doSmth(<!UNINITIALIZED_VARIABLE!>i<!>)
}
}
fun func() {
val b = 1
val <!UNUSED_VARIABLE!>a<!> = object {
val x = b
{
<!VAL_REASSIGNMENT!>b<!> = <!UNUSED_VALUE!>4<!>
<!UNRESOLVED_REFERENCE!>$b<!> = 3
}
}
}
// ------------------------------------------------
// dot qualifiers
class M() {
val x = 11
var y = 12
}
fun test(m : M) {
<!VAL_REASSIGNMENT!>m.x<!> = 23
m.y = 23
}
fun test1(m : M) {
<!VAL_REASSIGNMENT!>m.x<!>++
m.y--
}
compiler/testData/diagnostics/quick/UnitByDefaultForFunctionTypes.jet
+3
View File
@@ -0,0 +1,3 @@
fun foo(f : fun()) {
val <!UNUSED_VARIABLE!>x<!> : Unit = f()
}
compiler/testData/diagnostics/quick/UnreachableCode.jet
+168
View File
@@ -0,0 +1,168 @@
// +JDK
fun t1() : Int{
return 0
<!UNREACHABLE_CODE!>1<!>
}
fun t1a() : Int {
<!RETURN_TYPE_MISMATCH!>return<!>
<!UNREACHABLE_CODE!>return 1<!>
<!UNREACHABLE_CODE!>1<!>
}
fun t1b() : Int {
return 1
<!UNREACHABLE_CODE!>return 1<!>
<!UNREACHABLE_CODE!>1<!>
}
fun t1c() : Int {
return 1
<!RETURN_TYPE_MISMATCH, UNREACHABLE_CODE!>return<!>
<!UNREACHABLE_CODE!>1<!>
}
fun t2() : Int {
if (1 > 2)
return 1
else return 1
<!UNREACHABLE_CODE!>1<!>
}
fun t2a() : Int {
if (1 > 2) {
return 1
<!UNREACHABLE_CODE!>1<!>
} else { return 1
<!UNREACHABLE_CODE!>2<!>
}
<!UNREACHABLE_CODE!>1<!>
}
fun t3() : Any {
if (1 > 2)
return 2
else return ""
<!UNREACHABLE_CODE!>1<!>
}
fun t4(<!UNUSED_PARAMETER!>a<!> : Boolean) : Int {
do {
return 1
}
while (<!UNREACHABLE_CODE!>a<!>)
<!UNREACHABLE_CODE!>1<!>
}
fun t4break(<!UNUSED_PARAMETER!>a<!> : Boolean) : Int {
do {
break
}
while (<!UNREACHABLE_CODE!>a<!>)
return 1
}
fun t5() : Int {
do {
return 1
<!UNREACHABLE_CODE!>2<!>
}
while (<!UNREACHABLE_CODE!>1 > 2<!>)
<!UNREACHABLE_CODE!>return 1<!>
}
fun t6() : Int {
while (1 > 2) {
return 1
<!UNREACHABLE_CODE!>2<!>
}
return 1
}
fun t6break() : Int {
while (1 > 2) {
break
<!UNREACHABLE_CODE!>2<!>
}
return 1
}
fun t7(b : Int) : Int {
for (i in 1..b) {
return 1
<!UNREACHABLE_CODE!>2<!>
}
return 1
}
fun t7break(b : Int) : Int {
for (i in 1..b) {
return 1
<!UNREACHABLE_CODE!>2<!>
}
return 1
}
fun t7() : Int {
try {
return 1
<!UNREACHABLE_CODE!>2<!>
}
catch (e : Any) {
2
}
return 1 // this is OK, like in Java
}
fun t8() : Int {
try {
return 1
<!UNREACHABLE_CODE!>2<!>
}
catch (e : Any) {
return 1
<!UNREACHABLE_CODE!>2<!>
}
<!UNREACHABLE_CODE!>return 1<!>
}
fun blockAndAndMismatch() : Boolean {
<!UNREACHABLE_CODE!>(return true) || (return false)<!>
<!UNREACHABLE_CODE!>return true<!>
}
fun tf() : Int {
try {<!UNREACHABLE_CODE!>return 1<!>} finally{return 1}
<!UNREACHABLE_CODE!>return 1<!>
}
fun failtest(a : Int) : Int {
if (fail() || <!UNREACHABLE_CODE!>true<!>) {
}
<!UNREACHABLE_CODE!>return 1<!>
}
fun foo(a : Nothing) : Unit {
1
a
<!UNREACHABLE_CODE!>2<!>
}
fun fail() : Nothing {
throw java.lang.RuntimeException()
}
fun nullIsNotNothing() : Unit {
val x : Int? = 1
if (x != null) {
return
}
fail()
}
fun returnInWhile(<!UNUSED_PARAMETER!>a<!>: Int) {
do {return}
while (<!UNREACHABLE_CODE!>1 > a<!>)
}
compiler/testData/diagnostics/quick/Unresolved.jet
+31
View File
@@ -0,0 +1,31 @@
namespace unresolved
fun testGenericArgumentsCount() {
val <!UNUSED_VARIABLE!>p1<!>: Tuple2<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> = (2, 2)
val <!UNUSED_VARIABLE!>p2<!>: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Tuple2<!> = (2, 2)
}
fun testUnresolved() {
if (<!UNRESOLVED_REFERENCE!>a<!> is String) {
val <!UNUSED_VARIABLE!>s<!> = <!UNRESOLVED_REFERENCE!>a<!>
}
<!UNRESOLVED_REFERENCE!>foo<!>(<!UNRESOLVED_REFERENCE!>a<!>)
val s = "s"
<!UNRESOLVED_REFERENCE!>foo<!>(s)
foo1(<!UNRESOLVED_REFERENCE!>i<!>)
s.<!UNRESOLVED_REFERENCE!>foo<!>()
when(<!UNRESOLVED_REFERENCE!>a<!>) {
is Int => <!UNRESOLVED_REFERENCE!>a<!>
is String => <!UNRESOLVED_REFERENCE!>a<!>
}
//TODO
for (j in <!UNRESOLVED_REFERENCE!>collection<!>) {
var i: Int = j
i += 1
foo1(j)
}
}
fun foo1(<!UNUSED_PARAMETER!>i<!>: Int) {}
compiler/testData/diagnostics/quick/UnusedVariables.jet
+142
View File
@@ -0,0 +1,142 @@
namespace unused_variables
fun testSimpleCases() {
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>i<!> = 2
i = <!UNUSED_VALUE!>34<!>
i = 34
doSmth(i)
i = <!UNUSED_VALUE!>5<!>
var j = 2
j = <!UNUSED_CHANGED_VALUE!>j++<!>
j = <!UNUSED_VALUE, UNUSED_CHANGED_VALUE!>j--<!>
}
class IncDec() {
fun inc() : IncDec = this
fun dec() : IncDec = this
}
class MyTest() {
fun testIncDec() {
var x = IncDec()
x++
++x
x--
--x
x = <!UNUSED_CHANGED_VALUE!>x++<!>
x = <!UNUSED_CHANGED_VALUE!>x--<!>
x = ++x
x = <!UNUSED_VALUE!>--x<!>
}
var a: String = "s"
set(v: String) {
var i: Int = 23
doSmth(i)
i = <!UNUSED_VALUE!>34<!>
$a = v
}
{
a = "rr"
}
fun testSimple() {
a = "rro"
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>i<!> = 1;
i = <!UNUSED_VALUE!>34<!>;
i = <!UNUSED_VALUE!>456<!>;
}
fun testWhile() {
var a : Any? = true
var b : Any? = 34
while (a is Any) {
a = null
}
while (b != null) {
a = <!UNUSED_VALUE!>null<!>
}
}
fun testIf() {
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>a<!> : Any
if (1 < 2) {
a = 23
}
else {
a = "ss"
doSmth(a as String)
}
doSmth(a)
if (1 < 2) {
a = <!UNUSED_VALUE!>23<!>
}
else {
a = <!UNUSED_VALUE!>"ss"<!>
}
}
fun testFor() {
for (i in 1..10) {
doSmth(i)
}
}
fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
fun doSmth(<!UNUSED_PARAMETER!>a<!>: Any) {}
}
fun testInnerFunctions() {
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>y<!> = 1
fun foo() {
y = <!UNUSED_VALUE!>1<!>
}
var z = 1
fun bar() {
doSmth(z)
}
}
fun testFunctionLiterals() {
var x = 1
var <!UNUSED_VARIABLE!>fl<!> = { (): Int =>
x
}
var y = 2
var <!UNUSED_VARIABLE!>fl1<!> = { (): Unit =>
doSmth(y)
}
}
trait Trait {
fun foo()
}
fun testObject() : Trait {
val x = 24
val o = object : Trait {
val y : Int //in this case y should not be marked as unused
get() = 55
override fun foo() {
doSmth(x)
}
}
return o
}
fun testBackingFieldsNotMarked() {
val <!UNUSED_VARIABLE!>a<!> = object {
val x : Int
{
$x = 1
}
}
}
fun doSmth(<!UNUSED_PARAMETER!>i<!> : Int) {}
compiler/testData/diagnostics/quick/ValAndFunOverrideCompatibilityClash.jet
+10
View File
@@ -0,0 +1,10 @@
// +JDK
class Foo1() : java.util.ArrayList<Int>()
open class Bar() {
fun v() : Int = 1
val v : Int = 1
}
class Barr() : Bar() {}
compiler/testData/diagnostics/quick/VarargTypes.jet
+27
View File
@@ -0,0 +1,27 @@
// KT-389 Wrong type inference for varargs etc.
// +JDK
import java.util.*
fun foob(vararg a : Byte) : ByteArray = a
fun fooc(vararg a : Char) : CharArray = a
fun foos(vararg a : Short) : ShortArray = a
fun fooi(vararg a : Int) : IntArray = a
fun fool(vararg a : Long) : LongArray = a
fun food(vararg a : Double) : DoubleArray = a
fun foof(vararg a : Float) : FloatArray = a
fun foob(vararg a : Boolean) : BooleanArray = a
fun foos(vararg a : String) : Array<String> = a
fun test() {
Arrays.asList(1, 2, 3)
Arrays.asList<Int>(1, 2, 3)
foob(1, 2, 3)
foos(1, 2, 3)
fooc('1', '2', '3')
fooi(1, 2, 3)
fool(1, 2, 3)
food(1.0, 2.0, 3.0)
foof(1.0.flt, 2.0.flt, 3.0.flt)
}
compiler/testData/diagnostics/quick/Varargs.jet
+17
View File
@@ -0,0 +1,17 @@
fun v(<!UNUSED_PARAMETER!>x<!> : Int, <!UNUSED_PARAMETER!>y<!> : String, vararg <!UNUSED_PARAMETER!>f<!> : Long) {}
fun v1(vararg <!UNUSED_PARAMETER!>f<!> : fun (Int) : Unit) {}
fun test() {
v(1, "")
v(1, "", 1)
v(1, "", 1, 1, 1)
v(1, "", 1, 1, 1)
v1()
v1({})
v1({}, {})
v1({}, <!ERROR_COMPILE_TIME_VALUE!>1<!>, {})
v1({}, {}, {it})
v1({}) <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
v1 <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
}
compiler/testData/diagnostics/quick/Variance.jet
+40
View File
@@ -0,0 +1,40 @@
namespace variance
abstract class Consumer<in T> {}
abstract class Producer<out T> {}
abstract class Usual<T> {}
fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
val c1: Consumer<Any> = <!TYPE_MISMATCH!>c<!>
val <!UNUSED_VARIABLE!>c2<!>: Consumer<Int> = c1
val p1: Producer<Any> = p
val <!UNUSED_VARIABLE!>p2<!>: Producer<Int> = <!TYPE_MISMATCH!>p1<!>
val u1: Usual<Any> = <!TYPE_MISMATCH!>u<!>
val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!TYPE_MISMATCH!>u1<!>
}
//Arrays copy example
class Array<T>(val length : Int, val t : T) {
fun get(<!UNUSED_PARAMETER!>index<!> : Int) : T { return t }
fun set(<!UNUSED_PARAMETER!>index<!> : Int, <!UNUSED_PARAMETER!>value<!> : T) { /* ... */ }
}
fun copy1(<!UNUSED_PARAMETER!>from<!> : Array<Any>, <!UNUSED_PARAMETER!>to<!> : Array<Any>) {}
fun copy2(<!UNUSED_PARAMETER!>from<!> : Array<out Any>, <!UNUSED_PARAMETER!>to<!> : Array<in Any>) {}
fun <T> copy3(<!UNUSED_PARAMETER!>from<!> : Array<out T>, <!UNUSED_PARAMETER!>to<!> : Array<in T>) {}
fun copy4(<!UNUSED_PARAMETER!>from<!> : Array<out Number>, <!UNUSED_PARAMETER!>to<!> : Array<in Int>) {}
fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
copy1(<!TYPE_MISMATCH!>ints<!>, any)
copy2(ints, any) //ok
copy2(ints, <!TYPE_MISMATCH!>numbers<!>)
copy3<Int>(ints, numbers)
copy4(ints, numbers) //ok
}
compiler/testData/diagnostics/quick/When.jet
+67
View File
@@ -0,0 +1,67 @@
fun Int.foo() : Boolean = true
fun foo() : Int {
val s = ""
val x = 1
when (x) {
is * => 1
is <!INCOMPATIBLE_TYPES!>String<!> => 1
!is Int => 1
is Any? => 1
<!INCOMPATIBLE_TYPES!>s<!> => 1
1 => 1
1 + <!UNRESOLVED_REFERENCE!>a<!> => 1
in 1..<!UNRESOLVED_REFERENCE!>a<!> => 1
!in 1..<!UNRESOLVED_REFERENCE!>a<!> => 1
// Commented for KT-621 .<!!UNRESOLVED_REFERENCE!>a<!!> => 1
// Commented for KT-621 .equals(1).<!!UNRESOLVED_REFERENCE!>a<!!> => 1
// Commented for KT-621 <!UNNECESSARY_SAFE_CALL!!>?.<!!>equals(1) => 1
else => 1
}
// Commented for KT-621
// return when (<!!USELESS_ELVIS!>x<!!>?:null) {
// <!!UNSAFE_CALL!!>.<!!>foo() => 1
// .equals(1) => 1
// ?.equals(1).equals(2) => 1
// }
return 0
}
val _type_test : Int = foo() // this is needed to ensure the inferred return type of foo()
fun test() {
val x = 1;
val s = "";
when (x) {
<!INCOMPATIBLE_TYPES!>s<!> => 1
is <!INCOMPATIBLE_TYPES!>""<!> => 1
x => 1
is 1 => 1
is <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, 1)<!> => 1
}
val z = (1, 1)
when (z) {
is (*, *) => 1
is (*, 1) => 1
is (1, 1) => 1
is (1, <!INCOMPATIBLE_TYPES!>"1"<!>) => 1
is <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, "1", *)<!> => 1
is boo @ (1, <!INCOMPATIBLE_TYPES!>"a"<!>, *) => 1
is boo @ <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, *)<!> => 1
}
when (z) {
<!ELSE_MISPLACED_IN_WHEN!>else => 1<!>
(1, 1) => 2
}
when (z) {
else => 1
}
}
val (Int, Int).boo : (Int, Int, Int) = (1, 1, 1)
compiler/testData/diagnostics/quick/backingField/CustomGetSet.jet
+7
View File
@@ -0,0 +1,7 @@
class Flower() {
var minusOne: Int = 1
get() = $minusOne + 1
set(n: Int) { $minusOne = n - 1 }
}
compiler/testData/diagnostics/quick/backingField/CustomGetVal.jet
+4
View File
@@ -0,0 +1,4 @@
class CustomGetVal() {
val zz = 1
get() = $zz * 2
}
compiler/testData/diagnostics/quick/backingField/CustomGetValGlobal.jet
+5
View File
@@ -0,0 +1,5 @@
namespace customGetValGlobal {
val zz = 1
get() = $zz * 2
}
compiler/testData/diagnostics/quick/backingField/CustomGetVar.jet
+4
View File
@@ -0,0 +1,4 @@
class Raise() {
var zz = 1
get() = $zz * 2
}
compiler/testData/diagnostics/quick/backingField/CustomSet.jet
+4
View File
@@ -0,0 +1,4 @@
class Raise() {
var zz = 1
set(it) { $zz = it / 2 }
}
compiler/testData/diagnostics/quick/backingField/CyclicReferenceInitializer.jet
+3
View File
@@ -0,0 +1,3 @@
class Cyclic() {
val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, UNINITIALIZED_VARIABLE!>$a<!>
}
compiler/testData/diagnostics/quick/backingField/ReadForwardInAnonymous.jet
+7
View File
@@ -0,0 +1,7 @@
class ReadForward() {
{
val x = <!UNINITIALIZED_VARIABLE!>$a<!>
}
val a = 1
}
compiler/testData/diagnostics/quick/backingField/ReadForwardInPropertyInitializer.jet
+4
View File
@@ -0,0 +1,4 @@
class ReadForward() {
val a = <!UNINITIALIZED_VARIABLE!>$b<!>
val b = 1
}
compiler/testData/diagnostics/quick/backingField/ReadInAnonymous.jet
+6
View File
@@ -0,0 +1,6 @@
class ReadByAnotherPropertyInitializer() {
val a = 1
{
val x = $a
}
}
compiler/testData/diagnostics/quick/backingField/ReadInAnotherPropertyIntializer.jet
+4
View File
@@ -0,0 +1,4 @@
class ReadByAnotherPropertyInitializer() {
val a = 1
val b = $a
}
compiler/testData/diagnostics/quick/backingField/ReadInFunction.jet
+4
View File
@@ -0,0 +1,4 @@
class ReadByAnotherPropertyInitializer() {
val a = 1
fun ff() = <!UNRESOLVED_REFERENCE!>$a<!>
}
compiler/testData/diagnostics/quick/backingField/ReadNonexistentAbstractPropertyInAnonymous.jet
+7
View File
@@ -0,0 +1,7 @@
abstract class ReadNonexistent() {
abstract val aa: Int
{
val x = <!NO_BACKING_FIELD!>$aa<!>
}
}
compiler/testData/diagnostics/quick/backingField/ReadNonexistentAbstractPropertyInFunction.jet
+5
View File
@@ -0,0 +1,5 @@
abstract class ReadNonexistent {
abstract val aa: Int
fun ff() = <!UNRESOLVED_REFERENCE!>$aa<!>
}
compiler/testData/diagnostics/quick/backingField/ReadNonexistentCustomGetInAnonymous.jet
+8
View File
@@ -0,0 +1,8 @@
class ReadNonexistent() {
val a: Int
get() = 1
{
val x = <!NO_BACKING_FIELD!>$a<!>
}
}
compiler/testData/diagnostics/quick/backingField/ReadNonexistentCustomGetInAnotherInitializer.jet
+6
View File
@@ -0,0 +1,6 @@
class CustomValNoBackingField() {
val a: Int
get() = 1
val b = <!NO_BACKING_FIELD!>$a<!>
}
compiler/testData/diagnostics/quick/backingField/ReadNonexistentDeclaredInHigher.jet
+7
View File
@@ -0,0 +1,7 @@
val y = 1
class A() {
{
val x = <!UNRESOLVED_REFERENCE!>$y<!>
}
}
compiler/testData/diagnostics/quick/backingField/ReadNonexistentPropertyInAnonymous.jet
+5
View File
@@ -0,0 +1,5 @@
class Cl() {
{
val x = <!UNRESOLVED_REFERENCE!>$a<!>
}
}
compiler/testData/diagnostics/quick/backingField/WriteNonexistentDeclaredInHigher.jet
+7
View File
@@ -0,0 +1,7 @@
val y = 1
class A() {
{
<!UNRESOLVED_REFERENCE!>$y<!> = 1
}
}
compiler/testData/diagnostics/quick/cast/AsErasedError.jet
+6
View File
@@ -0,0 +1,6 @@
// +JDK
import java.util.List;
import java.util.Collection;
fun ff(c: Collection<String>) = c <!CAST_NEVER_SUCCEEDS!>as<!> List<Int>
compiler/testData/diagnostics/quick/cast/AsErasedFine.jet
+6
View File
@@ -0,0 +1,6 @@
// +JDK
import java.util.List;
import java.util.Collection;
fun ff(c: Collection<String>) = c as List<String>

Some files were not shown because too many files have changed in this diff Show More