diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaArrayTypeImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaArrayTypeImpl.java index 0cc059a6751..21f8ca2ad47 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaArrayTypeImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaArrayTypeImpl.java @@ -19,7 +19,6 @@ package org.jetbrains.kotlin.load.java.structure.impl; import com.intellij.psi.PsiArrayType; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.load.java.structure.JavaArrayType; -import org.jetbrains.kotlin.load.java.structure.JavaType; public class JavaArrayTypeImpl extends JavaTypeImpl implements JavaArrayType { public JavaArrayTypeImpl(@NotNull PsiArrayType psiArrayType) { @@ -28,7 +27,7 @@ public class JavaArrayTypeImpl extends JavaTypeImpl implements Jav @Override @NotNull - public JavaType getComponentType() { + public JavaTypeImpl getComponentType() { return JavaTypeImpl.create(getPsi().getComponentType()); } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassImpl.java index dbc96af65ad..29220f87a25 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassImpl.java @@ -78,7 +78,7 @@ public class JavaClassImpl extends JavaClassifierImpl implements JavaC @Override @Nullable - public JavaClass getOuterClass() { + public JavaClassImpl getOuterClass() { PsiClass outer = getPsi().getContainingClass(); return outer == null ? null : new JavaClassImpl(outer); } @@ -154,12 +154,6 @@ public class JavaClassImpl extends JavaClassifierImpl implements JavaC return JavaElementUtil.getVisibility(this); } - @Override - @NotNull - public JavaClassifierType getDefaultType() { - return new JavaClassifierTypeImpl(JavaPsiFacade.getElementFactory(getPsi().getProject()).createType(getPsi())); - } - @Override @NotNull public OriginKind getOriginKind() { @@ -176,25 +170,24 @@ public class JavaClassImpl extends JavaClassifierImpl implements JavaC } @NotNull - public JavaType createImmediateType(@NotNull JavaTypeSubstitutorImpl substitutor) { + /* package */ JavaTypeImpl createImmediateType(@NotNull Map> substitutionMap) { return new JavaClassifierTypeImpl( - JavaPsiFacade.getElementFactory(getPsi().getProject()).createType(getPsi(), createPsiSubstitutor(substitutor))); + JavaPsiFacade.getElementFactory(getPsi().getProject()).createType(getPsi(), createPsiSubstitutor(substitutionMap)) + ); } @NotNull - private static PsiSubstitutor createPsiSubstitutor(@NotNull JavaTypeSubstitutorImpl substitutor) { - Map substMap = new HashMap(); - for (Map.Entry entry : substitutor.getSubstitutionMap().entrySet()) { - PsiTypeParameter key = ((JavaTypeParameterImpl) entry.getKey()).getPsi(); - if (entry.getValue() == null) { - substMap.put(key, null); - } - else { - substMap.put(key, ((JavaTypeImpl) entry.getValue()).getPsi()); - } + private static PsiSubstitutor createPsiSubstitutor(@NotNull Map> substitutionMap) { + if (substitutionMap.isEmpty()) return PsiSubstitutor.EMPTY; + + Map result = new HashMap(); + for (Map.Entry> entry : substitutionMap.entrySet()) { + PsiTypeParameter key = entry.getKey().getPsi(); + JavaTypeImpl value = entry.getValue(); + result.put(key, value == null ? null : value.getPsi()); } - return PsiSubstitutorImpl.createSubstitutor(substMap); + return PsiSubstitutorImpl.createSubstitutor(result); } @Nullable diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierImpl.java index 39977543f42..fca259a6bec 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierImpl.java @@ -32,7 +32,7 @@ public abstract class JavaClassifierImpl extends JavaEleme } @NotNull - /* package */ static JavaClassifier create(@NotNull PsiClass psiClass) { + /* package */ static JavaClassifierImpl create(@NotNull PsiClass psiClass) { if (psiClass instanceof PsiTypeParameter) { return new JavaTypeParameterImpl((PsiTypeParameter) psiClass); } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java index 7f8255fa7f1..92fa4f62d79 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java @@ -19,20 +19,18 @@ package org.jetbrains.kotlin.load.java.structure.impl; import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.load.java.structure.JavaClassifier; import org.jetbrains.kotlin.load.java.structure.JavaClassifierType; import org.jetbrains.kotlin.load.java.structure.JavaType; -import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter; import java.util.*; public class JavaClassifierTypeImpl extends JavaTypeImpl implements JavaClassifierType { private static class ResolutionResult { - private final JavaClassifier classifier; + private final JavaClassifierImpl classifier; private final JavaTypeSubstitutorImpl substitutor; private final boolean isRaw; - private ResolutionResult(@Nullable JavaClassifier classifier, @NotNull JavaTypeSubstitutorImpl substitutor, boolean isRaw) { + private ResolutionResult(@Nullable JavaClassifierImpl classifier, @NotNull JavaTypeSubstitutorImpl substitutor, boolean isRaw) { this.classifier = classifier; this.substitutor = substitutor; this.isRaw = isRaw; @@ -47,7 +45,7 @@ public class JavaClassifierTypeImpl extends JavaTypeImpl implement @Override @Nullable - public JavaClassifier getClassifier() { + public JavaClassifierImpl getClassifier() { resolve(); return resolutionResult.classifier; } @@ -66,35 +64,21 @@ public class JavaClassifierTypeImpl extends JavaTypeImpl implement resolutionResult = new ResolutionResult( psiClass == null ? null : JavaClassifierImpl.create(psiClass), new JavaTypeSubstitutorImpl(convertSubstitutionMap(substitutor.getSubstitutionMap())), - PsiClassType.isRaw(result)); + PsiClassType.isRaw(result) + ); } } @NotNull - private static Map convertSubstitutionMap(@NotNull Map psiMap) { + private static Map> convertSubstitutionMap(@NotNull Map psiMap) { if (psiMap.isEmpty()) return Collections.emptyMap(); - Map substitutionMap = new HashMap(); + Map> result = new HashMap>(); for (Map.Entry entry : psiMap.entrySet()) { PsiType value = entry.getValue(); - substitutionMap.put(new JavaTypeParameterImpl(entry.getKey()), value == null ? null : JavaTypeImpl.create(value)); + result.put(new JavaTypeParameterImpl(entry.getKey()), value == null ? null : JavaTypeImpl.create(value)); } - return substitutionMap; - } - - @Override - @NotNull - public Collection getSupertypes() { - PsiType[] psiTypes = getPsi().getSuperTypes(); - if (psiTypes.length == 0) return Collections.emptyList(); - List result = new ArrayList(psiTypes.length); - for (PsiType psiType : psiTypes) { - if (!(psiType instanceof PsiClassType)) { - throw new IllegalStateException("Supertype should be a class: " + psiType + ", type: " + getPsi()); - } - result.add(new JavaClassifierTypeImpl((PsiClassType) psiType)); - } return result; } @@ -113,11 +97,11 @@ public class JavaClassifierTypeImpl extends JavaTypeImpl implement @Override @NotNull public List getTypeArguments() { - JavaClassifier classifier = getClassifier(); + JavaClassifierImpl classifier = getClassifier(); // parameters including ones from outer class Iterable parameters = classifier instanceof JavaClassImpl - ? getTypeParameters(((JavaClassImpl) classifier).getPsi()) + ? getTypeParameters(classifier.getPsi()) : Collections.emptyList(); JavaTypeSubstitutorImpl substitutor = getSubstitutor(); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeImpl.java index 153dae89544..23154d1cb96 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeImpl.java @@ -20,7 +20,6 @@ import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.load.java.structure.JavaAnnotation; -import org.jetbrains.kotlin.load.java.structure.JavaArrayType; import org.jetbrains.kotlin.load.java.structure.JavaType; import org.jetbrains.kotlin.name.FqName; @@ -79,12 +78,6 @@ public abstract class JavaTypeImpl implements JavaType, Jav }); } - @NotNull - @Override - public JavaArrayType createArrayType() { - return new JavaArrayTypeImpl(getPsi().createArrayType()); - } - @NotNull @Override public Collection getAnnotations() { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeParameterImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeParameterImpl.java index 9376ef44b98..69ca2cc6898 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeParameterImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeParameterImpl.java @@ -16,10 +16,12 @@ package org.jetbrains.kotlin.load.java.structure.impl; -import com.intellij.psi.*; +import com.intellij.psi.PsiAnnotationOwner; +import com.intellij.psi.PsiTypeParameter; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.load.java.structure.*; +import org.jetbrains.kotlin.load.java.structure.JavaClassifierType; +import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter; import org.jetbrains.kotlin.name.Name; import java.util.Collection; @@ -43,37 +45,6 @@ public class JavaTypeParameterImpl extends JavaClassifierImpl return classifierTypes(getPsi().getExtendsList().getReferencedTypes()); } - @Override - @Nullable - public JavaTypeParameterListOwner getOwner() { - PsiTypeParameterListOwner owner = getPsi().getOwner(); - // TODO: a separate factory for such things - if (owner instanceof PsiMethod) { - PsiMethod psiMethod = (PsiMethod) owner; - return psiMethod.isConstructor() ? new JavaConstructorImpl(psiMethod) : new JavaMethodImpl(psiMethod); - } - else if (owner instanceof PsiClass) { - return new JavaClassImpl((PsiClass) owner); - } - else if (owner != null) { - throw new UnsupportedOperationException("Unsupported type parameter list owner: " + owner); - } - - return null; - } - - @NotNull - @Override - public JavaType getType() { - return JavaTypeImpl.create(JavaPsiFacade.getInstance(getPsi().getProject()).getElementFactory().createType(getPsi())); - } - - @Override - @NotNull - public JavaTypeProvider getTypeProvider() { - return new JavaTypeProviderImpl(getPsi().getManager()); - } - @Nullable @Override public PsiAnnotationOwner getAnnotationOwnerPsi() { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeProviderImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeProviderImpl.java deleted file mode 100644 index 80bd9685e83..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeProviderImpl.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.load.java.structure.impl; - -import com.intellij.psi.PsiManager; -import com.intellij.psi.PsiType; -import com.intellij.psi.PsiWildcardType; -import com.intellij.psi.search.GlobalSearchScope; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.load.java.structure.JavaType; -import org.jetbrains.kotlin.load.java.structure.JavaTypeProvider; -import org.jetbrains.kotlin.load.java.structure.JavaWildcardType; - -public class JavaTypeProviderImpl implements JavaTypeProvider { - private final PsiManager manager; - - public JavaTypeProviderImpl(@NotNull PsiManager manager) { - this.manager = manager; - } - - @Override - @NotNull - public JavaType createJavaLangObjectType() { - return JavaTypeImpl.create(PsiType.getJavaLangObject(manager, GlobalSearchScope.allScope(manager.getProject()))); - } - - @NotNull - @Override - public JavaWildcardType createUpperBoundWildcard(@NotNull JavaType bound) { - return new JavaWildcardTypeImpl(PsiWildcardType.createExtends(manager, ((JavaTypeImpl) bound).getPsi())); - } - - @NotNull - @Override - public JavaWildcardType createLowerBoundWildcard(@NotNull JavaType bound) { - return new JavaWildcardTypeImpl(PsiWildcardType.createSuper(manager, ((JavaTypeImpl) bound).getPsi())); - } - - @NotNull - @Override - public JavaWildcardType createUnboundedWildcard() { - return new JavaWildcardTypeImpl(PsiWildcardType.createUnbounded(manager)); - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeSubstitutorImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeSubstitutorImpl.java index b365e059429..5d6a15db01e 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeSubstitutorImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeSubstitutorImpl.java @@ -16,9 +16,13 @@ package org.jetbrains.kotlin.load.java.structure.impl; +import com.intellij.psi.*; +import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.load.java.structure.*; +import org.jetbrains.kotlin.load.java.structure.JavaClassifier; +import org.jetbrains.kotlin.load.java.structure.JavaClassifierType; +import org.jetbrains.kotlin.load.java.structure.JavaPrimitiveType; import java.util.Collection; import java.util.HashMap; @@ -26,15 +30,15 @@ import java.util.List; import java.util.Map; public class JavaTypeSubstitutorImpl { - private final Map substitutionMap; + private final Map> substitutionMap; - public JavaTypeSubstitutorImpl(@NotNull Map substitutionMap) { + public JavaTypeSubstitutorImpl(@NotNull Map> substitutionMap) { this.substitutionMap = substitutionMap; } @NotNull - public JavaType substitute(@NotNull JavaType type) { - JavaType substitutedType = substituteInternal(type); + public JavaTypeImpl substitute(@NotNull JavaTypeImpl type) { + JavaTypeImpl substitutedType = substituteInternal(type); return substitutedType != null ? substitutedType : correctSubstitutionForRawType(type); } @@ -42,11 +46,11 @@ public class JavaTypeSubstitutorImpl { // In case of raw type we get substitution map like T -> null, // in this case we should substitute upper bound of T or, // if it does not exist, return java.lang.Object - private JavaType correctSubstitutionForRawType(@NotNull JavaType original) { + private JavaTypeImpl correctSubstitutionForRawType(@NotNull JavaTypeImpl original) { if (original instanceof JavaClassifierType) { JavaClassifier classifier = ((JavaClassifierType) original).getClassifier(); - if (classifier instanceof JavaTypeParameter) { - return rawTypeForTypeParameter((JavaTypeParameter) classifier); + if (classifier instanceof JavaTypeParameterImpl) { + return rawTypeForTypeParameter((JavaTypeParameterImpl) classifier); } } @@ -54,20 +58,20 @@ public class JavaTypeSubstitutorImpl { } @Nullable - private JavaType substituteInternal(@NotNull JavaType type) { - if (type instanceof JavaClassifierType) { - JavaClassifierType classifierType = (JavaClassifierType) type; - JavaClassifier classifier = classifierType.getClassifier(); + private JavaTypeImpl substituteInternal(@NotNull JavaTypeImpl type) { + if (type instanceof JavaClassifierTypeImpl) { + JavaClassifierTypeImpl classifierType = (JavaClassifierTypeImpl) type; + JavaClassifierImpl classifier = classifierType.getClassifier(); - if (classifier instanceof JavaTypeParameter) { - return substitute((JavaTypeParameter) classifier); + if (classifier instanceof JavaTypeParameterImpl) { + return substitute((JavaTypeParameterImpl) classifier); } else if (classifier instanceof JavaClassImpl) { JavaClassImpl javaClass = (JavaClassImpl) classifier; - Map substMap = new HashMap(); - processClass(javaClass, ((JavaClassifierTypeImpl) classifierType).getSubstitutor(), substMap); + Map> substMap = new HashMap>(); + processClass(javaClass, classifierType.getSubstitutor(), substMap); - return javaClass.createImmediateType(new JavaTypeSubstitutorImpl(substMap)); + return javaClass.createImmediateType(substMap); } return type; @@ -75,52 +79,50 @@ public class JavaTypeSubstitutorImpl { else if (type instanceof JavaPrimitiveType) { return type; } - else if (type instanceof JavaArrayType) { - JavaType componentType = ((JavaArrayType) type).getComponentType(); - JavaType substitutedComponentType = substitute(componentType); + else if (type instanceof JavaArrayTypeImpl) { + JavaTypeImpl componentType = ((JavaArrayTypeImpl) type).getComponentType(); + JavaTypeImpl substitutedComponentType = substitute(componentType); if (substitutedComponentType == componentType) return type; - return substitutedComponentType.createArrayType(); + return new JavaArrayTypeImpl(substitutedComponentType.getPsi().createArrayType()); } - else if (type instanceof JavaWildcardType) { - return substituteWildcardType((JavaWildcardType) type); + else if (type instanceof JavaWildcardTypeImpl) { + return substituteWildcardType((JavaWildcardTypeImpl) type); } return type; } private void processClass( - @NotNull JavaClass javaClass, @NotNull JavaTypeSubstitutorImpl substitutor, @NotNull Map substMap + @NotNull JavaClassImpl javaClass, + @NotNull JavaTypeSubstitutorImpl substitutor, + @NotNull Map> substMap ) { - List typeParameters = javaClass.getTypeParameters(); - for (JavaTypeParameter typeParameter : typeParameters) { - JavaType substitutedParam = substitutor.substitute(typeParameter); - if (substitutedParam == null) { - substMap.put(typeParameter, null); - } - else { - substMap.put(typeParameter, substituteInternal(substitutedParam)); - } + @SuppressWarnings("unchecked") + List typeParameters = (List) javaClass.getTypeParameters(); + for (JavaTypeParameterImpl typeParameter : typeParameters) { + JavaTypeImpl substitutedParam = substitutor.substitute(typeParameter); + substMap.put(typeParameter, substitutedParam == null ? null : substituteInternal(substitutedParam)); } if (javaClass.isStatic()) { return; } - JavaClass outerClass = javaClass.getOuterClass(); + JavaClassImpl outerClass = javaClass.getOuterClass(); if (outerClass != null) { processClass(outerClass, substitutor, substMap); } } @Nullable - private JavaType substituteWildcardType(@NotNull JavaWildcardType wildcardType) { - JavaType bound = wildcardType.getBound(); + private JavaTypeImpl substituteWildcardType(@NotNull JavaWildcardTypeImpl wildcardType) { + JavaTypeImpl bound = wildcardType.getBound(); if (bound == null) { return wildcardType; } - JavaType newBound = substituteInternal(bound); + JavaTypeImpl newBound = substituteInternal(bound); if (newBound == null) { // This can be in case of substitution wildcard to raw type return null; @@ -130,41 +132,40 @@ public class JavaTypeSubstitutorImpl { } @NotNull - private static JavaWildcardType rebound(@NotNull JavaWildcardType type, @NotNull JavaType newBound) { - if (type.getTypeProvider().createJavaLangObjectType().equals(newBound)) { - return type.getTypeProvider().createUnboundedWildcard(); + private static JavaWildcardTypeImpl rebound(@NotNull JavaWildcardTypeImpl type, @NotNull JavaTypeImpl newBound) { + PsiManager manager = type.getPsi().getManager(); + if (createJavaLangObjectType(manager).equals(newBound)) { + return createUnboundedWildcard(manager); } if (type.isExtends()) { - return type.getTypeProvider().createUpperBoundWildcard(newBound); + return createUpperBoundWildcard(manager, newBound); } else { - return type.getTypeProvider().createLowerBoundWildcard(newBound); + return createLowerBoundWildcard(manager, newBound); } } @NotNull - private JavaType rawTypeForTypeParameter(@NotNull JavaTypeParameter typeParameter) { + private JavaTypeImpl rawTypeForTypeParameter(@NotNull JavaTypeParameterImpl typeParameter) { Collection bounds = typeParameter.getUpperBounds(); if (!bounds.isEmpty()) { - return substitute(bounds.iterator().next()); + return substitute(((JavaClassifierTypeImpl) bounds.iterator().next())); } - return typeParameter.getTypeProvider().createJavaLangObjectType(); + return createJavaLangObjectType(typeParameter.getPsi().getManager()); } @Nullable - public JavaType substitute(@NotNull JavaTypeParameter typeParameter) { + public JavaTypeImpl substitute(@NotNull JavaTypeParameterImpl typeParameter) { if (substitutionMap.containsKey(typeParameter)) { return substitutionMap.get(typeParameter); } - return typeParameter.getType(); - } - - @NotNull - public Map getSubstitutionMap() { - return substitutionMap; + PsiTypeParameter psiTypeParameter = typeParameter.getPsi(); + return JavaTypeImpl.create( + JavaPsiFacade.getInstance(psiTypeParameter.getProject()).getElementFactory().createType(psiTypeParameter) + ); } @Override @@ -181,4 +182,24 @@ public class JavaTypeSubstitutorImpl { public String toString() { return getClass().getSimpleName() + ": " + substitutionMap; } + + @NotNull + private static JavaTypeImpl createJavaLangObjectType(@NotNull PsiManager manager) { + return JavaTypeImpl.create(PsiType.getJavaLangObject(manager, GlobalSearchScope.allScope(manager.getProject()))); + } + + @NotNull + private static JavaWildcardTypeImpl createUpperBoundWildcard(@NotNull PsiManager manager, @NotNull JavaTypeImpl bound) { + return new JavaWildcardTypeImpl(PsiWildcardType.createExtends(manager, bound.getPsi())); + } + + @NotNull + private static JavaWildcardTypeImpl createLowerBoundWildcard(@NotNull PsiManager manager, @NotNull JavaTypeImpl bound) { + return new JavaWildcardTypeImpl(PsiWildcardType.createSuper(manager, bound.getPsi())); + } + + @NotNull + private static JavaWildcardTypeImpl createUnboundedWildcard(@NotNull PsiManager manager) { + return new JavaWildcardTypeImpl(PsiWildcardType.createUnbounded(manager)); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaWildcardTypeImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaWildcardTypeImpl.java index 2436cb94a6d..cff5e607aaa 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaWildcardTypeImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaWildcardTypeImpl.java @@ -20,8 +20,6 @@ import com.intellij.psi.PsiType; import com.intellij.psi.PsiWildcardType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.load.java.structure.JavaType; -import org.jetbrains.kotlin.load.java.structure.JavaTypeProvider; import org.jetbrains.kotlin.load.java.structure.JavaWildcardType; public class JavaWildcardTypeImpl extends JavaTypeImpl implements JavaWildcardType { @@ -31,7 +29,7 @@ public class JavaWildcardTypeImpl extends JavaTypeImpl implemen @Override @Nullable - public JavaType getBound() { + public JavaTypeImpl getBound() { PsiType bound = getPsi().getBound(); return bound == null ? null : create(bound); } @@ -40,10 +38,4 @@ public class JavaWildcardTypeImpl extends JavaTypeImpl implemen public boolean isExtends() { return getPsi().isExtends(); } - - @Override - @NotNull - public JavaTypeProvider getTypeProvider() { - return new JavaTypeProviderImpl(getPsi().getManager()); - } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClass.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClass.java index c56ca54176e..2de1f0d546b 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClass.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClass.java @@ -50,9 +50,6 @@ public interface JavaClass extends JavaClassifier, JavaTypeParameterListOwner, J @NotNull Collection getConstructors(); - @NotNull - JavaClassifierType getDefaultType(); - @NotNull OriginKind getOriginKind(); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java index a5c9a613d66..391cd77dc38 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java @@ -20,17 +20,12 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.ReadOnly; -import java.util.Collection; import java.util.List; public interface JavaClassifierType extends JavaType, JavaAnnotationOwner { @Nullable JavaClassifier getClassifier(); - @NotNull - @ReadOnly - Collection getSupertypes(); - @NotNull String getPresentableText(); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaType.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaType.java index 1cb6db7dc66..af9d3821175 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaType.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaType.java @@ -16,9 +16,5 @@ package org.jetbrains.kotlin.load.java.structure; -import org.jetbrains.annotations.NotNull; - public interface JavaType { - @NotNull - JavaArrayType createArrayType(); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameter.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameter.java index 17764d3f98a..bc1b8796b71 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameter.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameter.java @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.load.java.structure; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.ReadOnly; import java.util.Collection; @@ -26,13 +25,4 @@ public interface JavaTypeParameter extends JavaClassifier { @NotNull @ReadOnly Collection getUpperBounds(); - - @Nullable - JavaTypeParameterListOwner getOwner(); - - @NotNull - JavaType getType(); - - @NotNull - JavaTypeProvider getTypeProvider(); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeProvider.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeProvider.java deleted file mode 100644 index 5cc105fe626..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeProvider.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.load.java.structure; - -import org.jetbrains.annotations.NotNull; - -public interface JavaTypeProvider { - @NotNull - JavaType createJavaLangObjectType(); - - @NotNull - JavaWildcardType createUpperBoundWildcard(@NotNull JavaType bound); - - @NotNull - JavaWildcardType createLowerBoundWildcard(@NotNull JavaType bound); - - @NotNull - JavaWildcardType createUnboundedWildcard(); -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaWildcardType.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaWildcardType.java index ff9752502d7..6aabb2ec314 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaWildcardType.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaWildcardType.java @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.load.java.structure; -import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; public interface JavaWildcardType extends JavaType { @@ -24,7 +23,4 @@ public interface JavaWildcardType extends JavaType { JavaType getBound(); boolean isExtends(); - - @NotNull - JavaTypeProvider getTypeProvider(); } diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt index 14cab082c9d..01fd9a9366c 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt @@ -81,8 +81,6 @@ class ReflectJavaClass( .map(::ReflectJavaConstructor) .toList() - override fun getDefaultType(): ReflectJavaClassifierType = throw UnsupportedOperationException() - // TODO: drop OriginKind override fun getOriginKind() = JavaClass.OriginKind.COMPILED diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt index 1c9d29b618d..d0b9ac0bbe8 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt @@ -39,8 +39,6 @@ class ReflectJavaClassifierType(public override val type: Type) : ReflectJavaTyp override fun getClassifier(): JavaClassifier = classifier - override fun getSupertypes(): Collection = throw UnsupportedOperationException() - override fun getPresentableText(): String = type.toString() override fun isRaw(): Boolean = with(type) { this is Class<*> && getTypeParameters().isNotEmpty() } diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt index dc7292b6e43..8afcca8e67a 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.load.java.structure.reflect -import org.jetbrains.kotlin.load.java.structure.JavaArrayType import org.jetbrains.kotlin.load.java.structure.JavaType import java.lang.reflect.GenericArrayType import java.lang.reflect.Type @@ -25,8 +24,6 @@ import java.lang.reflect.WildcardType abstract class ReflectJavaType : JavaType { protected abstract val type: Type - override fun createArrayType(): JavaArrayType = throw UnsupportedOperationException() - companion object Factory { fun create(type: Type): ReflectJavaType { return when { diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt index 71dca7f153d..f6dcd48e8a8 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt @@ -16,11 +16,9 @@ package org.jetbrains.kotlin.load.java.structure.reflect -import org.jetbrains.kotlin.load.java.structure.* +import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter import org.jetbrains.kotlin.name.Name import java.lang.reflect.AnnotatedElement -import java.lang.reflect.Constructor -import java.lang.reflect.Method import java.lang.reflect.TypeVariable class ReflectJavaTypeParameter( @@ -36,20 +34,6 @@ class ReflectJavaTypeParameter( // TypeVariable is AnnotatedElement only in JDK8 get() = typeVariable as? AnnotatedElement - override fun getOwner(): JavaTypeParameterListOwner? { - val owner = typeVariable.genericDeclaration - return when (owner) { - is Class<*> -> ReflectJavaClass(owner) - is Method -> ReflectJavaMethod(owner) - is Constructor<*> -> ReflectJavaConstructor(owner) - else -> throw UnsupportedOperationException("Unsupported type parameter list owner (${owner.javaClass}): $owner") - } - } - - override fun getType(): JavaType = throw UnsupportedOperationException() - - override fun getTypeProvider(): JavaTypeProvider = throw UnsupportedOperationException() - override fun getName() = Name.identifier(typeVariable.name) override fun equals(other: Any?) = other is ReflectJavaTypeParameter && typeVariable == other.typeVariable diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaWildcardType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaWildcardType.kt index e132d05f85b..3bf2360e9b9 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaWildcardType.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaWildcardType.kt @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.load.java.structure.reflect -import org.jetbrains.kotlin.load.java.structure.JavaTypeProvider import org.jetbrains.kotlin.load.java.structure.JavaWildcardType import java.lang.reflect.WildcardType @@ -35,6 +34,4 @@ class ReflectJavaWildcardType(override val type: WildcardType): ReflectJavaType( } override fun isExtends() = type.upperBounds.firstOrNull() != Any::class.java - - override fun getTypeProvider(): JavaTypeProvider = throw UnsupportedOperationException() } diff --git a/idea/tests/org/jetbrains/kotlin/load/java/AbstractJavaTypeSubstitutorTest.java b/idea/tests/org/jetbrains/kotlin/load/java/AbstractJavaTypeSubstitutorTest.java index 61772d8b05b..1574ca798b6 100644 --- a/idea/tests/org/jetbrains/kotlin/load/java/AbstractJavaTypeSubstitutorTest.java +++ b/idea/tests/org/jetbrains/kotlin/load/java/AbstractJavaTypeSubstitutorTest.java @@ -24,7 +24,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase; import org.jetbrains.kotlin.idea.test.KotlinLightProjectDescriptor; import org.jetbrains.kotlin.load.java.structure.JavaType; -import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter; import org.jetbrains.kotlin.load.java.structure.impl.JavaClassifierTypeImpl; import org.jetbrains.kotlin.load.java.structure.impl.JavaTypeImpl; import org.jetbrains.kotlin.load.java.structure.impl.JavaTypeParameterImpl; @@ -69,7 +68,7 @@ public abstract class AbstractJavaTypeSubstitutorTest extends KotlinLightCodeIns PsiType expectedType = type.resolveGenerics().getSubstitutor().substitute(typeParameter); JavaClassifierTypeImpl javaClassifierType = (JavaClassifierTypeImpl) JavaTypeImpl.create(type); - JavaTypeParameter javaTypeToSubstitute = new JavaTypeParameterImpl(typeParameter); + JavaTypeParameterImpl javaTypeToSubstitute = new JavaTypeParameterImpl(typeParameter); JavaType actualType = javaClassifierType.getSubstitutor().substitute(javaTypeToSubstitute); if (actualType == null) { @@ -84,7 +83,7 @@ public abstract class AbstractJavaTypeSubstitutorTest extends KotlinLightCodeIns PsiType expectedType = type.resolveGenerics().getSubstitutor().substitute(psiTypeToSubstitute); JavaClassifierTypeImpl javaClassifierType = (JavaClassifierTypeImpl) JavaTypeImpl.create(type); - JavaType javaTypeToSubstitute = JavaTypeImpl.create(psiTypeToSubstitute); + JavaTypeImpl javaTypeToSubstitute = JavaTypeImpl.create(psiTypeToSubstitute); JavaType actualType = javaClassifierType.getSubstitutor().substitute(javaTypeToSubstitute); if (expectedType instanceof PsiEllipsisType) {