diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java index f6c96d6b9d4..c80374fc0ea 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java +++ b/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; - } - } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJavaUtil.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJavaUtil.java deleted file mode 100644 index 93c3285cf90..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJavaUtil.java +++ /dev/null @@ -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(""); - - GlobalSearchScope moduleContentScope = GlobalSearchScope.allScope(project); - GlobalContextImpl globalContext = ContextPackage.GlobalContext(); - DeclarationProviderFactory declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory( - project, globalContext.getStorageManager(), Collections.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; - } -} diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java index 29771d305ce..17d3312ebfe 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java +++ b/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.emptyList() + ); AlternativeSignatureErrorFindingVisitor visitor = new AlternativeSignatureErrorFindingVisitor(trace.getBindingContext(), errors); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java index b53dcd3a384..7172a921f39 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java +++ b/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.emptyList()); + + PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); assert packageView != null; return Pair.create(packageView, trace.getBindingContext()); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java index 3a67dee6d9a..3c03790db27 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java +++ b/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); } diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java index aa3ee9e14c4..8ee6bf55c02 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java +++ b/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 diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java index c87af37f605..3bd72d50cab 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java +++ b/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 files, JetCoreEnvironment environment) { - return doResolve(files, environment); + @NotNull + public static ModuleDescriptor resolveProject(@NotNull Project project) { + return resolve(project, Collections.emptyList()); } - private static ModuleDescriptor doResolve(List files, JetCoreEnvironment environment) { + @NotNull + public static ModuleDescriptor resolve(@NotNull Project project, @NotNull List sourceFiles) { + return resolve(project, new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), sourceFiles); + } + + @NotNull + public static ModuleDescriptor resolve(@NotNull Project project, @NotNull BindingTrace trace, @NotNull List sourceFiles) { + ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule(); + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); TopDownAnalysisParameters params = TopDownAnalysisParameters.create( globalContext.getStorageManager(), globalContext.getExceptionTracker(), Predicates.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 diff --git a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java index 6d6ed0b79cc..33193141267 100644 --- a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java +++ b/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) { diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java index abbfa514a88..c8b60a2a2bd 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java +++ b/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()) { diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index 7bbedf82f0a..ba9dae8d548 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -156,7 +156,7 @@ private fun generatorForLazyResolveWithJava() = + ".SERVICE.getInstance(project).create(moduleContentScope)") ) - publicField() + field() field() field() field()