Drop DependencyClassByQualifiedNameResolver and implementation

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -24,11 +24,9 @@ import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
-import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 
-public class JavaDescriptorResolver implements DependencyClassByQualifiedNameResolver {
+public class JavaDescriptorResolver {
     public static final Name JAVA_ROOT = Name.special("<java_root>");
 
     private final ModuleDescriptor module;
@@ -50,12 +48,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         return lazyJavaPackageFragmentProvider;
     }
 
-    @Nullable
-    @Override
-    public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) {
-        return lazyJavaPackageFragmentProvider.getClass(qualifiedName);
-    }
-
     @Nullable
     public ClassDescriptor resolveClass(@NotNull JavaClass javaClass) {
         return lazyJavaPackageFragmentProvider.getClass(javaClass);

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -104,22 +104,6 @@ public class LazyJavaPackageFragmentProvider(
 
     fun getClass(javaClass: JavaClass): ClassDescriptor? = c.javaClassResolver.resolveClass(javaClass)
 
-    fun getClass(fqName: FqName): ClassDescriptor? {
-        val builtinClass = DescriptorResolverUtils.getKotlinBuiltinClassDescriptor(fqName)
-        if (builtinClass != null) return builtinClass
-
-        // TODO Here we prefer sources (something outside JDR subsystem) to binaries, which should actually be driven by module dependencies separation
-        // See DeserializedDescriptorResolver.javaDescriptorFinder
-        val classFromSources = c.javaResolverCache.getClassResolvedFromSource(fqName)
-        if (classFromSources != null) return classFromSources
-
-        val (jClass, kClass) = c.findClassInJava(fqName)
-        if (jClass != null) return c.javaClassResolver.resolveClass(jClass)
-        if (kClass != null) return kClass
-
-        return null
-    }
-
     private inner class FragmentClassResolver : LazyJavaClassResolver {
         override fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
             // TODO: there's no notion of module separation here. We must refuse to resolve classes from other modules

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt

@@ -16,14 +16,12 @@
 
 package org.jetbrains.jet.lang.resolve.kotlin
 
-import org.jetbrains.annotations.Nullable
 import org.jetbrains.jet.descriptors.serialization.ClassId
 import org.jetbrains.jet.descriptors.serialization.DescriptorFinder
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider
 import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName
 import java.util.Collections
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver