diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java
index 2c52818f70c..b68574974c6 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java
@@ -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);
             }
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java
index aedfd65174b..1985bdb49e1 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java
@@ -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;
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java
index aefcb56a71e..2ae8c09b815 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java
@@ -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) {
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java
index 6b4c71c6b6a..d4d419e7736 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java
@@ -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;
                 }
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java
index 8b97125f72f..66dd1a66c9c 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java
@@ -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());
     }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassType.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassifierType.java
similarity index 83%
rename from compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassType.java
rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassifierType.java
index ba9f4f9c028..dfb432eeedb 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassType.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassifierType.java
@@ -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;
     }
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java
index f0378fc0b0d..8afaed39419 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaElementCollectionFromPsiArrayUtil.java
@@ -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;
     }
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaType.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaType.java
index e5da84599f8..7462905417d 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaType.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaType.java
@@ -56,7 +56,7 @@ public abstract class JavaType {
             @Nullable
             @Override
             public JavaType visitClassType(PsiClassType classType) {
-                return new JavaClassType(classType);
+                return new JavaClassifierType(classType);
             }
 
             @Nullable
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaTypeParameter.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaTypeParameter.java
index b1fea7354ea..5a95457664a 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaTypeParameter.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaTypeParameter.java
@@ -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