Remove useless InjectorForLazyResolveWithJavaUtil, move methods to LazyResolveTestUtil

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java

@@ -172,7 +172,7 @@ public class InjectorForLazyResolveWithJava {
         this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
         this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver);
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
         this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
@@ -220,9 +220,9 @@ public class InjectorForLazyResolveWithJava {
         scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
         scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
 
-        this.javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
-        this.javaClassFinder.setProject(project);
-        this.javaClassFinder.setScope(moduleContentScope);
+        javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
+        javaClassFinder.setProject(project);
+        javaClassFinder.setScope(moduleContentScope);
 
         traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         traceBasedExternalSignatureResolver.setProject(project);
@@ -329,8 +329,4 @@ public class InjectorForLazyResolveWithJava {
         return this.javaDescriptorResolver;
     }
 
-    public JavaClassFinderImpl getJavaClassFinder() {
-        return this.javaClassFinder;
-    }
-
 }

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJavaUtil.java

@@ -1,62 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.di;
-
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.search.GlobalSearchScope;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.context.ContextPackage;
-import org.jetbrains.kotlin.context.GlobalContextImpl;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService;
-
-import java.util.Collections;
-
-public class InjectorForLazyResolveWithJavaUtil {
-    @NotNull
-    public static InjectorForLazyResolveWithJava create(@NotNull Project project, @NotNull BindingTrace trace, boolean dependOnBuiltins) {
-        ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createJavaModule("<module>");
-
-        GlobalSearchScope moduleContentScope = GlobalSearchScope.allScope(project);
-        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-        DeclarationProviderFactory declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
-                project, globalContext.getStorageManager(), Collections.<JetFile>emptyList(), moduleContentScope
-        );
-        SingleModuleClassResolver resolver = new SingleModuleClassResolver();
-
-        InjectorForLazyResolveWithJava injector = new InjectorForLazyResolveWithJava(
-                project, globalContext, trace, module, declarationProviderFactory, moduleContentScope, resolver
-        );
-
-        resolver.setResolver(injector.getJavaDescriptorResolver());
-
-        module.addDependencyOnModule(module);
-        module.initialize(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
-        if (dependOnBuiltins) {
-            module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
-        }
-        module.seal();
-
-        return injector;
-    }
-}

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java

@@ -25,19 +25,20 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJavaUtil;
 import org.jetbrains.kotlin.load.java.JavaBindingContext;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
+import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.TypeTransformingVisitor;
+import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 
 import java.io.IOException;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -75,9 +76,9 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase
                 JetCoreEnvironment commonEnvironment = createEnvironment(parentDisposable);
 
                 BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-                InjectorForLazyResolveWithJava injector =
-                        InjectorForLazyResolveWithJavaUtil.create(commonEnvironment.getProject(), trace, false);
-                ModuleDescriptor module = injector.getModule();
+                ModuleDescriptor module = LazyResolveTestUtil.resolve(
+                        commonEnvironment.getProject(), trace, Collections.<JetFile>emptyList()
+                );
 
                 AlternativeSignatureErrorFindingVisitor visitor =
                         new AlternativeSignatureErrorFindingVisitor(trace.getBindingContext(), errors);

compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java

@@ -33,15 +33,15 @@ import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJavaUtil;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
+import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
@@ -50,6 +50,7 @@ import java.io.File;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.kotlin.test.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations;
@@ -89,13 +90,13 @@ public final class LoadDescriptorUtil {
                 javaRoot,
                 new File("compiler/tests") // for @ExpectLoadError annotation
         );
-        JetCoreEnvironment jetCoreEnvironment =
+        JetCoreEnvironment environment =
                 JetCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
-        BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-        InjectorForLazyResolveWithJava injector =
-                InjectorForLazyResolveWithJavaUtil.create(jetCoreEnvironment.getProject(), trace, true);
 
-        PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME);
+        BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
+        ModuleDescriptor module = LazyResolveTestUtil.resolve(environment.getProject(), trace, Collections.<JetFile>emptyList());
+
+        PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
         assert packageView != null;
 
         return Pair.create(packageView, trace.getBindingContext());

compiler/tests/org/jetbrains/kotlin/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java

@@ -30,10 +30,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJavaUtil;
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.resolve.BindingTraceContext;
+import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
@@ -178,8 +177,7 @@ public class ResolveDescriptorsFromExternalLibraries {
             }
         }
 
-        InjectorForLazyResolveWithJava injector =
-                InjectorForLazyResolveWithJavaUtil.create(jetCoreEnvironment.getProject(), new BindingTraceContext(), false);
+        ModuleDescriptor module = LazyResolveTestUtil.resolveProject(jetCoreEnvironment.getProject());
 
         boolean hasErrors;
         try {
@@ -211,7 +209,7 @@ public class ResolveDescriptorsFromExternalLibraries {
                 String className = entryName.substring(0, entryName.length() - ".class".length()).replace("/", ".");
 
                 try {
-                    ClassDescriptor clazz = resolveTopLevelClass(injector.getModule(), new FqName(className));
+                    ClassDescriptor clazz = resolveTopLevelClass(module, new FqName(className));
                     if (clazz == null) {
                         throw new IllegalStateException("class not found by name " + className + " in " + libDescription);
                     }

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

@@ -20,33 +20,28 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJavaUtil;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava;
 import org.jetbrains.kotlin.di.InjectorForTests;
-import org.jetbrains.kotlin.load.java.structure.JavaClass;
-import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl;
-import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
+import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage;
+import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.junit.Assert;
 
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import static com.intellij.testFramework.UsefulTestCase.assertInstanceOf;
+import static org.junit.Assert.assertNotNull;
 
 public class JetExpectedResolveDataUtil {
     private JetExpectedResolveDataUtil() {
@@ -91,7 +86,7 @@ public class JetExpectedResolveDataUtil {
         nameToDeclaration.put("java::java.io.PrintStream.print(char[])", methods[6]);
         nameToDeclaration.put("java::java.io.PrintStream.print(Double)", methods[5]);
         PsiField outField = java_lang_System.findFieldByName("out", true);
-        Assert.assertNotNull("'out' property wasn't found", outField);
+        assertNotNull("'out' property wasn't found", outField);
         nameToDeclaration.put("java::java.lang.System.out", outField);
         PsiClass java_lang_Number = findClass("java.lang.Number", project);
         nameToDeclaration.put("java::java.lang.Number", java_lang_Number);
@@ -104,7 +99,7 @@ public class JetExpectedResolveDataUtil {
     private static PsiElement findPackage(String qualifiedName, Project project) {
         JavaPsiFacade javaFacade = JavaPsiFacade.getInstance(project);
         PsiPackage javaFacadePackage = javaFacade.findPackage(qualifiedName);
-        Assert.assertNotNull("Package wasn't found: " + qualifiedName, javaFacadePackage);
+        assertNotNull("Package wasn't found: " + qualifiedName, javaFacadePackage);
         return javaFacadePackage;
     }
 
@@ -116,12 +111,12 @@ public class JetExpectedResolveDataUtil {
 
     @NotNull
     private static PsiClass findClass(String qualifiedName, Project project) {
-        BindingTraceContext trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-        InjectorForLazyResolveWithJava injector = InjectorForLazyResolveWithJavaUtil.create(project, trace, false);
-        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();
+        ModuleDescriptor module = LazyResolveTestUtil.resolveProject(project);
+        ClassDescriptor classDescriptor = DescriptorUtilPackage.resolveTopLevelClass(module, new FqName(qualifiedName));
+        assertNotNull("Class descriptor wasn't resolved: " + qualifiedName, classDescriptor);
+        PsiClass psiClass = (PsiClass) DescriptorToSourceUtils.classDescriptorToDeclaration(classDescriptor);
+        assertNotNull("Class declaration wasn't found: " + classDescriptor, psiClass);
+        return psiClass;
     }
 
     @NotNull

compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve.lazy;
 
 import com.google.common.base.Predicates;
 import com.google.common.collect.Sets;
+import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
@@ -33,6 +34,7 @@ import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
@@ -42,27 +44,31 @@ public class LazyResolveTestUtil {
     private LazyResolveTestUtil() {
     }
 
-    public static ModuleDescriptor resolve(List<JetFile> files, JetCoreEnvironment environment) {
-        return doResolve(files, environment);
+    @NotNull
+    public static ModuleDescriptor resolveProject(@NotNull Project project) {
+        return resolve(project, Collections.<JetFile>emptyList());
     }
 
-    private static ModuleDescriptor doResolve(List<JetFile> files, JetCoreEnvironment environment) {
+    @NotNull
+    public static ModuleDescriptor resolve(@NotNull Project project, @NotNull List<JetFile> sourceFiles) {
+        return resolve(project, new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), sourceFiles);
+    }
+
+    @NotNull
+    public static ModuleDescriptor resolve(@NotNull Project project, @NotNull BindingTrace trace, @NotNull List<JetFile> sourceFiles) {
+        ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
+
         GlobalContextImpl globalContext = ContextPackage.GlobalContext();
         TopDownAnalysisParameters params = TopDownAnalysisParameters.create(
                 globalContext.getStorageManager(),
                 globalContext.getExceptionTracker(),
                 Predicates.<PsiFile>alwaysTrue(),
-                false, false);
-        BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-        ModuleDescriptorImpl sharedModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
+                false, false
+        );
 
-        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
-                environment.getProject(),
-                files,
-                trace,
-                params, sharedModule);
+        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(project, sourceFiles, trace, params, module);
 
-        return sharedModule;
+        return module;
     }
 
     @NotNull

compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java

@@ -444,7 +444,7 @@ public class JetTestUtils {
                 }
             }
         }
-        LazyResolveTestUtil.resolve(jetFiles, environment);
+        LazyResolveTestUtil.resolve(environment.getProject(), jetFiles);
     }
 
     public static void assertEqualsToFile(@NotNull File expectedFile, @NotNull String actual) {

compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java

@@ -21,14 +21,11 @@ import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava;
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJavaUtil;
 import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.JetExpression;
@@ -578,8 +575,8 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 
     private WritableScope getDeclarationsScope(String path) throws IOException {
         ModuleDescriptor moduleDescriptor = LazyResolveTestUtil.resolve(
-                Collections.singletonList(JetTestUtils.loadJetFile(getProject(), new File(path))),
-                getEnvironment()
+                getProject(),
+                Collections.singletonList(JetTestUtils.loadJetFile(getProject(), new File(path)))
         );
 
         FqName fqName = new FqName("testData");
@@ -591,10 +588,9 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     @SuppressWarnings("ConstantConditions")
     private WritableScopeImpl addImports(JetScope scope) {
         WritableScopeImpl writableScope = new WritableScopeImpl(
-                scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports");
-        BindingTraceContext trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-        InjectorForLazyResolveWithJava injector = InjectorForLazyResolveWithJavaUtil.create(getProject(), trace, true);
-        ModuleDescriptor module = injector.getModule();
+                scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports"
+        );
+        ModuleDescriptor module = LazyResolveTestUtil.resolveProject(getProject());
         for (ImportPath defaultImport : module.getDefaultImports()) {
             FqName fqName = defaultImport.fqnPart();
             if (defaultImport.isAllUnder()) {

generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt

@@ -156,7 +156,7 @@ private fun generatorForLazyResolveWithJava() =
                                          + ".SERVICE.getInstance(project).create(moduleContentScope)")
             )
 
-            publicField<JavaClassFinderImpl>()
+            field<JavaClassFinderImpl>()
             field<TraceBasedExternalSignatureResolver>()
             field<LazyResolveBasedCache>()
             field<TraceBasedErrorReporter>()