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

Merge remote branch 'origin/master'

Browse Source
This commit is contained in:
Dmitry Jemerov
2011-10-14 07:43:02 +02:00
parent b3783e37c8 3894eff5f2
commit 34e6ab9559
198 changed files with 5644 additions and 2010 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/testData/cfg/ArrayAccess.instructions
-12
View File
@@ -36,15 +36,3 @@ l1:
error:
<ERROR>
=====================
== a ==
val a = Array<Int>
---------------------
l0:
<START>
r(Array)
r(Array<Int>)
l1:
<END>
error:
<ERROR>
=====================
idea/testData/cfg/Assignments.instructions
-53
View File
@@ -55,56 +55,3 @@ l1:
error:
<ERROR>
=====================
== x ==
var x = 1
---------------------
l0:
<START>
r(1)
l1:
<END>
error:
<ERROR>
=====================
== y ==
val y = true && false
---------------------
l0:
<START>
r(true)
jf(l2)
r(false)
l2:
r(true && false)
l1:
<END>
error:
<ERROR>
=====================
== z ==
val z = false && true
---------------------
l0:
<START>
r(false)
jf(l2)
r(true)
l2:
r(false && true)
l1:
<END>
error:
<ERROR>
=====================
== t ==
val t = Test()
---------------------
l0:
<START>
r(Test)
r(Test())
l1:
<END>
error:
<ERROR>
=====================
idea/testData/checker/Constructors.jet
+1 -1
View File
@@ -23,7 +23,7 @@ class WithPC1(a : Int) {
this(s : String) : this(1) {}
this(b : Char) : <error>this("", 2)</error> {}
this(b : Char) : <error>this</error>("", 2) {}
this(b : Byte) : this(""), <error>this(1)</error> {}
}
idea/testData/checker/ExtensionFunctions.jet
+3 -3
View File
@@ -16,7 +16,7 @@ class A
fun A.plus(a : Any) {
1.foo()
true.<error>foo()</error>
true.<error>foo</error>()
1
}
@@ -55,10 +55,10 @@ namespace null_safety {
val command = parse("")
command<error>.</error>foo
command.foo
command.equals(null)
command<warning>?.</warning>equals(null)
command?.equals(null)
command.equals1(null)
command<warning>?.</warning>equals1(null)
idea/testData/checker/UnreachableCode.jet
+2 -2
View File
@@ -136,9 +136,9 @@ fun tf() : Int {
}
fun failtest(a : Int) : Int {
<error>if (fail() || true) {
if (fail() || <error>true</error>) {
}</error>
}
<error>return 1</error>
}
idea/testData/checker/When.jet
+3 -1
View File
@@ -1,3 +1,5 @@
fun Int.foo() : Boolean = true
fun foo() : Int {
val s = ""
val x = 1
@@ -17,7 +19,7 @@ fun foo() : Int {
else => 1
}
return when (<warning>x</warning>?:null) {
<error>.</error>equals(1) => 1
<error>.</error>foo() => 1
?.equals(1).equals(2) => 1
}
}
idea/testData/checker/infos/Autocasts.jet
+51 -53
View File
@@ -1,4 +1,4 @@
<info>open</info> class A() {
<info descr="null">open</info> class A() {
fun foo() {}
}
@@ -9,25 +9,25 @@ class B() : A() {
fun f9() {
val a : A?
a?.foo()
a?.<error>bar</error>()
a?.<error descr="Unresolved reference: bar">bar</error>()
if (a is B) {
<info descr="Automatically cast to B">a</info>.bar()
a.foo()
<info descr="Automatically cast to A">a</info>.foo()
}
a?.foo()
a?.<error>bar</error>()
a?.<error descr="Unresolved reference: bar">bar</error>()
if (!(a is B)) {
a?.<error>bar</error>()
a?.<error descr="Unresolved reference: bar">bar</error>()
a?.foo()
}
if (!(a is B) || <info descr="Automatically cast to B">a</info>.bar() == ()) {
a?.<error>bar</error>()
a?.<error descr="Unresolved reference: bar">bar</error>()
}
if (!(a is B)) {
return;
}
<info descr="Automatically cast to B">a</info>.bar()
a.foo()
<info descr="Automatically cast to A">a</info>.foo()
}
fun f10() {
@@ -47,19 +47,17 @@ class C() : A() {
}
fun f10(a : A?) {
if (a is B) {
if (a is C) {
<info descr="Automatically cast to C">a</info>.bar();
}
}
}
fun f11(a : A?) {
when (a) {
is B => <info descr="Automatically cast to B">a</info>.bar()
is A => a.foo()
is Any => a.foo()
is Any? => a.<error>bar</error>()
is A => <info descr="Automatically cast to A">a</info>.foo()
is Any => <info descr="Automatically cast to A">a</info>.foo()
is Any? => a.<error descr="Unresolved reference: bar">bar</error>()
else => a?.foo()
}
}
@@ -67,21 +65,21 @@ fun f11(a : A?) {
fun f12(a : A?) {
when (a) {
is B => <info descr="Automatically cast to B">a</info>.bar()
is A => a.foo()
is Any => a.foo();
is Any? => a.<error>bar</error>()
is val c : <error>B</error> => c.foo()
is A => <info descr="Automatically cast to A">a</info>.foo()
is Any => <info descr="Automatically cast to A">a</info>.foo();
is Any? => a.<error descr="Unresolved reference: bar">bar</error>()
is val c : <error descr="[TYPE_MISMATCH_IN_BINDING_PATTERN] B must be a supertype of A?. Use is to match against B">B</error> => c.foo()
is val c is C => <info descr="Automatically cast to C">c</info>.bar()
is val c is C => <info descr="Automatically cast to C">a</info>.bar()
else => a?.foo()
}
if (a is val b) {
a?.<error>bar</error>()
a?.<error descr="Unresolved reference: bar">bar</error>()
b?.foo()
}
if (a is val b is B) {
b.foo()
<info descr="Automatically cast to A">b</info>.foo()
<info descr="Automatically cast to B">a</info>.bar()
<info descr="Automatically cast to B">b</info>.bar()
}
@@ -89,41 +87,41 @@ fun f12(a : A?) {
fun f13(a : A?) {
if (a is val c is B) {
c.foo()
<info descr="Automatically cast to A">c</info>.foo()
<info descr="Automatically cast to B">c</info>.bar()
}
else {
a?.foo()
<error>c</error>.bar()
<error descr="Unresolved reference: c">c</error>.bar()
}
a?.foo()
if (!(a is val c is B)) {
a?.foo()
<error>c</error>.bar()
<error descr="Unresolved reference: c">c</error>.bar()
}
else {
a.foo()
<error>c</error>.bar()
<info descr="Automatically cast to A">a</info>.foo()
<error descr="Unresolved reference: c">c</error>.bar()
}
a?.foo()
if (a is val c is B && a.foo() == () && <info descr="Automatically cast to B">c</info>.bar() == ()) {
c.foo()
if (a is val c is B && <info descr="Automatically cast to A">a</info>.foo() == () && <info descr="Automatically cast to B">c</info>.bar() == ()) {
<info descr="Automatically cast to A">c</info>.foo()
<info descr="Automatically cast to B">c</info>.bar()
}
else {
a?.foo()
<error>c</error>.bar()
<error descr="Unresolved reference: c">c</error>.bar()
}
if (!(a is val c is B) || !(a is val x is C)) {
<error>x</error>
<error>c</error>
<error descr="Unresolved reference: x">x</error>
<error descr="Unresolved reference: c">c</error>
}
else {
<error>x</error>
<error>c</error>
<error descr="Unresolved reference: x">x</error>
<error descr="Unresolved reference: c">c</error>
}
if (!(a is val c is B) || !(a is val c is C)) {
@@ -131,38 +129,38 @@ fun f13(a : A?) {
if (!(a is val c is B)) return
<info descr="Automatically cast to B">a</info>.bar()
<error>c</error>.foo()
<error>c</error>.bar()
<error descr="Unresolved reference: c">c</error>.foo()
<error descr="Unresolved reference: c">c</error>.bar()
}
fun f14(a : A?) {
while (!(a is val c is B)) {
}
<info descr="Automatically cast to B">a</info>.bar()
<error>c</error>.bar()
<error descr="Unresolved reference: c">c</error>.bar()
}
fun f15(a : A?) {
do {
} while (!(a is val c is B))
<info descr="Automatically cast to B">a</info>.bar()
<error>c</error>.bar()
<error descr="Unresolved reference: c">c</error>.bar()
}
fun getStringLength(obj : Any) : Char? {
if (obj !is String)
return null
return <info>obj</info>.get(0) // no cast to String is needed
return <info descr="Automatically cast to String">obj</info>.get(0) // no cast to String is needed
}
fun toInt(i: Int?): Int = if (i != null) <info descr="Automatically cast to Int">i</info> else 0
fun illegalWhenBody(a: Any): Int = when(a) {
is Int => <info descr="Automatically cast to Int">a</info>
is String => <error>a</error>
is String => <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any but Int was expected">a</error>
}
fun illegalWhenBlock(a: Any): Int {
when(a) {
is Int => return <info descr="Automatically cast to Int">a</info>
is String => return <error>a</error>
is String => return <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any but Int was expected">a</error>
}
}
fun declarations(a: Any?) {
@@ -188,17 +186,17 @@ fun vars(a: Any?) {
}
fun tuples(a: Any?) {
if (a != null) {
val s: (Any, String) = (<info descr="Automatically cast to Any">a</info>, <error>a</error>)
val s: (Any, String) = (<info descr="Automatically cast to Any">a</info>, <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but String was expected">a</error>)
}
if (a is String) {
val s: (Any, String) = (<info descr="Automatically cast to Any">a</info>, <info descr="Automatically cast to String">a</info>)
val s: (Any, String) = (<info descr="Automatically cast to String">a</info>, <info descr="Automatically cast to String">a</info>)
}
fun illegalTupleReturnType(): (Any, String) = (<error>a</error>, <error>a</error>)
fun illegalTupleReturnType(): (Any, String) = (<error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but Any was expected">a</error>, <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but String was expected">a</error>)
if (a is String) {
fun legalTupleReturnType(): (Any, String) = (<info descr="Automatically cast to Any">a</info>, <info descr="Automatically cast to String">a</info>)
fun legalTupleReturnType(): (Any, String) = (<info descr="Automatically cast to String">a</info>, <info descr="Automatically cast to String">a</info>)
}
val illegalFunctionLiteral: Function0<Int> = <error>{ <error>a</error> }</error>
val illegalReturnValueInFunctionLiteral: Function0<Int> = { (): Int => <error>a</error> }
val illegalFunctionLiteral: Function0<Int> = <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Function0<Any?> but Function0<Int> was expected">{ <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but Int was expected">a</error> }</error>
val illegalReturnValueInFunctionLiteral: Function0<Int> = { (): Int => <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but Int was expected">a</error> }
if (a is Int) {
val legalFunctionLiteral: Function0<Int> = { <info descr="Automatically cast to Int">a</info> }
@@ -213,43 +211,43 @@ fun returnFunctionLiteral(a: Any?): Function0<Int> =
if (a is Int) { (): Int => <info descr="Automatically cast to Int">a</info> }
else { () => 1 }
fun illegalTupleReturnType(a: Any): (Any, String) = (a, <error>a</error>)
fun illegalTupleReturnType(a: Any): (Any, String) = (a, <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any but String was expected">a</error>)
fun declarationInsidePattern(x: (Any, Any)): String = when(x) { is (val a is String, *) => <info descr="Automatically cast to String">a</info>; else => "something" }
fun mergeAutocasts(a: Any?) {
if (a is String || a is Int) {
a.<error>compareTo</error>("")
a.<error descr="Unresolved reference: compareTo">compareTo</error>("")
a.toString()
}
if (a is Int || a is String) {
a.<error>compareTo</error>("")
a.<error descr="Unresolved reference: compareTo">compareTo</error>("")
}
when (a) {
is String, is Any => a.<error>compareTo</error>("")
is String, is Any => a.<error descr="Unresolved reference: compareTo">compareTo</error>("")
}
if (a is String && a is Any) {
val i: Int = <info descr="Automatically cast to String">a</info>.compareTo("")
}
if (a is String && <info descr="Automatically cast to String">a</info>.compareTo("") == 0) {}
if (a is String || a.<error>compareTo</error>("") == 0) {}
if (a is String || a.<error descr="Unresolved reference: compareTo">compareTo</error>("") == 0) {}
}
//mutability
fun f(): String {
var a: Any = 11
if (a is String) {
val i: String = <error>a</error>
<error>a</error>.compareTo("f")
val f: Function0<String> = { <error>a</error> }
return <error>a</error>
val i: String = <error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to String is impossible, because a could have changed since the is-check">a</error>
<error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to String is impossible, because a could have changed since the is-check">a</error>.compareTo("f")
val f: Function0<String> = { <error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to String is impossible, because a could have changed since the is-check">a</error> }
return <error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to String is impossible, because a could have changed since the is-check">a</error>
}
return ""
}
fun foo(var a: Any): Int {
if (a is Int) {
return <error>a</error>
return <error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to Int is impossible, because a could have changed since the is-check">a</error>
}
return 1
}
idea/testData/checker/infos/PropertiesWithBackingFields.jet
-2
View File
@@ -35,8 +35,6 @@
var <error>v5</error> : Int <info>get</info>() = 1; <info>set</info>(x){$v5 = x}
var <error>v6</error> : Int <info>get</info>() = $v6 + 1; <info>set</info>(x){}
<info>abstract</info> val v7 : Int <info>abstract</info> <info>get</info>
<info>abstract</info> var v8 : Int <info>abstract</info> <info>get</info> <info>abstract</info> <info>set</info>
var <error>v9</error> : Int <info>set</info>
var <error>v10</error> : Int <info>get</info>
idea/testData/checker/infos/WrapIntoRef.jet
+18
View File
@@ -0,0 +1,18 @@
fun notContainsBreak() {
var <info>a</info> = 1
val v = {
<info>a</info> = 2
}
var <info>x</info> = 1
val b = object {
fun foo() {
<info>x</info> = 2
}
}
var <info>y</info> = 1
fun foo() {
<info>y</info> = 1
}
}
idea/testData/checker/regression/Jet67.jet
+1 -1
View File
@@ -1,4 +1,4 @@
abstract class XXX {
abstract val a : Int abstract get
abstract val a : Int get
}
idea/testData/checkerWithErrorTypes/full/Abstract.jet
+45 -45
View File
@@ -29,19 +29,19 @@ class MyClass() {
<!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
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; <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var k1: Int = 0; <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
abstract class MyAbstractClass() {
@@ -73,19 +73,19 @@ abstract class MyAbstractClass() {
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
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; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var j1: Int get() = i; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var k1: Int = 0; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_WITH_BODY, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
trait MyTrait {
@@ -117,19 +117,19 @@ trait MyTrait {
<!REDUNDANT_MODIFIER_IN_TRAIT, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int abstract get abstract set
var i1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
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; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; get() = i; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 abstract set
var k1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var k: Int <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int abstract get abstract set
var l1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_WITH_BODY, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
enum class MyEnum() {
@@ -161,19 +161,19 @@ enum class MyEnum() {
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
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; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var k1: Int = 0; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!ABSTRACT_FUNCTION_WITH_BODY, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
abstract enum class MyAbstractEnum() {}
@@ -207,19 +207,19 @@ namespace MyNamespace {
<!NON_MEMBER_ABSTRACT_FUNCTION!>abstract<!> fun j() {}
//property accessors
var i: Int <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
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; <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var k1: Int = 0; <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var <!MUST_BE_INITIALIZED!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>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 <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get <!NON_MEMBER_ABSTRACT_ACCESSOR, ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set(v: Int) {}
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
}
//creating an instance
idea/testData/checkerWithErrorTypes/full/BreakContinue.jet
+57
View File
@@ -25,4 +25,61 @@ class C {
<!NOT_A_LOOP_LABEL!>break@f<!>
}
fun containsBreak(a: String?, 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")
}
}
idea/testData/checkerWithErrorTypes/full/Constructors.jet
+1 -1
View File
@@ -22,7 +22,7 @@ class WithPC1(a : Int) {
this(s : String) : this(1) {}
this(b : Char) : <!NONE_APPLICABLE!>this("", 2)<!> {}
this(b : Char) : <!NONE_APPLICABLE!>this<!>("", 2) {}
this(b : Byte) : this(""), <!MANY_CALLS_TO_THIS!>this(1)<!> {}
}
idea/testData/checkerWithErrorTypes/full/ExtensionFunctions.jet
+3 -3
View File
@@ -16,7 +16,7 @@ class A
fun A.plus(a : Any) {
1.foo()
true.<!NONE_APPLICABLE!>foo()<!>
true.<!NONE_APPLICABLE!>foo<!>()
1
}
@@ -55,10 +55,10 @@ namespace null_safety {
val command = parse("")
command<!UNSAFE_CALL!>.<!>foo
command.foo
command.equals(null)
command<!UNNECESSARY_SAFE_CALL!>?.<!>equals(null)
command?.equals(null)
command.equals1(null)
command<!UNNECESSARY_SAFE_CALL!>?.<!>equals1(null)
idea/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet
+43
View File
@@ -164,3 +164,46 @@ fun f(): Int {
}
fun f(): Int = if (1 < 2) 1 else returnNothing()
public fun <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>f<!>() = 1
class B() {
protected fun <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>f<!>() = "ss"
}
fun testFunctionLiterals() {
val endsWithVarDeclaration : fun() : Boolean = {
<!EXPECTED_TYPE_MISMATCH!>val x = 2<!>
}
val endsWithAssignment = { () : Int =>
val x = 1
<!EXPECTED_TYPE_MISMATCH!>x = 333<!>
}
val endsWithReAssignment = { () : Int =>
val x = 1
<!EXPECTED_TYPE_MISMATCH!>x += 333<!>
}
val endsWithFunDeclaration : fun() : String = {
val x = 1
x = 333
<!EXPECTED_TYPE_MISMATCH!>fun meow() : Unit {}<!>
}
val endsWithObjectDeclaration : fun() : Int = {
val x = 1
x = 333
<!EXPECTED_TYPE_MISMATCH!>object A {}<!>
}
val expectedUnitReturnType1 = { () : Unit =>
val x = 1
}
val expectedUnitReturnType2 = { () : Unit =>
fun meow() : Unit {}
object A {}
}
}
idea/testData/checkerWithErrorTypes/full/IllegalModifiers.jet
+3 -3
View File
@@ -7,7 +7,7 @@ abstract class A() {
open var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>r<!>: String
get
<!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> protected set
<!ILLEGAL_MODIFIER!>abstract<!> protected set
}
<!TRAIT_CAN_NOT_BE_FINAL!>final<!> trait T {}
@@ -15,7 +15,7 @@ abstract class A() {
class FinalClass() {
<!NON_FINAL_MEMBER_IN_FINAL_CLASS!>open<!> fun foo() {}
val i: Int = 1
<!NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY!>open<!> get(): Int = $i
<!ILLEGAL_MODIFIER!>open<!> get(): Int = $i
var j: Int = 1
<!NON_FINAL_ACCESSOR_OF_FINAL_PROPERTY!>open<!> set(v: Int) {}
<!ILLEGAL_MODIFIER!>open<!> set(v: Int) {}
}
idea/testData/checkerWithErrorTypes/full/NamespaceAsExpression.jet
+1 -1
View File
@@ -4,5 +4,5 @@ namespace a {
}
val x = <!EXPRESSION_EXPECTED_NAMESPACE_FOUND, UNRESOLVED_REFERENCE!>a<!>
val x = <!EXPRESSION_EXPECTED_NAMESPACE_FOUND!>a<!>
val y2 = <!NAMESPACE_IS_NOT_AN_EXPRESSION!>namespace<!>
idea/testData/checkerWithErrorTypes/full/NamespaceInExpressionPosition.jet
+11
View File
@@ -0,0 +1,11 @@
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<!>
idea/testData/checkerWithErrorTypes/full/Properties.jet
+1
View File
@@ -25,4 +25,5 @@ class Test() {
<!UNRESOLVED_REFERENCE!>$b<!> = <!UNRESOLVED_REFERENCE!>$a<!>
a = <!UNRESOLVED_REFERENCE!>$b<!>
}
public val <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>i<!> = 1
}
idea/testData/checkerWithErrorTypes/full/Return.jet
+17
View File
@@ -0,0 +1,17 @@
namespace return
class A {
fun outer() {
fun inner() {
if (1 < 2)
return@inner
else
return@outer
}
if (1 < 2)
<!NOT_A_RETURN_LABEL!>return@A<!>
else if (2 < 3)
<!NOT_A_RETURN_LABEL!>return<!UNRESOLVED_REFERENCE!>@inner<!><!>
return@outer
}
}
idea/testData/checkerWithErrorTypes/full/UnreachableCode.jet
+4 -4
View File
@@ -136,16 +136,16 @@ fun tf() : Int {
}
fun failtest(a : Int) : Int {
<!UNREACHABLE_BECAUSE_OF_NOTHING!>if (fail() || true) {
if (fail() || <!UNREACHABLE_CODE!>true<!>) {
}<!>
<!UNREACHABLE_BECAUSE_OF_NOTHING!>return 1<!>
}
<!UNREACHABLE_CODE!>return 1<!>
}
fun foo(a : Nothing) : Unit {
1
a
<!UNREACHABLE_BECAUSE_OF_NOTHING!>2<!>
<!UNREACHABLE_CODE!>2<!>
}
fun fail() : Nothing {
idea/testData/checkerWithErrorTypes/full/When.jet
+4 -1
View File
@@ -1,3 +1,5 @@
fun Int.foo() : Boolean = true
fun foo() : Int {
val s = ""
val x = 1
@@ -17,7 +19,8 @@ fun foo() : Int {
else => 1
}
return when (<!USELESS_ELVIS!>x<!>?:null) {
<!UNSAFE_CALL!>.<!>equals(1) => 1
<!UNSAFE_CALL!>.<!>foo() => 1
.equals(1) => 1
?.equals(1).equals(2) => 1
}
}
idea/testData/checkerWithErrorTypes/full/infos/Autocasts.jet
-2
View File
@@ -47,11 +47,9 @@ class C() : A() {
}
fun f10(a : A?) {
if (a is B) {
if (a is C) {
a.bar();
}
}
}
fun f11(a : A?) {
idea/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet
+6 -4
View File
@@ -35,10 +35,12 @@ abstract class Test() {
var <!MUST_BE_INITIALIZED!>v5<!> : Int get() = 1; set(x){$v5 = x}
var <!MUST_BE_INITIALIZED!>v6<!> : Int get() = $v6 + 1; set(x){}
abstract val v7 : Int abstract get
abstract var v8 : Int abstract get abstract set
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v9<!> : Int <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> set
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v10<!> : Int <!ABSTRACT_ACCESSOR_OF_NON_ABSTRACT_PROPERTY!>abstract<!> get
abstract val v7 : Int get
abstract var v8 : Int get set
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v9<!> : Int set
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v10<!> : Int get
abstract val v11 : Int <!ILLEGAL_MODIFIER!>abstract<!> get
abstract var v12 : Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
}
idea/testData/checkerWithErrorTypes/full/regression/Jet67.jet
+1 -1
View File
@@ -1,4 +1,4 @@
abstract class XXX {
abstract val a : Int abstract get
abstract val a : Int get
}
idea/testData/checkerWithErrorTypes/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()<!>;
}
}
}
idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet
+41
View File
@@ -0,0 +1,41 @@
class A() {
fun plus(i : Int) {}
fun minus() {}
fun contains(a : Any?) : Boolean = true
}
fun A.div(i : Int) {}
fun A?.times(i : Int) {}
fun test(x : Int?, a : A?) {
x<!UNSAFE_CALL!>.<!>plus(1)
x?.plus(1)
x <!UNSAFE_INFIX_CALL!>plus<!> 1
x <!UNSAFE_INFIX_CALL!>+<!> 1
<!UNSAFE_CALL!>-<!>x
x<!UNSAFE_CALL!>.<!>minus()
x?.minus()
a<!UNSAFE_CALL!>.<!>plus(1)
a?.plus(1)
a <!UNSAFE_INFIX_CALL!>plus<!> 1
a <!UNSAFE_INFIX_CALL!>+<!> 1
<!UNSAFE_CALL!>-<!>a
a<!UNSAFE_CALL!>.<!>minus()
a?.minus()
a<!UNSAFE_CALL!>.<!>div(1)
a <!UNSAFE_INFIX_CALL!>/<!> 1
a <!UNSAFE_INFIX_CALL!>div<!> 1
a?.div(1)
a.times(1)
a * 1
a times 1
a<!UNNECESSARY_SAFE_CALL!>?.<!>times(1)
1 <!UNSAFE_INFIX_CALL!>in<!> a
a <!UNSAFE_INFIX_CALL!>contains<!> 1
a<!UNSAFE_CALL!>.<!>contains(1)
a?.contains(1)
}
idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/PreferExtensionsOnNullableReceiver.jet
+9
View File
@@ -0,0 +1,9 @@
class Foo {
fun foo() {}
}
fun Any?.foo() {}
fun test(f : Foo?) {
f.foo()
}
idea/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/ReceiverNullability.jet
+44
View File
@@ -0,0 +1,44 @@
class A {
fun foo() {}
}
fun A.bar() {}
fun A?.buzz() {}
fun test(a : A?) {
a<!UNSAFE_CALL!>.<!>foo() // error
a<!UNSAFE_CALL!>.<!>bar() // error
a.buzz()
a?.foo()
a?.bar()
a<!UNNECESSARY_SAFE_CALL!>?.<!>buzz() // warning
}
fun A.test() {
foo()
bar()
buzz()
this.foo()
this.bar()
this.buzz()
this<!UNNECESSARY_SAFE_CALL!>?.<!>foo() // warning
this<!UNNECESSARY_SAFE_CALL!>?.<!>bar() // warning
this<!UNNECESSARY_SAFE_CALL!>?.<!>buzz() // warning
}
fun A?.test() {
<!UNSAFE_CALL!>foo<!>() // error
<!UNSAFE_CALL!>bar<!>() // error
buzz()
this<!UNSAFE_CALL!>.<!>foo() // error
this<!UNSAFE_CALL!>.<!>bar() // error
this.buzz()
this?.foo()
this?.bar()
this<!UNNECESSARY_SAFE_CALL!>?.<!>buzz() // warning
}
idea/testData/codegen/classes/outerThis.jet
+1 -1
View File
@@ -3,7 +3,7 @@ class Outer() {
val outer: Outer get() = this@Outer
}
public val x = Inner()
public val x : Inner = Inner()
}
fun box() : String {
idea/testData/codegen/classes/propertyDelegation.jet
+1 -1
View File
@@ -1,5 +1,5 @@
open class Base() {
public val plain = 239
val plain = 239
public val read : Int
get() = 239
idea/testData/codegen/classes/propertyInInitializer.jet
+2 -2
View File
@@ -1,5 +1,5 @@
class Outer() {
public val s = "xyzzy"
val s = "xyzzy"
open class InnerBase(public val name: String) {
}
@@ -7,7 +7,7 @@ class Outer() {
class InnerDerived(): InnerBase(s) {
}
public val x = InnerDerived()
val x = InnerDerived()
}
fun box() : String {
idea/testData/codegen/regressions/kt343.jet
+24
View File
@@ -0,0 +1,24 @@
import java.util.ArrayList
fun launch(f : fun() : Unit) {
f()
}
fun box(): String {
val list = ArrayList<Int>()
val foo : fun() : Unit = {
list.add(2) //first exception
}
foo()
launch({
list.add(3)
})
val bar = {
val x = 1 //second exception
}
bar()
return if (list.size() == 2 && list.get(0) == 2 && list.get(1) == 3) "OK" else "fail"
}
idea/testData/quickfix/abstract/afterAbstractFunctionWithBody2.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove function body" "true"
abstract class A() {
<caret>abstract fun foo() : Any
}
idea/testData/quickfix/abstract/afterAbstractFunctionWithBody3.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove function body" "true"
abstract class A() {
<caret>abstract fun foo() : Any
}
idea/testData/quickfix/abstract/afterNonMemberAbstractAccessor.kt
-2
View File
@@ -1,2 +0,0 @@
// "Make 'get' not abstract" "true"
val i : Int = 0; <caret>get
idea/testData/quickfix/abstract/beforeAbstractFunctionWithBody2.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove function body" "true"
abstract class A() {
<caret>abstract fun foo() : Any { return "a" }
}
idea/testData/quickfix/abstract/beforeAbstractFunctionWithBody3.kt
+4
View File
@@ -0,0 +1,4 @@
// "Remove function body" "true"
abstract class A() {
<caret>abstract fun foo() : Any = 1
}
idea/testData/quickfix/abstract/beforeNonMemberAbstractAccessor.kt
-2
View File
@@ -1,2 +0,0 @@
// "Make 'get' not abstract" "true"
val i : Int = 0; <caret>abstract get
idea/testData/quickfix/modifiers/afterNonFinalAccessorOfFinalProperty1.kt
-5
View File
@@ -1,5 +0,0 @@
// "Make 'i' open" "true"
open class A() {
open val i: Int = 1
<caret>open get(): Int = $i
}
idea/testData/quickfix/modifiers/afterNonFinalAccessorOfFinalProperty2.kt
-5
View File
@@ -1,5 +0,0 @@
// "Make 'get' not open" "true"
open class A() {
val i: Int = 1
<caret>get(): Int = $i
}
idea/testData/quickfix/modifiers/beforeNonFinalAccessorOfFinalProperty1.kt
-5
View File
@@ -1,5 +0,0 @@
// "Make 'i' open" "true"
open class A() {
val i: Int = 1
<caret>open get(): Int = $i
}
idea/testData/quickfix/modifiers/beforeNonFinalAccessorOfFinalProperty2.kt
-5
View File
@@ -1,5 +0,0 @@
// "Make 'get' not open" "true"
open class A() {
val i: Int = 1
<caret>open get(): Int = $i
}
idea/testData/quickfix/typeAddition/afterProtectedFunWithoutReturnType.kt
+6
View File
@@ -0,0 +1,6 @@
// "Add return type declaration" "true"
namespace a
class A() {
protected fun <caret>foo() : Int = 1
}
idea/testData/quickfix/typeAddition/afterPublicFunWithoutReturnType.kt
+6
View File
@@ -0,0 +1,6 @@
// "Add return type declaration" "true"
namespace a
class A() {
public fun <caret>foo() : String = "a"
}
idea/testData/quickfix/typeAddition/afterPublicValWithoutReturnType.kt
+6
View File
@@ -0,0 +1,6 @@
// "Add return type declaration" "true"
namespace a
import java.util.List
public val <caret>l : List<Int>? = java.util.Collections.emptyList<Int>()
idea/testData/quickfix/typeAddition/beforeInternalProtectedFunWithoutReturnType.kt
+6
View File
@@ -0,0 +1,6 @@
// "Add return type declaration" "false"
namespace a
class A() {
internal protected fun <caret>foo() = 1
}
idea/testData/quickfix/typeAddition/beforeProtectedFunWithoutReturnType.kt
+6
View File
@@ -0,0 +1,6 @@
// "Add return type declaration" "true"
namespace a
class A() {
protected fun <caret>foo() = 1
}
idea/testData/quickfix/typeAddition/beforePublicFunWithoutBody.kt
+6
View File
@@ -0,0 +1,6 @@
// "Add return type declaration" "false"
namespace a
class A() {
public fun <caret>foo()
}
idea/testData/quickfix/typeAddition/beforePublicFunWithoutReturnType.kt
+6
View File
@@ -0,0 +1,6 @@
// "Add return type declaration" "true"
namespace a
class A() {
public fun <caret>foo() = "a"
}
idea/testData/quickfix/typeAddition/beforePublicValWithoutReturnType.kt
+4
View File
@@ -0,0 +1,4 @@
// "Add return type declaration" "true"
namespace a
public val <caret>l = java.util.Collections.emptyList<Int>()