Decompiler: introduce ResolverForDecompiler as dependency for DecompiledDataFactory

Extract JDR based implementation of ResolverForDecompiler from DecompiledDataFactory

idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java

@@ -21,13 +21,9 @@ import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiManager;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
-import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.MemberComparator;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache;
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass;
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader;
@@ -50,7 +46,7 @@ public final class DecompiledDataFactory {
     @NotNull
     private final Map<String, TextRange> renderedDescriptorsToRange = new HashMap<String, TextRange>();
     @NotNull
-    private final JavaDescriptorResolver javaDescriptorResolver;
+    private final ResolverForDecompiler resolver;
     @NotNull
     private final KotlinClassHeader classFileHeader;
     @NotNull
@@ -60,11 +56,9 @@ public final class DecompiledDataFactory {
     @NotNull
     private final Project project;
 
-    private DecompiledDataFactory(@NotNull VirtualFile classFile, @NotNull Project project) {
+    private DecompiledDataFactory(@NotNull VirtualFile classFile, @NotNull Project project, @NotNull ResolverForDecompiler resolver) {
         this.classFile = classFile;
         this.project = project;
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext());
-        this.javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
         KotlinJvmBinaryClass kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile);
         this.classFqName = kotlinClass.getClassName().getFqNameForClassNameWithoutDollars();
@@ -72,11 +66,12 @@ public final class DecompiledDataFactory {
         KotlinClassHeader header = kotlinClass.getClassHeader();
         assert header != null : "Decompiled data factory shouldn't be called on an unsupported file: " + classFile;
         this.classFileHeader = header;
+        this.resolver = resolver;
     }
 
     @NotNull
     static JetDecompiledData createDecompiledData(@NotNull VirtualFile virtualFile, @NotNull Project project) {
-        return new DecompiledDataFactory(virtualFile, project).build();
+        return new DecompiledDataFactory(virtualFile, project, new ProjectBasedResolverForDecompiler(project)).build();
     }
 
     private JetDecompiledData build() {
@@ -84,18 +79,15 @@ public final class DecompiledDataFactory {
         appendDecompiledTextAndPackageName(packageFqName);
         KotlinClassHeader.Kind kind = classFileHeader.getKind();
         if (kind == KotlinClassHeader.Kind.PACKAGE_FACADE) {
-            PackageFragmentDescriptor pf = javaDescriptorResolver.getPackageFragment(packageFqName);
+            for (DeclarationDescriptor member : sortDeclarations(resolver.resolveDeclarationsInPackage(packageFqName))) {
-            if (pf != null) {
+                if (!(member instanceof ClassDescriptor)) {
-                for (DeclarationDescriptor member : sortDeclarations(pf.getMemberScope().getAllDescriptors())) {
+                    appendDescriptor(member, "");
-                    if (!(member instanceof ClassDescriptor)) {
+                    builder.append("\n");
-                        appendDescriptor(member, "");
-                        builder.append("\n");
-                    }
                 }
             }
         }
         else if (kind == KotlinClassHeader.Kind.CLASS) {
-            ClassDescriptor cd = javaDescriptorResolver.resolveClass(classFqName);
+            ClassDescriptor cd = resolver.resolveClass(classFqName);
             if (cd != null) {
                 appendDescriptor(cd, "");
             }

idea/src/org/jetbrains/jet/plugin/libraries/ProjectBasedResolverForDecompiler.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2014 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.jet.plugin.libraries
+
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil
+import com.intellij.openapi.project.Project
+import org.jetbrains.jet.lang.resolve.BindingTraceContext
+import java.util.Collections
+
+public class ProjectBasedResolverForDecompiler(project: Project) : ResolverForDecompiler {
+    val javaDescriptorResolver = InjectorForJavaDescriptorResolverUtil.create(project, BindingTraceContext()).getJavaDescriptorResolver()!!
+
+    override fun resolveClass(classFqName: FqName): ClassDescriptor? {
+        return javaDescriptorResolver.resolveClass(classFqName)
+    }
+
+    override fun resolveDeclarationsInPackage(packageFqName: FqName): Collection<DeclarationDescriptor> {
+        val packageFragment = javaDescriptorResolver.getPackageFragment(packageFqName)
+        if (packageFragment == null) {
+            return Collections.emptyList()
+        }
+        return packageFragment.getMemberScope().getAllDescriptors()
+    }
+}

idea/src/org/jetbrains/jet/plugin/libraries/ResolverForDecompiler.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2014 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.jet.plugin.libraries
+
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+
+trait ResolverForDecompiler {
+    fun resolveClass(classFqName: FqName): ClassDescriptor?
+    fun resolveDeclarationsInPackage(packageFqName: FqName): Collection<DeclarationDescriptor>
+}