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

Rename JavaClassType to JavaClassifierType

Browse Source
This commit is contained in:
Alexander Udalov
2013-07-31 18:22:06 +04:00
parent c1d40f1e15
commit 732378d837
9 changed files with 43 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java
+3 -3
View File
@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
import org.jetbrains.jet.lang.resolve.java.TypeUsage;
import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod;
import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter;
import org.jetbrains.jet.lang.types.JetType;
@@ -99,12 +99,12 @@ public final class JavaSignatureResolver {
TypeVariableResolver typeVariableByPsiResolver
) {
TypeParameterDescriptorImpl typeParameterDescriptor = typeParameter.descriptor;
Collection<JavaClassType> upperBounds = typeParameter.javaTypeParameter.getUpperBounds();
Collection<JavaClassifierType> upperBounds = typeParameter.javaTypeParameter.getUpperBounds();
if (upperBounds.isEmpty()) {
typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
}
else {
for (JavaClassType upperBound : upperBounds) {
for (JavaClassifierType upperBound : upperBounds) {
JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver);
typeParameterDescriptor.addUpperBound(transformedType);
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java
+3 -3
View File
@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.java.TypeUsage;
import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifier;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.types.ErrorUtils;
@@ -112,11 +112,11 @@ public final class JavaSupertypeResolver {
@NotNull
private List<JetType> transformSupertypeList(
@NotNull Collection<JavaClassType> supertypes,
@NotNull Collection<JavaClassifierType> supertypes,
@NotNull TypeVariableResolver typeVariableResolver
) {
List<JetType> result = new ArrayList<JetType>(supertypes.size());
for (JavaClassType type : supertypes) {
for (JavaClassifierType type : supertypes) {
JavaClassifier resolved = type.resolve();
if (resolved != null) {
assert resolved instanceof JavaClass : "Supertype should be a class: " + resolved;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java
+15 -15
View File
@@ -90,11 +90,11 @@ public class JavaTypeTransformer {
@NotNull TypeUsage howThisTypeIsUsed,
@NotNull TypeVariableResolver typeVariableResolver
) {
if (type instanceof JavaClassType) {
JavaClassType classType = (JavaClassType) type;
JetType jetType = transformClassType(classType, howThisTypeIsUsed, typeVariableResolver);
if (type instanceof JavaClassifierType) {
JavaClassifierType classifierType = (JavaClassifierType) type;
JetType jetType = transformClassifierType(classifierType, howThisTypeIsUsed, typeVariableResolver);
if (jetType == null) {
return ErrorUtils.createErrorType("Unresolved java class: " + classType.getPresentableText());
return ErrorUtils.createErrorType("Unresolved java class: " + classifierType.getPresentableText());
}
return jetType;
}
@@ -113,12 +113,12 @@ public class JavaTypeTransformer {
}
@Nullable
private JetType transformClassType(
@NotNull JavaClassType classType,
private JetType transformClassifierType(
@NotNull JavaClassifierType classifierType,
@NotNull TypeUsage howThisTypeIsUsed,
@NotNull TypeVariableResolver typeVariableResolver
) {
JavaClassifier javaClassifier = classType.resolve();
JavaClassifier javaClassifier = classifierType.resolve();
if (javaClassifier == null) {
return null;
}
@@ -128,7 +128,7 @@ public class JavaTypeTransformer {
else if (javaClassifier instanceof JavaClass) {
FqName fqName = ((JavaClass) javaClassifier).getFqName();
assert fqName != null : "Class type should have a FQ name: " + javaClassifier;
return transformClassType(fqName, classType, howThisTypeIsUsed, typeVariableResolver);
return transformClassType(fqName, classifierType, howThisTypeIsUsed, typeVariableResolver);
}
else {
throw new UnsupportedOperationException("Unsupported classifier: " + javaClassifier);
@@ -144,7 +144,7 @@ public class JavaTypeTransformer {
JavaTypeParameterListOwner owner = typeParameter.getOwner();
if (owner instanceof JavaMethod && ((JavaMethod) owner).isConstructor()) {
Set<JetType> supertypesJet = Sets.newHashSet();
for (JavaClassType supertype : typeParameter.getUpperBounds()) {
for (JavaClassifierType supertype : typeParameter.getUpperBounds()) {
supertypesJet.add(transformToType(supertype, UPPER_BOUND, typeVariableResolver));
}
return TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet);
@@ -163,7 +163,7 @@ public class JavaTypeTransformer {
@Nullable
private JetType transformClassType(
@NotNull FqName fqName,
@NotNull JavaClassType classType,
@NotNull JavaClassifierType classifierType,
@NotNull TypeUsage howThisTypeIsUsed,
@NotNull TypeVariableResolver typeVariableResolver
) {
@@ -181,7 +181,7 @@ public class JavaTypeTransformer {
List<TypeProjection> arguments = Lists.newArrayList();
List<TypeParameterDescriptor> parameters = classData.getTypeConstructor().getParameters();
if (isRaw(classType, !parameters.isEmpty())) {
if (isRaw(classifierType, !parameters.isEmpty())) {
for (TypeParameterDescriptor parameter : parameters) {
// not making a star projection because of this case:
// Java:
@@ -198,12 +198,12 @@ public class JavaTypeTransformer {
}
}
else {
PsiType[] psiArguments = classType.getPsi().getParameters();
PsiType[] psiArguments = classifierType.getPsi().getParameters();
if (parameters.size() != psiArguments.length) {
// Most of the time this means there is an error in the Java code
LOG.warn("parameters = " + parameters.size() + ", actual arguments = " + psiArguments.length +
" in " + classType.getPresentableText() + "\n fqName: \n" + fqName);
" in " + classifierType.getPresentableText() + "\n fqName: \n" + fqName);
for (TypeParameterDescriptor parameter : parameters) {
arguments.add(new TypeProjection(ErrorUtils.createErrorType(parameter.getName().asString())));
@@ -280,11 +280,11 @@ public class JavaTypeTransformer {
return transformArrayType(type, howThisTypeIsUsed, typeVariableResolver, true);
}
private static boolean isRaw(@NotNull JavaClassType classType, boolean argumentsExpected) {
private static boolean isRaw(@NotNull JavaClassifierType classifierType, boolean argumentsExpected) {
// The second option is needed because sometimes we get weird versions of JDK classes in the class path,
// such as collections with no generics, so the Java types are not raw, formally, but they don't match with
// their Kotlin analogs, so we treat them as raw to avoid exceptions
return classType.getPsi().isRaw() || argumentsExpected && classType.getPsi().getParameterCount() == 0;
return classifierType.getPsi().isRaw() || argumentsExpected && classifierType.getPsi().getParameterCount() == 0;
}
public static TypeUsage adjustTypeUsageWithMutabilityAnnotations(PsiModifierListOwner owner, TypeUsage originalTypeUsage) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java
+7 -7
View File
@@ -33,8 +33,8 @@ import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifier;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -341,10 +341,10 @@ public class SingleAbstractMethodUtils {
@Nullable
private static JavaMethod findOnlyAbstractMethod(@NotNull JavaClass javaClass, @NotNull Project project) {
JavaClassType classType = new JavaClassType(JavaPsiFacade.getElementFactory(project).createType(javaClass.getPsi()));
JavaClassifierType classifierType = new JavaClassifierType(JavaPsiFacade.getElementFactory(project).createType(javaClass.getPsi()));
OnlyAbstractMethodFinder finder = new OnlyAbstractMethodFinder();
if (finder.find(classType)) {
if (finder.find(classifierType)) {
return finder.getFoundMethod();
}
return null;
@@ -376,10 +376,10 @@ public class SingleAbstractMethodUtils {
private static class OnlyAbstractMethodFinder {
private MethodSignatureBackedByPsiMethod found;
private boolean find(@NotNull JavaClassType classType) {
PsiClassType.ClassResolveResult classResolveResult = classType.getPsi().resolveGenerics();
private boolean find(@NotNull JavaClassifierType classifierType) {
PsiClassType.ClassResolveResult classResolveResult = classifierType.getPsi().resolveGenerics();
PsiSubstitutor classSubstitutor = classResolveResult.getSubstitutor();
JavaClassifier javaClassifier = classType.resolve();
JavaClassifier javaClassifier = classifierType.resolve();
if (javaClassifier == null) {
return false; // can't resolve class -> not a SAM interface
}
@@ -410,7 +410,7 @@ public class SingleAbstractMethodUtils {
}
}
for (JavaClassType t : classType.getSupertypes()) {
for (JavaClassifierType t : classifierType.getSupertypes()) {
if (!find(t)) {
return false;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java
+3 -3
View File
@@ -108,10 +108,10 @@ public class JavaClass extends JavaClassifier implements JavaNamedElement, JavaT
@SuppressWarnings("unchecked")
@NotNull
public Collection<JavaClassType> getSupertypes() {
public Collection<JavaClassifierType> getSupertypes() {
// TODO: getPsi().getSuperTypes() ?
Collection<JavaClassType> superClasses = classTypes(getPsi().getExtendsListTypes());
Collection<JavaClassType> superInterfaces = classTypes(getPsi().getImplementsListTypes());
Collection<JavaClassifierType> superClasses = classifierTypes(getPsi().getExtendsListTypes());
Collection<JavaClassifierType> superInterfaces = classifierTypes(getPsi().getImplementsListTypes());
return ContainerUtil.collect(ContainerUtil.concat(superClasses, superInterfaces).iterator());
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassType.java → compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassifierType.java
+5 -5
View File
@@ -27,8 +27,8 @@ import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class JavaClassType extends JavaType {
public JavaClassType(@NotNull PsiClassType psiClassType) {
public class JavaClassifierType extends JavaType {
public JavaClassifierType(@NotNull PsiClassType psiClassType) {
super(psiClassType);
}
@@ -45,15 +45,15 @@ public class JavaClassType extends JavaType {
}
@NotNull
public Collection<JavaClassType> getSupertypes() {
public Collection<JavaClassifierType> getSupertypes() {
PsiType[] psiTypes = getPsi().getSuperTypes();
if (psiTypes.length == 0) return Collections.emptyList();
List<JavaClassType> result = new ArrayList<JavaClassType>(psiTypes.length);
List<JavaClassifierType> result = new ArrayList<JavaClassifierType>(psiTypes.length);
for (PsiType psiType : psiTypes) {
if (!(psiType instanceof PsiClassType)) {
throw new IllegalStateException("Supertype should be a class: " + psiType + ", type: " + getPsi());
}
result.add(new JavaClassType((PsiClassType) psiType));
result.add(new JavaClassifierType((PsiClassType) psiType));
}
return result;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java
+3 -3
View File
@@ -89,11 +89,11 @@ import java.util.List;
}
@NotNull
public static Collection<JavaClassType> classTypes(@NotNull PsiClassType[] classTypes) {
public static Collection<JavaClassifierType> classifierTypes(@NotNull PsiClassType[] classTypes) {
if (classTypes.length == 0) return Collections.emptyList();
List<JavaClassType> result = new ArrayList<JavaClassType>(classTypes.length);
List<JavaClassifierType> result = new ArrayList<JavaClassifierType>(classTypes.length);
for (PsiClassType psiClassType : classTypes) {
result.add(new JavaClassType(psiClassType));
result.add(new JavaClassifierType(psiClassType));
}
return result;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaType.java
+1 -1
View File
@@ -56,7 +56,7 @@ public abstract class JavaType {
@Nullable
@Override
public JavaType visitClassType(PsiClassType classType) {
return new JavaClassType(classType);
return new JavaClassifierType(classType);
}
@Nullable
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaTypeParameter.java
+3 -3
View File
@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
import java.util.Collection;
import static org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil.classTypes;
import static org.jetbrains.jet.lang.resolve.java.structure.JavaElementCollectionFromPsiArrayUtil.classifierTypes;
public class JavaTypeParameter extends JavaClassifier implements JavaNamedElement {
public JavaTypeParameter(@NotNull PsiTypeParameter psiTypeParameter) {
@@ -50,8 +50,8 @@ public class JavaTypeParameter extends JavaClassifier implements JavaNamedElemen
}
@NotNull
public Collection<JavaClassType> getUpperBounds() {
return classTypes(getPsi().getExtendsList().getReferencedTypes());
public Collection<JavaClassifierType> getUpperBounds() {
return classifierTypes(getPsi().getExtendsList().getReferencedTypes());
}
@Nullable