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

[FIR] do not ignore nested type aliases in FirNestedClassifierScope

Browse Source
This commit is contained in:
Ilya Kirillov
2022-11-10 14:29:41 +01:00
parent 7059f7fbe7
commit 4b7cacd55e
12 changed files with 45 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
analysis/analysis-api/testData/symbols/symbolByPsi/outerAndInnerTypeAlias.pretty.txt
Vendored
+2
View File
@@ -4,4 +4,6 @@ typealias TopLevelAlias = X<kotlin.Int>
class A {
fun check()
typealias NestedLevelAlias = X<kotlin.String>
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt
+10 -6
View File
@@ -8,11 +8,13 @@ package org.jetbrains.kotlin.fir.scopes.impl
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -21,7 +23,7 @@ import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
import org.jetbrains.kotlin.name.Name
abstract class FirNestedClassifierScope(val klass: FirClass, val useSiteSession: FirSession) : FirContainingNamesAwareScope() {
protected abstract fun getNestedClassSymbol(name: Name): FirRegularClassSymbol?
protected abstract fun getNestedClassSymbol(name: Name): FirClassLikeSymbol<*>?
override fun processClassifiersByNameWithSubstitution(
name: Name,
@@ -40,17 +42,19 @@ abstract class FirNestedClassifierScope(val klass: FirClass, val useSiteSession:
}
class FirNestedClassifierScopeImpl(klass: FirClass, useSiteSession: FirSession) : FirNestedClassifierScope(klass, useSiteSession) {
private val classIndex: Map<Name, FirRegularClassSymbol> = run {
val result = mutableMapOf<Name, FirRegularClassSymbol>()
private val classIndex: Map<Name, FirClassLikeSymbol<*>> = run {
val result = mutableMapOf<Name, FirClassLikeSymbol<*>>()
for (declaration in klass.declarations) {
if (declaration is FirRegularClass) {
result[declaration.name] = declaration.symbol
when (declaration) {
is FirRegularClass -> result[declaration.name] = declaration.symbol
is FirTypeAlias -> result[declaration.name] = declaration.symbol
else -> {}
}
}
result
}
override fun getNestedClassSymbol(name: Name): FirRegularClassSymbol? {
override fun getNestedClassSymbol(name: Name): FirClassLikeSymbol<*>? {
return classIndex[name]
}
compiler/testData/diagnostics/tests/typealias/exposedExpandedType.fir.kt
Vendored
-45
View File
@@ -1,45 +0,0 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
typealias L<T> = List<T>
class Outer {
private class Private
protected class Protected
internal class Internal
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate1<!> = Private
protected typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate2<!> = Private
internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate3<!> = Private
private typealias TestPrivate4 = Private
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate5<!> = L<Private>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate6<!> = L<TestPrivate1>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected1<!> = Protected
protected typealias TestProtected2 = Protected
internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected3<!> = Protected
private typealias TestProtected4 = Protected
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected5<!> = L<Protected>
typealias TestProtected6 = L<<!UNRESOLVED_REFERENCE!>TestProtected1<!>>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal1<!> = Internal
protected typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal2<!> = Internal
internal typealias TestInternal3 = Internal
private typealias TestInternal4 = Internal
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal5<!> = L<Internal>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal6<!> = L<TestInternal1>
}
private class Private
internal class Internal
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate1<!> = Private
internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate2<!> = Private
private typealias TestPrivate3 = Private
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate4<!> = L<Private>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate5<!> = L<TestPrivate1>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal1<!> = Internal
internal typealias TestInternal2 = Internal
private typealias TestInternal3 = Internal
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal4<!> = L<Internal>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal5<!> = L<TestInternal1>
compiler/testData/diagnostics/tests/typealias/exposedExpandedType.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
typealias L<T> = List<T>
compiler/testData/diagnostics/tests/typealias/innerTypeAliasAsType.fir.kt
Vendored
+6 -6
View File
@@ -11,12 +11,12 @@ class Outer<T> {
typealias InnerAlias = Inner
typealias GenericInnerAlias<TT> = GenericInner<TT>
fun test1(x: <!UNRESOLVED_REFERENCE!>NestedAlias<!>) = x
fun test2(x: <!UNRESOLVED_REFERENCE!>GenericNestedAlias<Int><!>) = x
fun <T> test3(x: <!UNRESOLVED_REFERENCE!>GenericNestedAlias<T><!>) = x
fun test4(x: <!UNRESOLVED_REFERENCE!>InnerAlias<!>) = x
fun test5(x: <!UNRESOLVED_REFERENCE!>GenericInnerAlias<Int><!>) = x
fun <T> test6(x: <!UNRESOLVED_REFERENCE!>GenericInnerAlias<T><!>) = x
fun test1(x: NestedAlias) = x
fun test2(x: GenericNestedAlias<Int>) = x
fun <T> test3(x: GenericNestedAlias<T>) = x
fun test4(x: InnerAlias) = x
fun test5(x: GenericInnerAlias<Int>) = x
fun <T> test6(x: GenericInnerAlias<T>) = x
}
fun test1(x: Outer<Int>.NestedAlias) = x
fun <T> test2(x: Outer<T>.NestedAlias) = x
compiler/testData/diagnostics/tests/typealias/innerTypeAliasConstructor.fir.kt
Vendored
+8 -8
View File
@@ -10,14 +10,14 @@ class C<T> {
// C<...>.P[<...>]() syntax doesn't work due to the way qualified expressions are resolved now.
// This restriction can be removed later.
val test0 = C<Int>.<!UNRESOLVED_REFERENCE!>P<!>(1, 1)
val test1 = C<Int>.<!UNRESOLVED_REFERENCE!>P1<!><String>("", 1)
val test2 = C<Int>.<!UNRESOLVED_REFERENCE!>P2<!><String>(1, "")
val test3 = C<Int>.<!UNRESOLVED_REFERENCE!>P1<!>("", 1)
val test4 = C<Int>.<!UNRESOLVED_REFERENCE!>P2<!>(1, "")
val test0 = C<Int>.P(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>1<!>)
val test1 = C<Int>.P1<String>("", <!ARGUMENT_TYPE_MISMATCH!>1<!>)
val test2 = C<Int>.P2<String>(<!ARGUMENT_TYPE_MISMATCH!>1<!>, "")
val test3 = C<Int>.P1("", <!ARGUMENT_TYPE_MISMATCH!>1<!>)
val test4 = C<Int>.P2(<!ARGUMENT_TYPE_MISMATCH!>1<!>, "")
// C.P() syntax could work if we add captured type parameters as type variables in a constraint system for corresponding call.
// However, this should be consistent with inner classes capturing type parameters.
val test5 = C.<!UNRESOLVED_REFERENCE!>P<!>(1, 1)
val test6 = C.<!UNRESOLVED_REFERENCE!>P1<!>("", 1)
val test7 = C.<!UNRESOLVED_REFERENCE!>P2<!>(1, "")
val test5 = C.P(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>1<!>)
val test6 = C.P1("", <!ARGUMENT_TYPE_MISMATCH!>1<!>)
val test7 = C.P2(<!ARGUMENT_TYPE_MISMATCH!>1<!>, "")
compiler/testData/diagnostics/tests/typealias/nested.fir.kt
Vendored
-24
View File
@@ -1,24 +0,0 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
class Pair<T1, T2>(val x1: T1, val x2: T2)
class C {
typealias P2 = Pair<Int, Int>
fun p() = <!UNRESOLVED_REFERENCE!>P2<!>(1, 1)
fun first(p: <!UNRESOLVED_REFERENCE!>P2<!>) = p.<!UNRESOLVED_REFERENCE!>x1<!>
fun second(p: <!UNRESOLVED_REFERENCE!>P2<!>) = p.<!UNRESOLVED_REFERENCE!>x2<!>
}
val p1 = Pair(1, 1)
val test1: Int = C().first(p1)
val test2: Int = C().second(p1)
fun C.testExtFun1(x: C.P2) = x
fun C.testExtFun2(): C.P2 {
val x: C.P2 = p()
val y = C.<!UNRESOLVED_REFERENCE!>P2<!>(1, 1)
return x
}
compiler/testData/diagnostics/tests/typealias/nested.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
class Pair<T1, T2>(val x1: T1, val x2: T2)
compiler/testData/diagnostics/tests/typealias/nestedCapturingTypeParameters.fir.kt
Vendored
+8 -8
View File
@@ -6,18 +6,18 @@ class C<T> {
typealias P2 = Pair<T, T>
typealias PT2<T2> = Pair<T, T2>
fun first(p: <!UNRESOLVED_REFERENCE!>P2<!>) = p.<!UNRESOLVED_REFERENCE!>x1<!>
fun second(p: <!UNRESOLVED_REFERENCE!>P2<!>) = p.<!UNRESOLVED_REFERENCE!>x2<!>
fun first(p: P2) = p.x1
fun second(p: P2) = p.x2
fun <T2> first2(p: <!UNRESOLVED_REFERENCE!>PT2<T2><!>) = p.<!UNRESOLVED_REFERENCE!>x1<!>
fun <T2> second2(p: <!UNRESOLVED_REFERENCE!>PT2<T2><!>) = p.<!UNRESOLVED_REFERENCE!>x2<!>
fun <T2> first2(p: PT2<T2>) = p.x1
fun <T2> second2(p: PT2<T2>) = p.x2
}
val p1 = Pair(1, 1)
val p2 = Pair(1, "")
val test1: Int = C<Int>().first(p1)
val test2: Int = C<Int>().second(p1)
val test1: Int = C<Int>().first(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
val test2: Int = C<Int>().second(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
val test3: Int = C<Int>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>first2<!>(p2)
val test4: String = C<Int>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>second2<!>(p2)
val test3: Int = C<Int>().first2(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
val test4: String = C<Int>().second2(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
compiler/testData/diagnostics/tests/typealias/typeAliasAsQualifier.fir.kt
Vendored
+6 -6
View File
@@ -13,9 +13,9 @@ class C {
}
}
val c = C.<!UNRESOLVED_REFERENCE!>Self<!>.Self()
val n = C.<!UNRESOLVED_REFERENCE!>Self<!>.Nested()
val x = C.<!UNRESOLVED_REFERENCE!>Self<!>.X
val n2 = C.Nested.<!UNRESOLVED_REFERENCE!>Root<!>.Nested.N2()
val ic = C.<!UNRESOLVED_REFERENCE!>Self<!>.InCompanion()
val ok = C.<!UNRESOLVED_REFERENCE!>Self<!>.ok
val c = C.Self.<!UNRESOLVED_REFERENCE!>Self<!>()
val n = C.Self.<!UNRESOLVED_REFERENCE!>Nested<!>()
val x = C.Self.<!UNRESOLVED_REFERENCE!>X<!>
val n2 = C.Nested.Root.<!UNRESOLVED_REFERENCE!>Nested<!>.N2()
val ic = C.Self.<!UNRESOLVED_REFERENCE!>InCompanion<!>()
val ok = C.Self.ok
compiler/testData/diagnostics/tests/typealias/typeAliasAsSuperQualifier.fir.kt
Vendored
+2 -2
View File
@@ -22,7 +22,7 @@ class TestSuperForBase : B() {
override fun foo() {
super<Base>.foo()
super<B>.foo()
super<<!NOT_A_SUPERTYPE!>MyBase<!>>.foo()
super<MyBase>.foo()
super<<!NOT_A_SUPERTYPE!>U<!>>.foo()
}
}
@@ -34,7 +34,7 @@ class TestSuperForGenericBase<T> : GB<T>() {
override fun foo() {
super<GenericBase>.foo()
super<GB>.foo()
super<<!NOT_A_SUPERTYPE!>MyBase<!>>.foo()
super<MyBase>.foo()
super<<!NOT_A_SUPERTYPE!>MyBaseInt<!>>.foo() // Type arguments don't matter here
super<<!NOT_A_SUPERTYPE!>U<!>>.foo()
}
compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongClass.fir.kt
Vendored
+1 -1
View File
@@ -28,7 +28,7 @@ typealias Test5 = Outer.Inner
val test5 = <!RESOLUTION_TO_CLASSIFIER!>Test5<!>()
val test5a = Outer.<!RESOLUTION_TO_CLASSIFIER!>Inner<!>()
val test5b = Outer.<!UNRESOLVED_REFERENCE!>TestInner<!>()
val test5b = Outer.<!RESOLUTION_TO_CLASSIFIER!>TestInner<!>()
val test5c = Outer().<!UNRESOLVED_REFERENCE!>TestInner<!>()
val test5d = Outer().Inner()
val test5e = Outer().Test5()