Merge LazyJavaResolverContext and LazyJavaResolverContextWithTypes

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

@@ -31,23 +31,7 @@ public class LazyJavaPackageFragmentProvider(
         val module: ModuleDescriptor
 ) : PackageFragmentProvider {
 
-    private val c = LazyJavaResolverContext(
+    private val c = LazyJavaResolverContext(outerContext, this, FragmentClassResolver(), TypeParameterResolver.EMPTY)
-            this,
-            FragmentClassResolver(),
-            outerContext.storageManager,
-            outerContext.finder,
-            outerContext.kotlinClassFinder,
-            outerContext.deserializedDescriptorResolver,
-            outerContext.externalAnnotationResolver,
-            outerContext.externalSignatureResolver,
-            outerContext.errorReporter,
-            outerContext.methodSignatureChecker,
-            outerContext.javaResolverCache,
-            outerContext.javaPropertyInitializerEvaluator,
-            outerContext.samConversionResolver,
-            outerContext.sourceElementFactory,
-            outerContext.moduleClassResolver
-    )
 
     private val packageFragments: MemoizedFunctionToNullable<FqName, LazyJavaPackageFragment> =
             c.storageManager.createMemoizedFunctionWithNullableValues {
@@ -67,12 +51,7 @@ public class LazyJavaPackageFragmentProvider(
         val packageFragment = getPackageFragment(fqName.parent())
         if (packageFragment == null) return@lambda null
 
-        LazyJavaClassDescriptor(
+        LazyJavaClassDescriptor(c, packageFragment, fqName, jClass)
-                c.withTypes(TypeParameterResolver.EMPTY),
-                packageFragment,
-                fqName,
-                jClass
-        )
     }
 
     private fun getPackageFragment(fqName: FqName) = packageFragments(fqName)

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

@@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames
 import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.resolveAnnotation
 
 class LazyJavaAnnotations(
-        c: LazyJavaResolverContextWithTypes,
+        c: LazyJavaResolverContext,
         val annotationOwner: JavaAnnotationOwner,
         private val extraLookup: (FqName) -> JavaAnnotation? = { null }
 ) : Annotations {
@@ -48,7 +48,7 @@ class LazyJavaAnnotations(
     override fun isEmpty() = iterator().hasNext()
 }
 
-fun LazyJavaResolverContextWithTypes.resolveAnnotations(annotationsOwner: JavaAnnotationOwner): Annotations
+fun LazyJavaResolverContext.resolveAnnotations(annotationsOwner: JavaAnnotationOwner): Annotations
         = LazyJavaAnnotations(this, annotationsOwner) { fqName -> externalAnnotationResolver.findExternalAnnotation(annotationsOwner, fqName) }
 
 private fun GlobalJavaResolverContext.hasAnnotation(owner: JavaAnnotationOwner, annotationFqName: FqName): Boolean

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

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPropertyInitializerEvaluator
 import org.jetbrains.jet.lang.resolve.java.sources.JavaSourceElementFactory
+import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameterListOwner
 
 open class GlobalJavaResolverContext(
         val storageManager: StorageManager,
@@ -44,72 +45,34 @@ open class GlobalJavaResolverContext(
 )
 
 open class LazyJavaResolverContext(
+        globalContext: GlobalJavaResolverContext,
         val packageFragmentProvider: LazyJavaPackageFragmentProvider,
         val javaClassResolver: LazyJavaClassResolver,
-        storageManager: StorageManager,
-        finder: JavaClassFinder,
-        kotlinClassFinder: KotlinClassFinder,
-        deserializedDescriptorResolver: DeserializedDescriptorResolver,
-        externalAnnotationResolver: ExternalAnnotationResolver,
-        externalSignatureResolver: ExternalSignatureResolver,
-        errorReporter: ErrorReporter,
-        methodSignatureChecker: MethodSignatureChecker,
-        javaResolverCache: JavaResolverCache,
-        javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
-        samConversionResolver: SamConversionResolver,
-        sourceElementFactory: JavaSourceElementFactory,
-        moduleClassResolver: ModuleClassResolver
-) : GlobalJavaResolverContext(storageManager, finder, kotlinClassFinder, deserializedDescriptorResolver,
-                              externalAnnotationResolver, externalSignatureResolver,
-                              errorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator,
-                              samConversionResolver, sourceElementFactory, moduleClassResolver)
-
-fun LazyJavaResolverContext.withTypes(
-        typeParameterResolver: TypeParameterResolver = TypeParameterResolver.EMPTY
-)  =  LazyJavaResolverContextWithTypes(
-        packageFragmentProvider,
-        javaClassResolver,
-        storageManager,
-        finder,
-        kotlinClassFinder,
-        deserializedDescriptorResolver,
-        externalAnnotationResolver,
-        externalSignatureResolver,
-        errorReporter,
-        methodSignatureChecker,
-        javaResolverCache,
-        javaPropertyInitializerEvaluator,
-        samConversionResolver,
-        sourceElementFactory,
-        moduleClassResolver,
-        LazyJavaTypeResolver(this, typeParameterResolver),
-        typeParameterResolver
-)
-
-class LazyJavaResolverContextWithTypes(
-        packageFragmentProvider: LazyJavaPackageFragmentProvider,
-        javaClassResolver: LazyJavaClassResolver,
-        storageManager: StorageManager,
-        finder: JavaClassFinder,
-        kotlinClassFinder: KotlinClassFinder,
-        deserializedDescriptorResolver: DeserializedDescriptorResolver,
-        externalAnnotationResolver: ExternalAnnotationResolver,
-        externalSignatureResolver: ExternalSignatureResolver,
-        errorReporter: ErrorReporter,
-        methodSignatureChecker: MethodSignatureChecker,
-        javaResolverCache: JavaResolverCache,
-        javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
-        samConversionResolver: SamConversionResolver,
-        sourceElementFactory: JavaSourceElementFactory,
-        moduleClassResolver: ModuleClassResolver,
-        val typeResolver: LazyJavaTypeResolver,
         val typeParameterResolver: TypeParameterResolver
-) : LazyJavaResolverContext(packageFragmentProvider, javaClassResolver, storageManager, finder, kotlinClassFinder,
+) : GlobalJavaResolverContext(
-                            deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, errorReporter,
+        globalContext.storageManager,
-                            methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver,
+        globalContext.finder,
-                            sourceElementFactory, moduleClassResolver)
+        globalContext.kotlinClassFinder,
+        globalContext.deserializedDescriptorResolver,
+        globalContext.externalAnnotationResolver,
+        globalContext.externalSignatureResolver,
+        globalContext.errorReporter,
+        globalContext.methodSignatureChecker,
+        globalContext.javaResolverCache,
+        globalContext.javaPropertyInitializerEvaluator,
+        globalContext.samConversionResolver,
+        globalContext.sourceElementFactory,
+        globalContext.moduleClassResolver
+) {
+    val typeResolver = LazyJavaTypeResolver(this, typeParameterResolver)
+}
 
-fun LazyJavaResolverContextWithTypes.child(
+fun LazyJavaResolverContext.child(
+        typeParameterResolver: TypeParameterResolver
+) = LazyJavaResolverContext(this, packageFragmentProvider, javaClassResolver, typeParameterResolver)
+
+
+fun LazyJavaResolverContext.child(
         containingDeclaration: DeclarationDescriptor,
-        typeParameters: Set<JavaTypeParameter>
+        typeParameterOwner: JavaTypeParameterListOwner
-): LazyJavaResolverContextWithTypes = this.withTypes(LazyJavaTypeParameterResolver(this, containingDeclaration, typeParameters))
+) = this.child(LazyJavaTypeParameterResolver(this, containingDeclaration, typeParameterOwner))

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

@@ -19,7 +19,7 @@ package org.jetbrains.jet.lang.resolve.java.lazy.descriptors
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.jet.lang.types.*
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContextWithTypes
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.resolve.java.structure.*
 import org.jetbrains.jet.lang.resolve.constants.*
 import org.jetbrains.jet.lang.resolve.name.Name
@@ -43,14 +43,14 @@ private object DEPRECATED_IN_JAVA : JavaLiteralAnnotationArgument {
     override val value: Any? = "Deprecated in Java"
 }
 
-fun LazyJavaResolverContextWithTypes.resolveAnnotation(annotation: JavaAnnotation): LazyJavaAnnotationDescriptor? {
+fun LazyJavaResolverContext.resolveAnnotation(annotation: JavaAnnotation): LazyJavaAnnotationDescriptor? {
     val classId = annotation.getClassId()
     if (classId == null || JvmAnnotationNames.isSpecialAnnotation(classId, !PLATFORM_TYPES)) return null
     return LazyJavaAnnotationDescriptor(this, annotation)
 }
 
 class LazyJavaAnnotationDescriptor(
-        private val c: LazyJavaResolverContextWithTypes,
+        private val c: LazyJavaResolverContext,
         val javaAnnotation : JavaAnnotation
 ) : AnnotationDescriptor {
 

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

@@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.types.TypeConstructor
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContextWithTypes
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.resolve.java.lazy.child
 import org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage
 import org.jetbrains.jet.lang.resolve.java.lazy.resolveAnnotations
@@ -36,14 +36,14 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotations
 import org.jetbrains.jet.lang.types.AbstractClassTypeConstructor
 
 class LazyJavaClassDescriptor(
-        private val outerC: LazyJavaResolverContextWithTypes,
+        private val outerC: LazyJavaResolverContext,
         containingDeclaration: DeclarationDescriptor,
         internal val fqName: FqName,
         private val jClass: JavaClass
 ) : ClassDescriptorBase(outerC.storageManager, containingDeclaration, fqName.shortName(),
                         outerC.sourceElementFactory.source(jClass)), JavaClassDescriptor {
 
-    private val c: LazyJavaResolverContextWithTypes = outerC.child(this, jClass.getTypeParameters().toSet());
+    private val c: LazyJavaResolverContext = outerC.child(this, jClass);
 
     {
         c.javaResolverCache.recordClass(jClass, this)

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

@@ -19,7 +19,7 @@ package org.jetbrains.jet.lang.resolve.java.lazy.descriptors
 import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.resolve.java.structure.*
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContextWithTypes
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage
 import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl
@@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class LazyJavaClassMemberScope(
-        c: LazyJavaResolverContextWithTypes,
+        c: LazyJavaResolverContext,
         containingDeclaration: ClassDescriptor,
         private val jClass: JavaClass
 ) : LazyJavaMemberScope(c, containingDeclaration) {

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

@@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
 import org.jetbrains.jet.lang.resolve.java.structure.JavaField
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContextWithTypes
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaMethodDescriptor
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import org.jetbrains.jet.lang.resolve.java.lazy.child
@@ -48,7 +48,7 @@ import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindExclude.NonExtensions
 
 public abstract class LazyJavaMemberScope(
-        protected val c: LazyJavaResolverContextWithTypes,
+        protected val c: LazyJavaResolverContext,
         private val containingDeclaration: DeclarationDescriptor
 ) : JetScope {
     // this lazy value is not used at all in LazyPackageFragmentScopeForJavaPackage because we do not use caching there
@@ -115,7 +115,7 @@ public abstract class LazyJavaMemberScope(
                 containingDeclaration, annotations, method.getName(), c.sourceElementFactory.source(method)
         )
 
-        val c = c.child(functionDescriptorImpl, method.getTypeParameters().toSet())
+        val c = c.child(functionDescriptorImpl, method)
 
         val methodTypeParameters = method.getTypeParameters().map { p -> c.typeParameterResolver.resolveTypeParameter(p)!! }
         val valueParameters = resolveValueParameters(c, functionDescriptorImpl, method.getValueParameters())
@@ -155,9 +155,10 @@ public abstract class LazyJavaMemberScope(
     protected class ResolvedValueParameters(val descriptors: List<ValueParameterDescriptor>, val hasSynthesizedNames: Boolean)
 
     protected fun resolveValueParameters(
-            c: LazyJavaResolverContextWithTypes,
+            c: LazyJavaResolverContext,
             function: FunctionDescriptor,
-            jValueParameters: List<JavaValueParameter>): ResolvedValueParameters {
+            jValueParameters: List<JavaValueParameter>
+    ): ResolvedValueParameters {
         var synthesizedNames = false
         val descriptors = jValueParameters.withIndices().map { pair ->
             val (index, javaParameter) = pair

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

@@ -19,15 +19,13 @@ package org.jetbrains.jet.lang.resolve.java.lazy.descriptors
 import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.resolve.name.*
 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.JavaMethod
 import org.jetbrains.jet.lang.types.JetType
-import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor
 
 public abstract class LazyJavaStaticScope(
         c: LazyJavaResolverContext,
         descriptor: ClassOrPackageFragmentDescriptor
-) : LazyJavaMemberScope(c.withTypes(), descriptor) {
+) : LazyJavaMemberScope(c, descriptor) {
 
     override fun getDispatchReceiverParameter() = null
 

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

@@ -23,12 +23,12 @@ import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContextWithTypes
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.resolve.java.lazy.types.toAttributes
 import org.jetbrains.jet.lang.descriptors.SourceElement
 
 class LazyJavaTypeParameterDescriptor(
-        private val c: LazyJavaResolverContextWithTypes,
+        private val c: LazyJavaResolverContext,
         public val javaTypeParameter: JavaTypeParameter,
         containingDeclaration: DeclarationDescriptor
 ) : AbstractLazyTypeParameterDescriptor(

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

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.jet.lang.resolve.name.ClassId
+import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameterListOwner
 
 //TODO: (module refactoring) usages of this interface should be replaced by ModuleClassResolver
 trait LazyJavaClassResolver {
@@ -42,21 +43,18 @@ trait TypeParameterResolver {
 }
 
 class LazyJavaTypeParameterResolver(
-        val c: LazyJavaResolverContextWithTypes,
+        private val c: LazyJavaResolverContext,
         private val containingDeclaration: DeclarationDescriptor,
-        private val typeParameters: Set<JavaTypeParameter>
+        typeParameterOwner: JavaTypeParameterListOwner
 ) : TypeParameterResolver {
+    private val typeParameters = typeParameterOwner.getTypeParameters().toSet()
 
     private val resolve = c.storageManager.createMemoizedFunctionWithNullableValues {
-                (javaTypeParameter: JavaTypeParameter) ->
+        (javaTypeParameter: JavaTypeParameter) ->
-                if (javaTypeParameter in typeParameters)
+        if (javaTypeParameter in typeParameters)
-                    LazyJavaTypeParameterDescriptor(
+            LazyJavaTypeParameterDescriptor(c.child(this), javaTypeParameter, containingDeclaration)
-                            c.withTypes(this),
+        else null
-                            javaTypeParameter,
+    }
-                            containingDeclaration
-                    )
-                else null
-            }
 
     override fun resolveTypeParameter(javaTypeParameter: JavaTypeParameter): TypeParameterDescriptor? {
         return resolve(javaTypeParameter) ?: c.typeParameterResolver.resolveTypeParameter(javaTypeParameter)