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

FIR: Support special scope for raw types

Browse Source 
^KT-46369 Fixed
^KT-41794 Fixed
^KT-49351 Fixed
This commit is contained in:
Denis.Zharkov
2022-10-13 10:50:45 +02:00
committed by Space Team
parent 1215ae0fe7
commit 5cc31114cd
39 changed files with 225 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/j+k/rawTypeScope.fir.kt
Vendored
-17
View File
@@ -1,17 +0,0 @@
// SKIP_TXT
// FILE: A.java
public class A {
public static B getB() { return null; }
}
// FILE: B.java
public class B<E> {
public void foo(java.util.Map<String, String> x) {}
}
// FILE: main.kt
fun main(x: Map<Any, Any>) {
A.getB().foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>) // OK in FE1.0 ( but probably shouldn't), ARGUMENT_TYPE_MISMATCH at FIR
}
compiler/testData/diagnostics/tests/j+k/rawTypeScope.kt
Vendored
+2 -1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// SKIP_TXT
// FILE: A.java
@@ -13,5 +14,5 @@ public class B<E> {
// FILE: main.kt
fun main(x: Map<Any, Any>) {
A.getB().foo(x) // OK in FE1.0 ( but probably shouldn't), ARGUMENT_TYPE_MISMATCH at FIR
A.getB().foo(x)
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.fir.kt
Vendored
+4 -4
View File
@@ -29,15 +29,15 @@ fun main() {
raw.charSequences = arrayOf<String>()
raw.charSequences = <!ASSIGNMENT_TYPE_MISMATCH!>arrayOf<Double>()<!>
raw.maps = <!ASSIGNMENT_TYPE_MISMATCH!>arrayOf<Map<Int, Int>>()<!>
raw.maps = <!ASSIGNMENT_TYPE_MISMATCH!>arrayOf<MutableMap<Int, Int>>()<!>
raw.maps = arrayOf<Map<Int, Int>>()
raw.maps = arrayOf<MutableMap<Int, Int>>()
raw.maps = <!ASSIGNMENT_TYPE_MISMATCH!>arrayOf<List<String>>()<!>
raw.arraysOfLists = <!ASSIGNMENT_TYPE_MISMATCH!>arrayOf<Array<List<*>>>()<!>
raw.arraysOfLists = arrayOf<Array<List<*>>>()
raw.arraysOfLists = <!ASSIGNMENT_TYPE_MISMATCH!>arrayOf<List<String>>()<!>
raw.arraysOfLists = <!ASSIGNMENT_TYPE_MISMATCH!>arrayOf<Array<Array<String>>>()<!>
raw.arraysOfAny = arrayOf<Array<Array<String>>>()
raw.erasedLists = <!ASSIGNMENT_TYPE_MISMATCH!>arrayOf<List<String>>()<!>
raw.erasedLists = arrayOf<List<String>>()
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.fir.kt
Vendored
-34
View File
@@ -1,34 +0,0 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: A.java
import java.util.*;
class A<T> {
void foo(T x) {}
public class Inner<E> {
Inner(E x0, T x, List<T> y) {}
void foo(E x0, T x, List<T> y) {}
A<Map<E, T>> bar() {}
}
}
// FILE: Test.java
class Test {
static A rawAField = null;
}
// FILE: main.kt
val strList: List<String> = null!!
fun main() {
val rawA = Test.rawAField
var rawInner = rawA.Inner<Double>(<!ARGUMENT_TYPE_MISMATCH!>""<!>, "", strList)
rawInner.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, "", strList)
rawInner.bar().foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: A.java
compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonRawArraysInRawType.kt
Vendored
+27
View File
@@ -0,0 +1,27 @@
// SKIP_TXT
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: Generic.java
import java.util.List;
public class Generic<T> {
public static class ML<E> {}
public static Generic create() { return null; }
public String[] getFoo()
}
// FILE: main.kt
fun main() {
val generic = Generic.create()
for (x in generic.foo) {
x.length // Arrays don't become raw
}
for (x in generic.getFoo()) {
x.length // Arrays don't become raw
}
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.fir.kt
Vendored
-36
View File
@@ -1,36 +0,0 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: A.java
import java.util.*;
class A<T> {
List<T> x;
void foo(T x, List<T> y) {}
A<List<T>> bar() {}
}
// FILE: Test.java
class Test {
static class RawADerived extends A {
}
}
// FILE: main.kt
val strList: List<String> = null!!
val strMap: Map<String, String> = null!!
fun main() {
val rawADerived = Test.RawADerived()
rawADerived.x = strList
rawADerived.foo("", strList)
val rawA = rawADerived.bar()
rawA.x = <!ASSIGNMENT_TYPE_MISMATCH!>strList<!>
rawA.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>strList<!>)
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: A.java
compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertypeOverride.fir.kt
Vendored
-41
View File
@@ -1,41 +0,0 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: A.java
import java.util.*;
public class A<T extends CharSequence> {
A<List<T>> foo(T x, Map<String, List<T>> y, HashMap<T, T> z) {}
void bar(List<Double[]>[][] d) {}
}
// FILE: RawADerived.java
public class RawADerived extends A {
}
// FILE: main.kt
import java.util.*;
class B1 : RawADerived() {
<!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: CharSequence, y: Map<Any?, Any?>, z: HashMap<Any, Any>): A<*> = null!!
<!NOTHING_TO_OVERRIDE!>override<!> fun bar(d: Array<Array<List<*>>>) {}
}
class B2 : RawADerived() {
<!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: CharSequence?, y: MutableMap<Any?, Any?>, z: HashMap<Any?, Any?>): A<String> = null!!
<!NOTHING_TO_OVERRIDE!>override<!> fun bar(d: Array<Array<MutableList<*>>>) {}
}
class B3 : RawADerived() {
// Type of second parameter (y) is not equal to overridden
// RawADerived.foo.y --- (MutableMap<Any?, Any?>..Map<out Any?, out Any?>) is not a subtype of Map<Any?, Any>
<!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: CharSequence, y: Map<Any?, Any>, z: HashMap<Any, Any>): A<*> = null!!
}
class B4 : RawADerived() {
// Type of first parameter is not equal to overridden
override fun bar(d: Array<Array<MutableList<Array<Double>>>>) {}
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertypeOverride.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: A.java
compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.fir.kt
Vendored
+5 -4
View File
@@ -26,16 +26,17 @@ public class Test {
// FILE: main.kt
fun foo(x: B<*>) {
// TODO: x.foo() now is flexible type instead of raw, because of captured type approximation
val q: MutableList<String> = x.foo().getChildrenStubs()
// TODO: In K1, x.foo() now is flexible type instead of raw, because of captured type approximation
// Works in K2 as expected: x.foo() returns raw `A`, thus it's `getChildrenStubs` has a type `MutableList<Any!>..List<*>?`
val q: MutableList<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.foo().getChildrenStubs()<!>
// Raw(B).field erased to A<Any!>..A<out Any!>?
Test.rawB.field = A<String>()
val anyA: A<Any> = <!INITIALIZER_TYPE_MISMATCH!>Test.rawB.field<!>
val anyA: A<Any> = Test.rawB.field
// FIR doesn't work here, because
// field has a type of just 'A' and it's not clear why should it accept 'String' at consume
// NB: some kind of BareTypeScope should be in use here
Test.rawB.field.consume(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
Test.rawB.field.consume("")
val y: Any = Test.rawB.field.produce()
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.kt
Vendored
+2 -1
View File
@@ -26,7 +26,8 @@ public class Test {
// FILE: main.kt
fun foo(x: B<*>) {
// TODO: x.foo() now is flexible type instead of raw, because of captured type approximation
// TODO: In K1, x.foo() now is flexible type instead of raw, because of captured type approximation
// Works in K2 as expected: x.foo() returns raw `A`, thus it's `getChildrenStubs` has a type `MutableList<Any!>..List<*>?`
val q: MutableList<String> = x.foo().getChildrenStubs()
// Raw(B).field erased to A<Any!>..A<out Any!>?
compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.fir.kt
Vendored
-39
View File
@@ -1,39 +0,0 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: A.java
import java.util.*;
class A<T> {
List<T> x;
Map<T, T> y;
A<Map<String, T>> z;
void foo(T x, List<T> y, List<Map<Integer, T>> z) {}
A<List<T>> bar() {}
}
// FILE: Test.java
class Test {
static A rawAField = null;
}
// FILE: main.kt
val strList: List<String> = null!!
val strMap: Map<String, String> = null!!
fun main() {
val rawA = Test.rawAField
rawA.x = strList
rawA.y = <!ASSIGNMENT_TYPE_MISMATCH!>strMap<!>
rawA.foo("", strList, <!ARGUMENT_TYPE_MISMATCH!>strList<!>)
val barResult = rawA.bar()
barResult.x = <!ASSIGNMENT_TYPE_MISMATCH!>strList<!>
barResult.y = <!ASSIGNMENT_TYPE_MISMATCH!>strMap<!>
barResult.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>strList<!>, null)
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: A.java
compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.fir.kt
Vendored
-27
View File
@@ -1,27 +0,0 @@
// FILE: A.java
import org.jetbrains.annotations.*;
import java.util.*;
class A<T> {
@NotNull
List<String> foo(@NotNull T x, @Nullable List<String> y) {}
}
// FILE: Test.java
class Test {
static class DerivedRawA extends A {}
static A rawField = null;
}
// FILE: main.kt
val doubleList: List<Double?> = null!!
fun main() {
Test.rawField.foo("", <!ARGUMENT_TYPE_MISMATCH!>doubleList<!>)
Test.rawField.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!ARGUMENT_TYPE_MISMATCH!>doubleList<!>)
Test.DerivedRawA().foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!ARGUMENT_TYPE_MISMATCH!>doubleList<!>)
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// FILE: A.java
import org.jetbrains.annotations.*;