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

JavaClassifierTypeImpl: convert to Kotlin & cleanup

Browse Source
This commit is contained in:
Mikhail Glukhikh
2019-03-01 12:40:42 +03:00
parent 21d19f4144
commit 484e67727f
1 changed files with 55 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.kt
+55 -88
View File
@@ -14,97 +14,67 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.load.java.structure.impl; package org.jetbrains.kotlin.load.java.structure.impl
import com.intellij.psi.*; import com.intellij.psi.*
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.load.java.structure.JavaClassifierType
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.load.java.structure.JavaType
import org.jetbrains.kotlin.load.java.structure.JavaClassifierType;
import org.jetbrains.kotlin.load.java.structure.JavaType;
import java.util.ArrayList; import java.util.ArrayList
import java.util.Collections;
import java.util.List;
public class JavaClassifierTypeImpl extends JavaTypeImpl<PsiClassType> implements JavaClassifierType { class JavaClassifierTypeImpl(psiClassType: PsiClassType) : JavaTypeImpl<PsiClassType>(psiClassType), JavaClassifierType {
private static class ResolutionResult {
private final JavaClassifierImpl<?> classifier;
private final PsiSubstitutor substitutor;
private final boolean isRaw;
private ResolutionResult(@Nullable JavaClassifierImpl<?> classifier, @NotNull PsiSubstitutor substitutor, boolean isRaw) { private var resolutionResult: ResolutionResult? = null
this.classifier = classifier;
this.substitutor = substitutor;
this.isRaw = isRaw;
}
}
private ResolutionResult resolutionResult; override val classifier: JavaClassifierImpl<*>?
get() = resolve().classifier
public JavaClassifierTypeImpl(@NotNull PsiClassType psiClassType) { val substitutor: PsiSubstitutor
super(psiClassType); get() = resolve().substitutor
}
@Override override val classifierQualifiedName: String
@Nullable get() = psi.canonicalText.convertCanonicalNameToQName()
public JavaClassifierImpl<?> getClassifier() {
resolve();
return resolutionResult.classifier;
}
@NotNull override val presentableText: String
public PsiSubstitutor getSubstitutor() { get() = psi.presentableText
resolve();
return resolutionResult.substitutor;
}
private void resolve() { override val isRaw: Boolean
if (resolutionResult == null) { get() = resolve().isRaw
PsiClassType.ClassResolveResult result = getPsi().resolveGenerics();
PsiClass psiClass = result.getElement();
PsiSubstitutor substitutor = result.getSubstitutor();
resolutionResult = new ResolutionResult(
psiClass == null ? null : JavaClassifierImpl.create(psiClass), substitutor, PsiClassType.isRaw(result)
);
}
}
@Override override// parameters including ones from outer class
@NotNull val typeArguments: List<JavaType?>
public String getClassifierQualifiedName() { get() {
return ClassNamesUtilKt.convertCanonicalNameToQName(getPsi().getCanonicalText()); val classifier = classifier as? JavaClassImpl ?: return emptyList()
} val parameters = getTypeParameters(classifier.psi)
@Override val substitutor = substitutor
@NotNull
public String getPresentableText() {
return getPsi().getPresentableText();
}
@Override val result = ArrayList<JavaType?>(parameters.size)
public boolean isRaw() { for (typeParameter in parameters) {
resolve(); val substitutedType = substitutor.substitute(typeParameter)
return resolutionResult.isRaw; result.add(substitutedType?.let { JavaTypeImpl.create(it) })
} }
@Override return result
@NotNull
public List<JavaType> getTypeArguments() {
JavaClassifierImpl<?> classifier = getClassifier();
if (!(classifier instanceof JavaClassImpl)) return Collections.emptyList();
// parameters including ones from outer class
List<PsiTypeParameter> parameters = getTypeParameters(classifier.getPsi());
PsiSubstitutor substitutor = getSubstitutor();
List<JavaType> result = new ArrayList<>(parameters.size());
for (PsiTypeParameter typeParameter : parameters) {
PsiType substitutedType = substitutor.substitute(typeParameter);
result.add(substitutedType == null ? null : JavaTypeImpl.create(substitutedType));
} }
return result; private class ResolutionResult(
val classifier: JavaClassifierImpl<*>?,
val substitutor: PsiSubstitutor,
val isRaw: Boolean
)
private fun resolve(): ResolutionResult {
return resolutionResult ?: run {
val result = psi.resolveGenerics()
val psiClass = result.element
val substitutor = result.substitutor
ResolutionResult(
psiClass?.let { JavaClassifierImpl.create(it) }, substitutor, PsiClassType.isRaw(result)
).apply {
resolutionResult = this
}
}
} }
// Copy-pasted from PsiUtil.typeParametersIterable // Copy-pasted from PsiUtil.typeParametersIterable
@@ -116,23 +86,20 @@ public class JavaClassifierTypeImpl extends JavaTypeImpl<PsiClassType> implement
// //
// PsiUtil.typeParametersIterable returns H3, H2, H1 // PsiUtil.typeParametersIterable returns H3, H2, H1
// But we would like to have H2, H3, H1 as such order is consistent with our type representation // But we would like to have H2, H3, H1 as such order is consistent with our type representation
@NotNull private fun getTypeParameters(owner: PsiClass): List<PsiTypeParameter> {
private static List<PsiTypeParameter> getTypeParameters(@NotNull PsiClass owner) { var result: List<PsiTypeParameter>? = null
List<PsiTypeParameter> result = null;
PsiTypeParameterListOwner currentOwner = owner; var currentOwner: PsiTypeParameterListOwner? = owner
while (currentOwner != null) { while (currentOwner != null) {
PsiTypeParameter[] typeParameters = currentOwner.getTypeParameters(); val typeParameters = currentOwner.typeParameters
if (typeParameters.length > 0) { if (typeParameters.isNotEmpty()) {
if (result == null) result = new ArrayList<>(typeParameters.length); result = result?.let { it + typeParameters } ?: typeParameters.toList()
Collections.addAll(result, typeParameters);
} }
if (currentOwner.hasModifierProperty(PsiModifier.STATIC)) break; if (currentOwner.hasModifierProperty(PsiModifier.STATIC)) break
currentOwner = currentOwner.getContainingClass(); currentOwner = currentOwner.containingClass
} }
if (result == null) return Collections.emptyList(); return result ?: emptyList()
return result;
} }
} }