Refactor JDR: add explicit binding between java classes and packages for their statics

Get rid of Kind in JavaPackageFragmentDescriptor and create subclass which exposes additional function
Add method in JavaClassDescriptor to get correponding package fragment
Remove JavaDescriptorResolver from context

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

@@ -27,14 +27,17 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 
-import javax.inject.Inject;
-
 public class JavaDescriptorResolver implements DependencyClassByQualifiedNameResolver {
     public static final Name JAVA_ROOT = Name.special("<java_root>");
 
-    private ModuleDescriptor module;
+    private final ModuleDescriptor module;
 
-    private LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
+    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
+
+    public JavaDescriptorResolver(@NotNull LazyJavaPackageFragmentProvider provider, @NotNull ModuleDescriptor module) {
+        lazyJavaPackageFragmentProvider = provider;
+        this.module = module;
+    }
 
     @NotNull
     public ModuleDescriptor getModule() {
@@ -56,14 +59,4 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     public PackageFragmentDescriptor getPackageFragment(@NotNull FqName fqName) {
         return lazyJavaPackageFragmentProvider.getPackageFragment(fqName);
     }
-
-    @Inject
-    public void setModule(@NotNull ModuleDescriptor module) {
-        this.module = module;
-    }
-
-    @Inject
-    public void setLazyJavaPackageFragmentProvider(@NotNull LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider) {
-        this.lazyJavaPackageFragmentProvider = lazyJavaPackageFragmentProvider;
-    }
 }

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

@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassStaticsPackageFragmentDescriptor;
 
 public class JavaVisibilities {
     private JavaVisibilities() {
@@ -67,16 +67,11 @@ public class JavaVisibilities {
             // protected static function or property
             else {
                 DeclarationDescriptor whatDeclarationDescriptor = what.getContainingDeclaration();
-
-                assert whatDeclarationDescriptor instanceof JavaPackageFragmentDescriptor : "Only static declarations can have protected_static visibility";
-                JavaPackageFragmentDescriptor javaPackageFragmentDescriptor = (JavaPackageFragmentDescriptor) whatDeclarationDescriptor;
-
-                whatClass = javaPackageFragmentDescriptor.getJavaDescriptorResolver().resolveClass(
-                        javaPackageFragmentDescriptor.getFqName());
+                assert whatDeclarationDescriptor instanceof JavaClassStaticsPackageFragmentDescriptor
+                        : "Only static declarations can have protected_static visibility";
+                whatClass = ((JavaClassStaticsPackageFragmentDescriptor) whatDeclarationDescriptor).getCorrespondingClass();
             }
 
-            assert whatClass != null : "Couldn't find ClassDescriptor for protected static member " + what;
-
             if (DescriptorUtils.isSubclass(fromClass, whatClass)) {
                 return true;
             }
@@ -143,10 +138,8 @@ public class JavaVisibilities {
     @Nullable
     private static PackageFragmentDescriptor getPackageStaticsAware(@NotNull DeclarationDescriptor member) {
         PackageFragmentDescriptor packageFragment = DescriptorUtils.getParentOfType(member, PackageFragmentDescriptor.class, false);
-        if (packageFragment instanceof JavaPackageFragmentDescriptor
-            && ((JavaPackageFragmentDescriptor) packageFragment).getKind() == JavaPackageFragmentDescriptor.Kind.CLASS_STATICS) {
-            ClassDescriptor classForPackage =
-                    ((JavaPackageFragmentDescriptor) packageFragment).getJavaDescriptorResolver().resolveClass(packageFragment.getFqName());
+        if (packageFragment instanceof JavaClassStaticsPackageFragmentDescriptor) {
+            ClassDescriptor classForPackage = ((JavaClassStaticsPackageFragmentDescriptor) packageFragment).getCorrespondingClass();
             return DescriptorUtils.getParentOfType(classForPackage, PackageFragmentDescriptor.class, false);
         }
         return packageFragment;

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

@@ -23,4 +23,7 @@ import org.jetbrains.jet.lang.types.JetType;
 public interface JavaClassDescriptor extends ClassDescriptor {
     @Nullable
     JetType getFunctionTypeForSamInterface();
+
+    @Nullable
+    JavaClassStaticsPackageFragmentDescriptor getCorrespondingPackageFragment();
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -14,26 +14,14 @@
  * limitations under the License.
  */
 
-package org.jetbrains.jet.lang.resolve.java.descriptor;
+package org.jetbrains.jet.lang.resolve.java.descriptor
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
 
-public interface JavaPackageFragmentDescriptor extends PackageFragmentDescriptor {
-    @NotNull
-    @Override
-    JavaPackageFragmentProvider getProvider();
-
-    @NotNull
-    JavaDescriptorResolver getJavaDescriptorResolver();
-
-    enum Kind {
-        PROPER,
-        CLASS_STATICS,
-    }
-
-    @NotNull
-    Kind getKind();
+public trait JavaPackageFragmentDescriptor : PackageFragmentDescriptor {
+    override fun getProvider(): JavaPackageFragmentProvider
+}
+
+public trait JavaClassStaticsPackageFragmentDescriptor : JavaPackageFragmentDescriptor {
+    public fun getCorrespondingClass(): JavaClassDescriptor
 }

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

@@ -29,8 +29,7 @@ public class LazyJavaPackageFragmentProvider(
             outerContext.externalSignatureResolver,
             outerContext.errorReporter,
             outerContext.methodSignatureChecker,
-            outerContext.javaResolverCache,
-            outerContext.javaDescriptorResolver
+            outerContext.javaResolverCache
     )
 
     override fun getModule() = _module

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

@@ -26,12 +26,8 @@ import org.jetbrains.jet.lang.resolve.java.resolver.ExternalSignatureResolver
 import org.jetbrains.jet.lang.resolve.java.resolver.MethodSignatureChecker
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaResolverCache
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder
-import org.jetbrains.jet.lang.resolve.name.FqName
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
 
 open class GlobalJavaResolverContext(
         val storageManager: StorageManager,
@@ -42,8 +38,7 @@ open class GlobalJavaResolverContext(
         val externalSignatureResolver: ExternalSignatureResolver,
         val errorReporter: ErrorReporter,
         val methodSignatureChecker: MethodSignatureChecker,
-        val javaResolverCache: JavaResolverCache,
-        val javaDescriptorResolver: JavaDescriptorResolver
+        val javaResolverCache: JavaResolverCache
 )
 
 open class LazyJavaResolverContext(
@@ -57,12 +52,10 @@ open class LazyJavaResolverContext(
         externalSignatureResolver: ExternalSignatureResolver,
         errorReporter: ErrorReporter,
         methodSignatureChecker: MethodSignatureChecker,
-        javaResolverCache: JavaResolverCache,
-        javaDescriptorResolver: JavaDescriptorResolver
+        javaResolverCache: JavaResolverCache
 ) : GlobalJavaResolverContext(storageManager, finder, kotlinClassFinder, deserializedDescriptorResolver,
                               externalAnnotationResolver, externalSignatureResolver,
-                              errorReporter, methodSignatureChecker, javaResolverCache,
-                              javaDescriptorResolver)
+                              errorReporter, methodSignatureChecker, javaResolverCache)
 
 fun LazyJavaResolverContext.withTypes(
         typeParameterResolver: TypeParameterResolver = TypeParameterResolver.EMPTY
@@ -78,7 +71,6 @@ fun LazyJavaResolverContext.withTypes(
         errorReporter,
         methodSignatureChecker,
         javaResolverCache,
-        javaDescriptorResolver,
         LazyJavaTypeResolver(this, typeParameterResolver),
         typeParameterResolver)
 
@@ -94,14 +86,12 @@ class LazyJavaResolverContextWithTypes(
         errorReporter: ErrorReporter,
         methodSignatureChecker: MethodSignatureChecker,
         javaResolverCache: JavaResolverCache,
-        javaDescriptorResolver: JavaDescriptorResolver,
         val typeResolver: LazyJavaTypeResolver,
         val typeParameterResolver: TypeParameterResolver
 ) : LazyJavaResolverContext(packageFragmentProvider, javaClassResolver, storageManager, finder,
                             kotlinClassFinder, deserializedDescriptorResolver,
                             externalAnnotationResolver, externalSignatureResolver,
-                            errorReporter, methodSignatureChecker, javaResolverCache,
-                            javaDescriptorResolver)
+                            errorReporter, methodSignatureChecker, javaResolverCache)
 
 fun LazyJavaResolverContextWithTypes.child(
         containingDeclaration: DeclarationDescriptor,

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

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorFactory
 import java.util.ArrayList
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassStaticsPackageFragmentDescriptor
 
 class LazyJavaClassDescriptor(
         private val outerC: LazyJavaResolverContextWithTypes,
@@ -110,6 +111,9 @@ class LazyJavaClassDescriptor(
         classObject.getBuilder().addFunctionDescriptor(valueOfMethod)
     }
 
+    override fun getCorrespondingPackageFragment() =
+            c.packageFragmentProvider.getPackageFragment(fqName) as? JavaClassStaticsPackageFragmentDescriptor
+
     override fun getClassObjectDescriptor(): ClassDescriptor? = _classObjectDescriptor()
     override fun getClassObjectType(): JetType? = getClassObjectDescriptor()?.let { d -> d.getDefaultType() }
 

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

@@ -13,30 +13,39 @@ import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorNonRootImpl
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor
 import org.jetbrains.jet.lang.types.TypeSubstitutor
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassStaticsPackageFragmentDescriptor
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor
 
-fun LazyPackageFragmentForJavaPackage(
+class LazyPackageFragmentForJavaPackage(
         c: LazyJavaResolverContext,
         containingDeclaration: ModuleDescriptor,
         jPackage: JavaPackage
-) = LazyJavaPackageFragment(c, containingDeclaration, JavaPackageFragmentDescriptor.Kind.PROPER, jPackage.getFqName(),
+) : LazyJavaPackageFragment(c, containingDeclaration, jPackage.getFqName(),
                             { LazyPackageFragmentScopeForJavaPackage(c, jPackage, this) })
 
-fun LazyPackageFragmentForJavaClass(
+class LazyPackageFragmentForJavaClass(
         c: LazyJavaResolverContext,
         containingDeclaration: ModuleDescriptor,
-        jClass: JavaClass
-) = LazyJavaPackageFragment(c, containingDeclaration, JavaPackageFragmentDescriptor.Kind.CLASS_STATICS,
+        private val jClass: JavaClass
+) : JavaClassStaticsPackageFragmentDescriptor,
+    LazyJavaPackageFragment(c, containingDeclaration,
                             jClass.getFqName().sure("Attempt to build a package of an anonymous/local class: $jClass"),
-                            { LazyPackageFragmentScopeForJavaClass(c, jClass, this) })
+                            { LazyPackageFragmentScopeForJavaClass(c, jClass, this) }) {
+    override fun getCorrespondingClass(): JavaClassDescriptor {
+        val classDescriptor = c.javaClassResolver.resolveClass(jClass)
+        if (classDescriptor !is JavaClassDescriptor) {
+            throw AssertionError("Corresponding class not found for package with static members: $this")
+        }
+        return classDescriptor
+    }
+}
 
-class LazyJavaPackageFragment(
-        private val c: LazyJavaResolverContext,
+abstract class LazyJavaPackageFragment(
+        protected val c: LazyJavaResolverContext,
         containingDeclaration: ModuleDescriptor,
-        val _kind: JavaPackageFragmentDescriptor.Kind,
-        val _fqName: FqName,
+        private val _fqName: FqName,
         createMemberScope: LazyJavaPackageFragment.() -> LazyJavaPackageFragmentScope
 ) : DeclarationDescriptorNonRootImpl(containingDeclaration, Annotations.EMPTY, _fqName.shortNameOrSpecial()),
     JavaPackageFragmentDescriptor, LazyJavaDescriptor
@@ -44,9 +53,7 @@ class LazyJavaPackageFragment(
     private val _memberScope = createMemberScope()
     override fun getMemberScope(): LazyJavaPackageFragmentScope = _memberScope
 
-    override fun getKind() = _kind
     override fun getFqName() = _fqName
-    override fun getJavaDescriptorResolver() = c.javaDescriptorResolver
     override fun getProvider() = c.packageFragmentProvider
 
     override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>, data: D) = visitor.visitPackageFragmentDescriptor(this, data) as R

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

@@ -267,16 +267,6 @@ public final class DescriptorResolverUtils {
         return TypeSubstitutor.create(typeSubstitutionContext);
     }
 
-    @Nullable
-    public static JavaPackageFragmentDescriptor getPackageForCorrespondingJavaClass(@NotNull JavaClassDescriptor javaClass) {
-        PackageFragmentDescriptor packageFragment = DescriptorUtils.getParentOfType(javaClass, PackageFragmentDescriptor.class);
-        assert packageFragment instanceof JavaPackageFragmentDescriptor :
-                "java class " + javaClass + " is under non-java fragment: " + packageFragment;
-
-        JavaPackageFragmentProvider provider = ((JavaPackageFragmentDescriptor) packageFragment).getProvider();
-        return provider.getPackageFragment(getFqNameSafe(javaClass));
-    }
-
     public static boolean isJavaClassVisibleAsPackage(@NotNull JavaClass javaClass) {
         return !isCompiledKotlinClassOrPackageClass(javaClass) && hasStaticMembers(javaClass);
     }