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

'quick' directory renamed to 'tests' which reflects its contents

Browse Source
This commit is contained in:
Andrey Breslav
2011-12-01 14:40:31 +03:00
parent 8e8d74e199
commit aad2d17cd8
213 changed files with 2 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/infos/Autocasts.jet
+253
View File
@@ -0,0 +1,253 @@
open class A() {
fun foo() {}
}
class B() : A() {
fun bar() {}
}
fun f9(init : A?) {
val a : A? = init
a?.foo()
a?.<!UNRESOLVED_REFERENCE!>bar<!>()
if (a is B) {
a.bar()
a.foo()
}
a?.foo()
a?.<!UNRESOLVED_REFERENCE!>bar<!>()
if (!(a is B)) {
a?.<!UNRESOLVED_REFERENCE!>bar<!>()
a?.foo()
}
if (!(a is B) || a.bar() == ()) {
a?.<!UNRESOLVED_REFERENCE!>bar<!>()
}
if (!(a is B)) {
return;
}
a.bar()
a.foo()
}
fun f10(init : A?) {
val a : A? = init
if (!(a is B)) {
return;
}
if (!(a is B)) {
return;
}
}
class C() : A() {
fun bar() {
}
}
fun f101(a : A?) {
if (a is C) {
a.bar();
}
}
fun f11(a : A?) {
when (a) {
is B => a.bar()
is A => a.foo()
is Any => a.foo()
is Any? => a.<!UNRESOLVED_REFERENCE!>bar<!>()
else => a?.foo()
}
}
fun f12(a : A?) {
when (a) {
is B => a.bar()
is A => a.foo()
is Any => a.foo();
is Any? => a.<!UNRESOLVED_REFERENCE!>bar<!>()
is val c : <!TYPE_MISMATCH_IN_BINDING_PATTERN!>B<!> => c.foo()
is val c is C => c.bar()
is val c is C => a.bar()
else => a?.foo()
}
if (a is val b) {
a?.<!UNRESOLVED_REFERENCE!>bar<!>()
b?.foo()
}
if (a is val b is B) {
b.foo()
a.bar()
b.bar()
}
}
fun f13(a : A?) {
if (a is val c is B) {
c.foo()
c.bar()
}
else {
a?.foo()
<!UNRESOLVED_REFERENCE!>c<!>.bar()
}
a?.foo()
if (!(a is val c is B)) {
a?.foo()
<!UNRESOLVED_REFERENCE!>c<!>.bar()
}
else {
a.foo()
<!UNRESOLVED_REFERENCE!>c<!>.bar()
}
a?.foo()
if (a is val c is B && a.foo() == () && c.bar() == ()) {
c.foo()
c.bar()
}
else {
a?.foo()
<!UNRESOLVED_REFERENCE!>c<!>.bar()
}
if (!(a is val c is B) || !(a is val x is C)) {
<!UNRESOLVED_REFERENCE!>x<!>
<!UNRESOLVED_REFERENCE!>c<!>
}
else {
<!UNRESOLVED_REFERENCE!>x<!>
<!UNRESOLVED_REFERENCE!>c<!>
}
if (!(a is val c is B) || !(a is val c is C)) {
}
if (!(a is val c is B)) return
a.bar()
<!UNRESOLVED_REFERENCE!>c<!>.foo()
<!UNRESOLVED_REFERENCE!>c<!>.bar()
}
fun f14(a : A?) {
while (!(a is val c is B)) {
}
a.bar()
<!UNRESOLVED_REFERENCE!>c<!>.bar()
}
fun f15(a : A?) {
do {
} while (!(a is val c is B))
a.bar()
<!UNRESOLVED_REFERENCE!>c<!>.bar()
}
fun getStringLength(obj : Any) : Char? {
if (obj !is String)
return null
return obj.get(0) // no cast to String is needed
}
fun toInt(i: Int?): Int = if (i != null) i else 0
fun illegalWhenBody(a: Any): Int = when(a) {
is Int => a
is String => <!TYPE_MISMATCH!>a<!>
}
fun illegalWhenBlock(a: Any): Int {
when(a) {
is Int => return a
is String => return <!TYPE_MISMATCH!>a<!>
}
}
fun declarations(a: Any?) {
if (a is String) {
val <!UNUSED_VARIABLE!>p4<!>: (Int, String) = (2, a)
}
if (a is String?) {
if (a != null) {
val <!UNUSED_VARIABLE!>s<!>: String = a
}
}
if (a != null) {
if (a is String?) {
val <!UNUSED_VARIABLE!>s<!>: String = a
}
}
}
fun vars(a: Any?) {
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>b<!>: Int = 0
if (a is Int) {
b = <!UNUSED_VALUE!>a<!>
}
}
fun tuples(a: Any?) {
if (a != null) {
val <!UNUSED_VARIABLE!>s<!>: (Any, String) = (a, <!TYPE_MISMATCH!>a<!>)
}
if (a is String) {
val <!UNUSED_VARIABLE!>s<!>: (Any, String) = (a, a)
}
fun illegalTupleReturnType(): (Any, String) = (<!TYPE_MISMATCH!>a<!>, <!TYPE_MISMATCH!>a<!>)
if (a is String) {
fun legalTupleReturnType(): (Any, String) = (a, a)
}
val <!UNUSED_VARIABLE!>illegalFunctionLiteral<!>: Function0<Int> = <!TYPE_MISMATCH!>{ <!TYPE_MISMATCH!>a<!> }<!>
val <!UNUSED_VARIABLE!>illegalReturnValueInFunctionLiteral<!>: Function0<Int> = { (): Int => <!TYPE_MISMATCH!>a<!> }
if (a is Int) {
val <!UNUSED_VARIABLE!>legalFunctionLiteral<!>: Function0<Int> = { a }
val <!UNUSED_VARIABLE!>alsoLegalFunctionLiteral<!>: Function0<Int> = { (): Int => a }
}
}
fun returnFunctionLiteralBlock(a: Any?): Function0<Int> {
if (a is Int) return { a }
else return { 1 }
}
fun returnFunctionLiteral(a: Any?): Function0<Int> =
if (a is Int) { (): Int => a }
else { () => 1 }
fun illegalTupleReturnType(a: Any): (Any, String) = (a, <!TYPE_MISMATCH!>a<!>)
fun declarationInsidePattern(x: (Any, Any)): String = when(x) { is (val a is String, *) => a; else => "something" }
fun mergeAutocasts(a: Any?) {
if (a is String || a is Int) {
a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
a.toString()
}
if (a is Int || a is String) {
a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
}
when (a) {
is String, is Any => a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
}
if (a is String && a is Any) {
val <!UNUSED_VARIABLE!>i<!>: Int = a.compareTo("")
}
if (a is String && a.compareTo("") == 0) {}
if (a is String || a.<!UNRESOLVED_REFERENCE!>compareTo<!>("") == 0) {}
}
//mutability
fun f(): String {
var a: Any = 11
if (a is String) {
val <!UNUSED_VARIABLE!>i<!>: String = <!AUTOCAST_IMPOSSIBLE!>a<!>
<!AUTOCAST_IMPOSSIBLE!>a<!>.compareTo("f")
val <!UNUSED_VARIABLE!>f<!>: Function0<String> = { <!AUTOCAST_IMPOSSIBLE!>a<!> }
return <!AUTOCAST_IMPOSSIBLE!>a<!>
}
return ""
}
fun foo(var a: Any): Int {
if (a is Int) {
return <!AUTOCAST_IMPOSSIBLE!>a<!>
}
return 1
}
compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.jet
+59
View File
@@ -0,0 +1,59 @@
abstract class Test() {
abstract val x : Int
abstract val x1 : Int get
abstract val x2 : Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!> : Int
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!> : Int get
val c = 1
val c1 = 1
get
val c2 : Int
get() = 1
val c3 : Int
get() { return 1 }
val c4 : Int
get() = 1
val <!MUST_BE_INITIALIZED!>c5<!> : Int
get() = $c5 + 1
abstract var y : Int
abstract var y1 : Int get
abstract var y2 : Int set
abstract var y3 : Int set get
abstract var y4 : Int set <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
abstract var y5 : Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(x) {}<!> <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
abstract var y6 : Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(x) {}<!>
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v<!> : Int
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v1<!> : Int get
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>v2<!> : Int get set
var <!MUST_BE_INITIALIZED!>v3<!> : Int get() = 1; set
var v4 : Int get() = 1; set(x){}
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 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
}
open class Super(i : Int)
class TestPCParameters(w : Int, x : Int, val y : Int, var z : Int) : Super(w) {
val xx = w
{
w + 1
}
fun foo() = <!UNRESOLVED_REFERENCE!>x<!>
}