Make JavaClassFinder accept ClassId rather than FqName

ClassId has more information about the name which will be very useful when
implementing JavaClassFinder in reflection

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java

@@ -24,20 +24,20 @@ import com.intellij.psi.search.DelegatingGlobalSearchScope;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.descriptors.serialization.ClassId;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaClassImpl;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPackageImpl;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.plugin.JetFileType;
 
 import javax.annotation.PostConstruct;
 import javax.inject.Inject;
 
 public class JavaClassFinderImpl implements JavaClassFinder {
-    @NotNull
     private Project project;
-    @NotNull
     private GlobalSearchScope baseScope;
 
     private GlobalSearchScope javaSearchScope;
@@ -57,7 +57,7 @@ public class JavaClassFinderImpl implements JavaClassFinder {
     public void initialize() {
         javaSearchScope = new DelegatingGlobalSearchScope(baseScope) {
             @Override
-            public boolean contains(VirtualFile file) {
+            public boolean contains(@NotNull VirtualFile file) {
                 return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE;
             }
 
@@ -73,13 +73,15 @@ public class JavaClassFinderImpl implements JavaClassFinder {
 
     @Nullable
     @Override
-    public JavaClass findClass(@NotNull FqName fqName) {
+    public JavaClass findClass(@NotNull ClassId classId) {
+        FqNameUnsafe fqName = classId.asSingleFqName();
+
         PsiClass psiClass = javaFacade.findClass(fqName.asString(), javaSearchScope);
         if (psiClass == null) return null;
 
         JavaClassImpl javaClass = new JavaClassImpl(psiClass);
 
-        if (!fqName.equals(javaClass.getFqName())) {
+        if (!fqName.equalsTo(javaClass.getFqName())) {
             throw new IllegalStateException("Requested " + fqName + ", got " + javaClass.getFqName());
         }
 

compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java

@@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.descriptors.serialization.ClassId;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
 import org.jetbrains.jet.di.InjectorForTests;
@@ -116,7 +117,7 @@ public class JetExpectedResolveDataUtil {
     @NotNull
     private static PsiClass findClass(String qualifiedName, Project project) {
         InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext(), false);
-        JavaClass javaClass = injector.getJavaClassFinder().findClass(new FqName(qualifiedName));
+        JavaClass javaClass = injector.getJavaClassFinder().findClass(ClassId.topLevel(new FqName(qualifiedName)));
         Assert.assertNotNull("Class wasn't found: " + qualifiedName, javaClass);
         assertInstanceOf(javaClass, JavaClassImpl.class);
         return ((JavaClassImpl) javaClass).getPsi();

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

@@ -18,13 +18,14 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.descriptors.serialization.ClassId;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 public interface JavaClassFinder {
     @Nullable
-    JavaClass findClass(@NotNull FqName fqName);
+    JavaClass findClass(@NotNull ClassId classId);
 
     @Nullable
     JavaPackage findPackage(@NotNull FqName fqName);

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

@@ -18,12 +18,11 @@ package org.jetbrains.jet.lang.resolve.java.lazy.descriptors
 
 import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
-import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.resolve.name.*
 import java.util.Collections
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.resolve.java.lazy.withTypes
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage
-import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.jet.lang.resolve.java.lazy.findClassInJava
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
@@ -33,9 +32,9 @@ import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
 import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaMemberScope.MethodSignatureData
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor
-import org.jetbrains.jet.lang.resolve.name.SpecialNames
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.jet.lang.resolve.DescriptorFactory.*
+import org.jetbrains.jet.descriptors.serialization.ClassId
 
 public abstract class LazyJavaStaticScope(
         c: LazyJavaResolverContext,
@@ -94,8 +93,8 @@ public class LazyPackageFragmentScopeForJavaPackage(
 
     private val classes = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
         name ->
-        val fqName = packageFragment.fqName.child(SpecialNames.safeIdentifier(name))
+        val classId = ClassId(packageFragment.fqName, FqNameUnsafe.topLevel(SpecialNames.safeIdentifier(name)))
-        val (jClass, kClass) = c.findClassInJava(fqName)
+        val (jClass, kClass) = c.findClassInJava(classId)
         if (kClass != null)
             kClass
         else if (jClass == null)

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

@@ -22,9 +22,9 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
 import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter
 import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaTypeParameterDescriptor
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
-import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
+import org.jetbrains.jet.descriptors.serialization.ClassId
 
 //TODO: (module refactoring) usages of this interface should be replaced by ModuleClassResolver
 trait LazyJavaClassResolver {
@@ -70,12 +70,12 @@ fun LazyJavaResolverContext.lookupBinaryClass(javaClass: JavaClass): ClassDescri
     return resolveBinaryClass(kotlinJvmBinaryClass)?.kClass
 }
 
-fun LazyJavaResolverContext.findClassInJava(fqName: FqName): JavaClassLookupResult {
+fun LazyJavaResolverContext.findClassInJava(classId: ClassId): JavaClassLookupResult {
-    val kotlinClass = kotlinClassFinder.findKotlinClass(fqName)
+    val kotlinClass = kotlinClassFinder.findKotlinClass(classId)
     val binaryClassResult = resolveBinaryClass(kotlinClass)
     if (binaryClassResult != null) return binaryClassResult
 
-    val javaClass = finder.findClass(fqName)
+    val javaClass = finder.findClass(classId)
     if (javaClass == null) return JavaClassLookupResult()
 
     // Light classes are not proper binaries either

core/descriptors/src/org/jetbrains/jet/lang/resolve/name/FqNameBase.java

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.name;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
@@ -44,11 +45,11 @@ public abstract class FqNameBase {
         }
     }
 
-    public final boolean equalsTo(@NotNull FqName that) {
+    public final boolean equalsTo(@Nullable FqName that) {
-        return equalsTo(that.toUnsafe());
+        return that != null && equalsTo(that.toUnsafe());
     }
 
-    public final boolean equalsTo(@NotNull FqNameUnsafe that) {
+    public final boolean equalsTo(@Nullable FqNameUnsafe that) {
         return toFqNameUnsafe().equals(that);
     }