All extra services delivered through contexts

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

@@ -25,9 +25,7 @@ import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaSubModule;
-import org.jetbrains.jet.lang.resolve.java.resolver.ExternalAnnotationResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.*;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 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;
@@ -53,6 +51,10 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     private JavaClassFinder javaClassFinder;
     private ExternalAnnotationResolver externalAnnotationResolver;
     private LazyJavaSubModule subModule;
+    private ExternalSignatureResolver externalSignatureResolver;
+    private ErrorReporter errorReporter;
+    private MethodSignatureChecker signatureChecker;
+    private JavaResolverCache javaResolverCache;
 
     @Inject
     public void setClassResolver(JavaClassResolver classResolver) {
@@ -74,6 +76,26 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         this.externalAnnotationResolver = externalAnnotationResolver;
     }
 
+    @Inject
+    public void setExternalSignatureResolver(ExternalSignatureResolver externalSignatureResolver) {
+        this.externalSignatureResolver = externalSignatureResolver;
+    }
+
+    @Inject
+    public void setErrorReporter(ErrorReporter errorReporter) {
+        this.errorReporter = errorReporter;
+    }
+
+    @Inject
+    public void setSignatureChecker(MethodSignatureChecker signatureChecker) {
+        this.signatureChecker = signatureChecker;
+    }
+
+    @Inject
+    public void setJavaResolverCache(JavaResolverCache javaResolverCache) {
+        this.javaResolverCache = javaResolverCache;
+    }
+
     @NotNull
     private LazyJavaSubModule getSubModule() {
         if (subModule == null) {
@@ -92,7 +114,11 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
                                     return null;
                                 }
                             },
-                            externalAnnotationResolver
+                            externalAnnotationResolver,
+                            externalSignatureResolver,
+                            errorReporter,
+                            signatureChecker,
+                            javaResolverCache
                     ),
                     new ModuleDescriptorImpl(Name.special("<java module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY)
             );

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

@@ -19,7 +19,11 @@ public open class LazyJavaSubModule(
             outerContext.storageManager,
             outerContext.finder,
             SubModuleClassResolver(),
-            outerContext.externalAnnotationResolver
+            outerContext.externalAnnotationResolver,
+            outerContext.externalSignatureResolver,
+            outerContext.errorReporter,
+            outerContext.methodSignatureChecker,
+            outerContext.javaResolverCache
     )
 
     private val _packageFragments: MemoizedFunctionToNullable<FqName, NamespaceDescriptor> = c.storageManager.createMemoizedFunctionWithNullableValues {

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

@@ -21,16 +21,21 @@ import org.jetbrains.jet.lang.resolve.java.lazy.types.LazyJavaTypeResolver
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinder
-import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotation
-import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaAnnotationDescriptor
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.jet.lang.resolve.java.resolver.ExternalAnnotationResolver
+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
 
 open class GlobalJavaResolverContext(
         val storageManager: StorageManager,
         val finder: JavaClassFinder,
         val javaClassResolver: LazyJavaClassResolver,
-        val externalAnnotationResolver: ExternalAnnotationResolver 
+        val externalAnnotationResolver: ExternalAnnotationResolver,
+        val externalSignatureResolver: ExternalSignatureResolver,
+        val errorReporter: ErrorReporter,
+        val methodSignatureChecker: MethodSignatureChecker,
+        val javaResolverCache: JavaResolverCache
 )
 
 open class LazyJavaResolverContext(
@@ -38,8 +43,14 @@ open class LazyJavaResolverContext(
         storageManager: StorageManager,
         finder: JavaClassFinder,
         javaClassResolver: LazyJavaClassResolver,
-        externalAnnotationResolver: ExternalAnnotationResolver
+        externalAnnotationResolver: ExternalAnnotationResolver,
-) : GlobalJavaResolverContext(storageManager, finder, javaClassResolver, externalAnnotationResolver)
+        externalSignatureResolver: ExternalSignatureResolver,
+        errorReporter: ErrorReporter,
+        methodSignatureChecker: MethodSignatureChecker,
+        javaResolverCache: JavaResolverCache
+) : GlobalJavaResolverContext(storageManager, finder, javaClassResolver,
+                              externalAnnotationResolver, externalSignatureResolver,
+                              errorReporter, methodSignatureChecker, javaResolverCache)
 
 fun LazyJavaResolverContext.withTypes(
         typeParameterResolver: TypeParameterResolver = TypeParameterResolver.EMPTY
@@ -49,6 +60,10 @@ fun LazyJavaResolverContext.withTypes(
         finder,
         javaClassResolver,
         externalAnnotationResolver,
+        externalSignatureResolver,
+        errorReporter,
+        methodSignatureChecker,
+        javaResolverCache,
         LazyJavaTypeResolver(this, typeParameterResolver),
         typeParameterResolver)
 
@@ -58,9 +73,15 @@ class LazyJavaResolverContextWithTypes(
         finder: JavaClassFinder,
         javaClassResolver: LazyJavaClassResolver,
         externalAnnotationResolver: ExternalAnnotationResolver,
+        externalSignatureResolver: ExternalSignatureResolver,
+        errorReporter: ErrorReporter,
+        methodSignatureChecker: MethodSignatureChecker,
+        javaResolverCache: JavaResolverCache,
         val typeResolver: LazyJavaTypeResolver,
         val typeParameterResolver: TypeParameterResolver
-) : LazyJavaResolverContext(subModule, storageManager, finder, javaClassResolver, externalAnnotationResolver)
+) : LazyJavaResolverContext(subModule, storageManager, finder, javaClassResolver,
+                            externalAnnotationResolver, externalSignatureResolver,
+                            errorReporter, methodSignatureChecker, javaResolverCache)
 
 fun LazyJavaResolverContextWithTypes.child(
         containingDeclaration: DeclarationDescriptor,