From 571f3c8524a1d329b64376c461aa7cb6c27c1ac3 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 22 Aug 2014 22:13:33 +0400 Subject: [PATCH] LTDA: Initialize project components with resolve session after injector construction is finished --- .../CliLightClassGenerationSupport.java | 119 +++++++++--------- .../cli/jvm/compiler/JetCoreEnvironment.java | 2 + .../compiler/KotlinToJVMBytecodeCompiler.java | 13 +- .../di/InjectorForJavaDescriptorResolver.java | 10 ++ ...InjectorForJavaDescriptorResolverUtil.java | 1 + .../di/InjectorForLazyResolveWithJava.java | 10 ++ .../di/InjectorForTopDownAnalyzerForJvm.java | 10 ++ .../resolve/java/JavaClassFinderImpl.java | 5 + .../java/JavaClassFinderPostConstruct.kt | 60 +++++++++ .../java/TopDownAnalyzerFacadeForJVM.java | 25 ++-- .../lang/resolve/CodeAnalyzerInitializer.kt | 39 ++++++ .../jet/lang/resolve/LazyTopDownAnalyzer.java | 5 - .../tests/org/jetbrains/jet/JetTestUtils.java | 5 - .../checkers/AbstractJetDiagnosticsTest.java | 60 +++------ .../jvm/compiler/AbstractLoadJavaTest.java | 9 +- .../jet/jvm/compiler/LoadDescriptorUtil.java | 1 - .../jet/lang/resolve/lazy/JvmResolveUtil.java | 13 +- .../resolve/lazy/LazyResolveTestUtil.java | 22 +--- .../generators/injectors/GenerateInjectors.kt | 11 +- .../caches/resolve/KotlinResolveCache.kt | 2 - idea/src/META-INF/plugin.xml | 3 + 21 files changed, 263 insertions(+), 162 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderPostConstruct.kt create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/CodeAnalyzerInitializer.kt diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java index 6d03e32382e..2fcac6590cf 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.cli.jvm.compiler; import com.google.common.base.Predicate; import com.google.common.collect.Collections2; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.components.ServiceManager; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiClass; @@ -29,25 +30,21 @@ import com.intellij.util.SmartList; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.annotations.TestOnly; import org.jetbrains.jet.asJava.KotlinLightClassForExplicitDeclaration; import org.jetbrains.jet.asJava.LightClassConstructionContext; import org.jetbrains.jet.asJava.LightClassGenerationSupport; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils; +import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.JvmAbi; -import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.jet.util.slicedmap.ReadOnlySlice; import org.jetbrains.jet.util.slicedmap.WritableSlice; import java.util.Collection; @@ -66,60 +63,40 @@ import java.util.List; * * To mitigate this, CliLightClassGenerationSupport hold a trace that is shared between the analyzer and JetLightClasses */ -public class CliLightClassGenerationSupport extends LightClassGenerationSupport { - +public class CliLightClassGenerationSupport extends LightClassGenerationSupport implements CodeAnalyzerInitializer { public static CliLightClassGenerationSupport getInstanceForCli(@NotNull Project project) { return ServiceManager.getService(project, CliLightClassGenerationSupport.class); } - private BindingTrace trace; - private ModuleDescriptorImpl module; + private BindingContext bindingContext = null; + private ModuleDescriptor module = null; public CliLightClassGenerationSupport() { } - @NotNull - public BindingTrace getTrace() { - if (trace == null) { - trace = new BindingTraceContextWithoutScopeRecording(); - } - return trace; - } - - @NotNull - public ModuleDescriptorImpl newModule() { - assert this.module == null : "module already configured: " + module; - module = TopDownAnalyzerFacadeForJVM.createJavaModule(""); - module.addDependencyOnModule(module); - module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); - module.seal(); - return module; - } - - @NotNull - private ModuleDescriptorImpl getModule() { - if (module == null) { - return newModule(); - } - return module; - } - - @TestOnly - @Nullable - public ModuleDescriptorImpl getLightClassModule() { - return module; - } - - @TestOnly - public void setModule(@NotNull ModuleDescriptorImpl module) { - assert this.module == null : "module already configured: " + module; + @Override + public void initialize(@NotNull BindingTrace trace, @NotNull ModuleDescriptor module, @Nullable KotlinCodeAnalyzer analyzer) { + this.bindingContext = trace.getBindingContext(); this.module = module; + + if (trace instanceof CliBindingTrace) { + ((CliBindingTrace) trace).setKotlinCodeAnalyzer(analyzer); + } + else { + assert ApplicationManager.getApplication().isUnitTestMode(); + } } - @TestOnly - public void newBindingTrace() { - trace = null; - module = null; + @NotNull + private BindingContext getBindingContext() { + assert bindingContext != null : "Call initialize() first"; + return bindingContext; + } + + @NotNull + private ModuleDescriptor getModule() { + assert module != null : "Call initialize() first"; + return module; } @NotNull @@ -136,13 +113,13 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport @NotNull private LightClassConstructionContext getContext() { - return new LightClassConstructionContext(getTrace().getBindingContext(), getModule()); + return new LightClassConstructionContext(bindingContext, getModule()); } @NotNull @Override public Collection findClassOrObjectDeclarations(@NotNull FqName fqName, @NotNull GlobalSearchScope searchScope) { - ClassDescriptor classDescriptor = getTrace().get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, fqName.toUnsafe()); + ClassDescriptor classDescriptor = getBindingContext().get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, fqName.toUnsafe()); if (classDescriptor != null) { PsiElement element = DescriptorToSourceUtils.classDescriptorToDeclaration(classDescriptor); if (element != null && PsiSearchScopeUtil.isInScope(searchScope, element)) { @@ -174,7 +151,7 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport @NotNull @Override public Collection findFilesForPackage(@NotNull FqName fqName, @NotNull final GlobalSearchScope searchScope) { - Collection files = getTrace().get(BindingContext.PACKAGE_TO_FILES, fqName); + Collection files = getBindingContext().get(BindingContext.PACKAGE_TO_FILES, fqName); if (files != null) { return Collections2.filter(files, new Predicate() { @Override @@ -240,7 +217,13 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport return KotlinLightClassForExplicitDeclaration.create(classOrObject.getManager(), classOrObject); } - public static class BindingTraceContextWithoutScopeRecording extends BindingTraceContext { + public static BindingTrace createTrace() { + return new CliBindingTrace(); + } + + public static class CliBindingTrace extends BindingTraceContext { + private KotlinCodeAnalyzer kotlinCodeAnalyzer; + @Override public void record(WritableSlice slice, K key, V value) { if (slice == BindingContext.RESOLUTION_SCOPE || slice == BindingContext.TYPE_RESOLUTION_SCOPE) { @@ -252,7 +235,31 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport @Override public String toString() { - return "Filtering trace for the CLI compiler: does not save scopes"; + return CliBindingTrace.class.getName(); + } + + public void setKotlinCodeAnalyzer(KotlinCodeAnalyzer kotlinCodeAnalyzer) { + this.kotlinCodeAnalyzer = kotlinCodeAnalyzer; + } + + @Override + public V get(ReadOnlySlice slice, K key) { + V value = super.get(slice, key); + + if (value == null) { + if (BindingContext.FUNCTION == slice || BindingContext.VARIABLE == slice) { + if (key instanceof JetDeclaration) { + JetDeclaration jetDeclaration = (JetDeclaration) key; + if (!JetPsiUtil.isLocal(jetDeclaration)) { + kotlinCodeAnalyzer.resolveToDescriptor(jetDeclaration); + } + } + } + + return super.get(slice, key); + } + + return value; } } } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java index 3ba7eb2485b..c4dd0e3ae6c 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java @@ -53,6 +53,7 @@ import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.parsing.JetParserDefinition; import org.jetbrains.jet.lang.parsing.JetScriptDefinitionProvider; import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.CodeAnalyzerInitializer; import org.jetbrains.jet.lang.resolve.DiagnosticsWithSuppression; import org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinderFactory; @@ -236,6 +237,7 @@ public class JetCoreEnvironment { CliLightClassGenerationSupport cliLightClassGenerationSupport = new CliLightClassGenerationSupport(); project.registerService(LightClassGenerationSupport.class, cliLightClassGenerationSupport); project.registerService(CliLightClassGenerationSupport.class, cliLightClassGenerationSupport); + project.registerService(CodeAnalyzerInitializer.class, cliLightClassGenerationSupport); Extensions.getArea(project) .getExtensionPoint(PsiElementFinder.EP_NAME) .registerExtension(new JavaElementFinder(project, cliLightClassGenerationSupport)); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index a9ad9b30f58..aaf0ed62b2b 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -282,23 +282,24 @@ public class KotlinToJVMBytecodeCompiler { @Nullable private static AnalysisResult analyze(@NotNull final JetCoreEnvironment environment) { - AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport( - environment.getConfiguration().get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)); + MessageCollector collector = environment.getConfiguration().get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY); + assert collector != null; + + AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(collector); analyzerWithCompilerReport.analyzeAndReport( environment.getSourceFiles(), new Function0() { @NotNull @Override public AnalysisResult invoke() { - CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); - BindingTrace sharedTrace = support.getTrace(); - ModuleDescriptorImpl sharedModule = support.newModule(); + BindingTrace sharedTrace = CliLightClassGenerationSupport.createTrace(); + ModuleDescriptorImpl analyzeModule = TopDownAnalyzerFacadeForJVM.createAnalyzeModule(); return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( environment.getProject(), environment.getSourceFiles(), sharedTrace, Predicates.alwaysTrue(), - sharedModule, + analyzeModule, environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS), environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_CACHE_PROVIDER) ); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index d130b2261d8..a7352742b8f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitialize import org.jetbrains.jet.lang.resolve.java.sam.SamConversionResolverImpl; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl; import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolverPostConstruct; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext; @@ -64,6 +65,7 @@ public class InjectorForJavaDescriptorResolver { private final SamConversionResolverImpl samConversionResolver; private final JavaSourceElementFactoryImpl javaSourceElementFactory; private final SingleModuleClassResolver singleModuleClassResolver; + private final JavaDescriptorResolverPostConstruct javaDescriptorResolverPostConstruct; private final VirtualFileFinder virtualFileFinder; private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; @@ -97,10 +99,12 @@ public class InjectorForJavaDescriptorResolver { this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule()); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule()); this.globalSearchScope = com.intellij.psi.search.GlobalSearchScope.allScope(project); + this.javaDescriptorResolverPostConstruct = new JavaDescriptorResolverPostConstruct(); this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver); this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), lockBasedStorageManager, virtualFileFinder, traceBasedErrorReporter); this.deserializationComponentsForJava = new DeserializationComponentsForJava(lockBasedStorageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider); + this.javaClassFinder.setComponentPostConstruct(javaDescriptorResolverPostConstruct); this.javaClassFinder.setProject(project); this.javaClassFinder.setScope(globalSearchScope); @@ -117,10 +121,16 @@ public class InjectorForJavaDescriptorResolver { singleModuleClassResolver.setResolver(javaDescriptorResolver); + javaDescriptorResolverPostConstruct.setModule(module); + javaDescriptorResolverPostConstruct.setProject(project); + javaDescriptorResolverPostConstruct.setTrace(bindingTrace); + deserializedDescriptorResolver.setComponents(deserializationComponentsForJava); javaClassFinder.initialize(); + javaDescriptorResolverPostConstruct.postCreate(); + } @PreDestroy diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java index ab14c2a4d43..a9be27bb089 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java @@ -37,6 +37,7 @@ public class InjectorForJavaDescriptorResolverUtil { module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); } module.seal(); + return injector; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index d73b1003814..b17a608d093 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.java.sam.SamConversionResolverImpl; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl; import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.context.LazyResolveToken; +import org.jetbrains.jet.lang.resolve.java.JavaLazyAnalyzerPostConstruct; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -98,6 +99,7 @@ public class InjectorForLazyResolveWithJava { private final JavaSourceElementFactoryImpl javaSourceElementFactory; private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider; private final LazyResolveToken lazyResolveToken; + private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct; private final AdditionalCheckerProvider additionalCheckerProvider; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -163,6 +165,7 @@ public class InjectorForLazyResolveWithJava { this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module); this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.lazyResolveToken = new LazyResolveToken(); + this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -198,6 +201,7 @@ public class InjectorForLazyResolveWithJava { this.resolveSession.setScriptBodyResolver(scriptBodyResolver); this.resolveSession.setTypeResolver(typeResolver); + javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct); javaClassFinder.setProject(project); javaClassFinder.setScope(moduleContentScope); @@ -212,6 +216,10 @@ public class InjectorForLazyResolveWithJava { psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); + javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession); + javaLazyAnalyzerPostConstruct.setProject(project); + javaLazyAnalyzerPostConstruct.setTrace(bindingTrace); + annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); annotationResolver.setTypeResolver(typeResolver); @@ -270,6 +278,8 @@ public class InjectorForLazyResolveWithJava { javaClassFinder.initialize(); + javaLazyAnalyzerPostConstruct.postCreate(); + } @PreDestroy diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 2d876b59e11..e85c02a3757 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitialize import org.jetbrains.jet.lang.resolve.java.sam.SamConversionResolverImpl; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl; import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver; +import org.jetbrains.jet.lang.resolve.java.JavaLazyAnalyzerPostConstruct; import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.BodyResolver; @@ -108,6 +109,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final SamConversionResolverImpl samConversionResolver; private final JavaSourceElementFactoryImpl javaSourceElementFactory; private final SingleModuleClassResolver singleModuleClassResolver; + private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct; private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider; private final AdditionalCheckerProvider additionalCheckerProvider; private final BodyResolver bodyResolver; @@ -184,6 +186,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver); this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter); this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider); + this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct(); this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; this.bodyResolver = new BodyResolver(); @@ -235,6 +238,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.resolveSession.setScriptBodyResolver(scriptBodyResolver); this.resolveSession.setTypeResolver(typeResolver); + javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct); javaClassFinder.setProject(project); javaClassFinder.setScope(moduleContentScope); @@ -251,6 +255,10 @@ public class InjectorForTopDownAnalyzerForJvm { singleModuleClassResolver.setResolver(javaDescriptorResolver); + javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession); + javaLazyAnalyzerPostConstruct.setProject(project); + javaLazyAnalyzerPostConstruct.setTrace(bindingTrace); + bodyResolver.setAnnotationResolver(annotationResolver); bodyResolver.setCallResolver(callResolver); bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); @@ -341,6 +349,8 @@ public class InjectorForTopDownAnalyzerForJvm { javaClassFinder.initialize(); + javaLazyAnalyzerPostConstruct.postCreate(); + } @PreDestroy diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java index 9f0253c467f..b897ccd3d15 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java @@ -53,6 +53,11 @@ public class JavaClassFinderImpl implements JavaClassFinder { this.baseScope = scope; } + @Inject + public void setComponentPostConstruct(@NotNull JavaClassFinderPostConstruct finderPostConstruct) { + // Only activate post create + } + @PostConstruct public void initialize() { javaSearchScope = new DelegatingGlobalSearchScope(baseScope) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderPostConstruct.kt b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderPostConstruct.kt new file mode 100644 index 00000000000..a9af2e1e38d --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderPostConstruct.kt @@ -0,0 +1,60 @@ +/* + * 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. + * 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.jet.lang.resolve.java + +import com.intellij.openapi.project.Project +import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor +import javax.inject.Inject +import javax.annotation.PostConstruct +import org.jetbrains.jet.lang.resolve.BindingTrace +import org.jetbrains.jet.lang.resolve.CodeAnalyzerInitializer + +public open class JavaClassFinderPostConstruct { + PostConstruct public open fun postCreate() {} +} + +public class JavaLazyAnalyzerPostConstruct : JavaClassFinderPostConstruct() { + public var project: Project? = null + [Inject] set + + public var trace: BindingTrace? = null + [Inject] set + + public var codeAnalyzer: KotlinCodeAnalyzer? = null + [Inject] set + + [PostConstruct] override fun postCreate() { + CodeAnalyzerInitializer.getInstance(project!!).initialize(trace!!, codeAnalyzer!!.getModuleDescriptor(), codeAnalyzer) + } +} + +public class JavaDescriptorResolverPostConstruct : JavaClassFinderPostConstruct() { + public var project: Project? = null + [Inject] set + + public var trace: BindingTrace? = null + [Inject] set + + public var module: ModuleDescriptor? = null + [Inject] set + + [PostConstruct] override fun postCreate() { + CodeAnalyzerInitializer.getInstance(project!!).initialize(trace!!, module!!, null) + } +} + diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java index 94a578e31af..cbe1bc5d007 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java @@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.incremental.cache.IncrementalCache; import org.jetbrains.jet.lang.resolve.kotlin.incremental.cache.IncrementalCacheProvider; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.storage.LockBasedStorageManager; import java.util.ArrayList; @@ -68,11 +69,7 @@ public enum TopDownAnalyzerFacadeForJVM { @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull ModuleDescriptorImpl module ) { - GlobalContext globalContext = new GlobalContextImpl( - (LockBasedStorageManager) topDownAnalysisParameters.getStorageManager(), - topDownAnalysisParameters.getExceptionTracker()); - - return analyzeFilesWithJavaIntegration(project, files, trace, topDownAnalysisParameters, module, globalContext, null, null); + return analyzeFilesWithJavaIntegration(project, files, trace, topDownAnalysisParameters, module, null, null); } @NotNull @@ -112,7 +109,7 @@ public enum TopDownAnalyzerFacadeForJVM { return analyzeFilesWithJavaIntegration( project, files, trace, topDownAnalysisParameters, module, - globalContext, moduleIds, incrementalCacheProvider); + moduleIds, incrementalCacheProvider); } @NotNull @@ -122,7 +119,6 @@ public enum TopDownAnalyzerFacadeForJVM { BindingTrace trace, TopDownAnalysisParameters topDownAnalysisParameters, ModuleDescriptorImpl module, - GlobalContext globalContext, @Nullable List moduleIds, @Nullable IncrementalCacheProvider incrementalCacheProvider ) { @@ -131,7 +127,7 @@ public enum TopDownAnalyzerFacadeForJVM { InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( project, - globalContext, + topDownAnalysisParameters, trace, module, GlobalSearchScope.allScope(project), @@ -166,6 +162,17 @@ public enum TopDownAnalyzerFacadeForJVM { @NotNull public static ModuleDescriptorImpl createJavaModule(@NotNull String name) { - return new ModuleDescriptorImpl(Name.special(name), DEFAULT_IMPORTS, JavaToKotlinClassMap.getInstance()); + return new ModuleDescriptorImpl(Name.special(name), + DEFAULT_IMPORTS, + JavaToKotlinClassMap.getInstance()); + } + + @NotNull + public static ModuleDescriptorImpl createAnalyzeModule() { + ModuleDescriptorImpl module = createJavaModule(""); + module.addDependencyOnModule(module); + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); + return module; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CodeAnalyzerInitializer.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CodeAnalyzerInitializer.kt new file mode 100644 index 00000000000..83462b9c65a --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CodeAnalyzerInitializer.kt @@ -0,0 +1,39 @@ +/* + * 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. + * 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.jet.lang.resolve + +import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer +import kotlin.platform.platformStatic +import com.intellij.openapi.project.Project +import com.intellij.openapi.components.ServiceManager +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor +import javax.annotation.PostConstruct + +public trait CodeAnalyzerInitializer { + public fun initialize(trace: BindingTrace, module: ModuleDescriptor, codeAnalyzer: KotlinCodeAnalyzer?) + + class object { + public fun getInstance(project: Project): CodeAnalyzerInitializer = + ServiceManager.getService(project, javaClass())!! + } +} + +public class DummyCodeAnalyzerInitializer: CodeAnalyzerInitializer { + public override fun initialize(trace: BindingTrace, module: ModuleDescriptor, codeAnalyzer: KotlinCodeAnalyzer?) { + // Do nothing + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java index 403c308a8d6..42590dfef88 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java @@ -24,8 +24,6 @@ import com.intellij.psi.util.PsiTreeUtil; import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.context.GlobalContextImpl; -import org.jetbrains.jet.di.InjectorForLazyResolve; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; @@ -33,11 +31,8 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.CallsPackage; import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.jet.lang.resolve.lazy.LazyImportScope; -import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.storage.LockBasedStorageManager; import javax.inject.Inject; import java.util.ArrayList; diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index dac36402df3..a987ed71b7d 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -416,11 +416,6 @@ public class JetTestUtils { return configuration; } - public static void newTrace(@NotNull JetCoreEnvironment environment) { - // let the next analysis use another trace - CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).newBindingTrace(); - } - public static void resolveAllKotlinFiles(JetCoreEnvironment environment) throws IOException { List paths = environment.getConfiguration().get(CommonConfigurationKeys.SOURCE_ROOTS_KEY); if (paths == null) return; diff --git a/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java index 51686fc5969..9d0993c79e6 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java @@ -32,8 +32,6 @@ import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.context.SimpleGlobalContext; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; -import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.diagnostics.*; @@ -86,9 +84,6 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { } ); - CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(getProject()); - BindingTrace supportTrace = support.getTrace(); - List allJetFiles = new ArrayList(); Map modules = createModules(groupedByModule); Map moduleBindings = new HashMap(); @@ -103,19 +98,9 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { allJetFiles.addAll(jetFiles); ModuleDescriptorImpl module = modules.get(testModule); - BindingTrace moduleTrace = groupedByModule.size() > 1 - ? new DelegatingBindingTrace(supportTrace.getBindingContext(), "Trace for module " + module) - : supportTrace; - moduleBindings.put(testModule, moduleTrace.getBindingContext()); + BindingTrace moduleTrace = CliLightClassGenerationSupport.createTrace(); - if (module == null) { - module = support.newModule(); - modules.put(entry.getKey(), module); - } - else { - module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); - module.seal(); - } + moduleBindings.put(testModule, moduleTrace.getBindingContext()); ExceptionTracker tracker = new ExceptionTracker(); GlobalContext context = new SimpleGlobalContext( @@ -149,7 +134,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { Throwable exceptionFromDescriptorValidation = null; try { File expectedFile = new File(FileUtil.getNameWithoutExtension(testDataFile.getAbsolutePath()) + ".txt"); - validateAndCompareDescriptorWithFile(expectedFile, testFiles, support, modules); + validateAndCompareDescriptorWithFile(expectedFile, testFiles, modules); } catch (Throwable e) { exceptionFromDescriptorValidation = e; @@ -167,8 +152,6 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { assertTrue("Diagnostics mismatch. See the output above", ok); - checkAllResolvedCallsAreCompleted(allJetFiles, supportTrace.getBindingContext()); - // now we throw a previously found error, if any if (exceptionFromDescriptorValidation != null) { throw UtilsPackage.rethrow(exceptionFromDescriptorValidation); @@ -246,28 +229,8 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { private void validateAndCompareDescriptorWithFile( File expectedFile, List testFiles, - CliLightClassGenerationSupport support, Map modules ) { - ModuleDescriptorImpl lightClassModule = support.getLightClassModule(); - if (lightClassModule == null) { - ModuleDescriptorImpl cliModule = support.newModule(); - cliModule.initialize(new PackageFragmentProvider() { - @NotNull - @Override - public List getPackageFragments(@NotNull FqName fqName) { - return Collections.emptyList(); - } - - @NotNull - @Override - public Collection getSubPackagesOf( - @NotNull FqName fqName, @NotNull Function1 nameFilter) { - return Collections.emptyList(); - } - }); - } - RecursiveDescriptorComparator comparator = new RecursiveDescriptorComparator(createdAffectedPackagesConfiguration(testFiles)); boolean isMultiModuleTest = modules.size() != 1; @@ -275,13 +238,13 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { for (TestModule module : KotlinPackage.sort(modules.keySet())) { ModuleDescriptorImpl moduleDescriptor = modules.get(module); + DeclarationDescriptor aPackage = moduleDescriptor.getPackage(FqName.ROOT); + assertNotNull(aPackage); + if (isMultiModuleTest) { rootPackageText.append(String.format("// -- Module: %s --\n", moduleDescriptor.getName())); } - DeclarationDescriptor aPackage = moduleDescriptor.getPackage(FqName.ROOT); - assertNotNull(aPackage); - String actualSerialized = comparator.serializeRecursively(aPackage); rootPackageText.append(actualSerialized); @@ -319,8 +282,11 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { Map modules = new HashMap(); for (TestModule testModule : groupedByModule.keySet()) { - if (testModule == null) continue; - ModuleDescriptorImpl module = createModule(testModule); + ModuleDescriptorImpl module = + testModule == null ? + TopDownAnalyzerFacadeForJVM.createAnalyzeModule() : + createModule(testModule); + modules.put(testModule, module); } @@ -332,7 +298,11 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { for (TestModule dependency : testModule.getDependencies()) { module.addDependencyOnModule(modules.get(dependency)); } + + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); + module.seal(); } + return modules; } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index bcdd112427c..5a825fefd01 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -145,10 +145,8 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File("compiler/tests")); // for @ExpectLoadError annotation JetCoreEnvironment environment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); - // we need the same binding trace for resolve from Java and Kotlin - CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); - BindingTrace trace = support.getTrace(); - ModuleDescriptorImpl module = support.newModule(); + BindingTrace trace = CliLightClassGenerationSupport.createTrace(); + ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createAnalyzeModule(); TopDownAnalysisParameters parameters = TopDownAnalysisParameters.create( new LockBasedStorageManager(), @@ -163,8 +161,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { environment.getSourceFiles(), trace, parameters, - module - ); + module); PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); assert packageView != null : "Test package not found"; diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index b42b3efb3a5..20e1ab99115 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -95,7 +95,6 @@ public final class LoadDescriptorUtil { InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace, true); ModuleDescriptorImpl module = injector.getModule(); - CliLightClassGenerationSupport.getInstanceForCli(jetCoreEnvironment.getProject()).setModule(module); PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); assert packageView != null; diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java index 11246036493..97857479f05 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; +import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -74,17 +75,15 @@ public class JvmResolveUtil { @NotNull Collection files, @NotNull Predicate filesToAnalyzeCompletely ) { - BindingTraceContext bindingTraceContext = new BindingTraceContext(); - ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createJavaModule(""); module.addDependencyOnModule(module); module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()); module.seal(); + CliLightClassGenerationSupport lightClassGenerationSupport = CliLightClassGenerationSupport.getInstanceForCli(project); - if (lightClassGenerationSupport != null) { - lightClassGenerationSupport.setModule(module); - } - return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, filesToAnalyzeCompletely, - module, null, null); + BindingTrace trace = lightClassGenerationSupport != null ? CliLightClassGenerationSupport.createTrace() : new BindingTraceContext(); + + return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( + project, files, trace, filesToAnalyzeCompletely, module, null, null); } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index 168ff66822e..c32f0c42a8c 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -18,10 +18,8 @@ package org.jetbrains.jet.lang.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.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.context.ContextPackage; @@ -49,22 +47,19 @@ public class LazyResolveTestUtil { } private static ModuleDescriptor doResolve(List files, JetCoreEnvironment environment) { - JetTestUtils.newTrace(environment); - GlobalContextImpl globalContext = ContextPackage.GlobalContext(); TopDownAnalysisParameters params = TopDownAnalysisParameters.create( globalContext.getStorageManager(), globalContext.getExceptionTracker(), Predicates.alwaysTrue(), false, false); - CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); - BindingTrace sharedTrace = support.getTrace(); - ModuleDescriptorImpl sharedModule = support.newModule(); + BindingTrace trace = CliLightClassGenerationSupport.createTrace(); + ModuleDescriptorImpl sharedModule = TopDownAnalyzerFacadeForJVM.createAnalyzeModule(); TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( environment.getProject(), - files, - sharedTrace, + files, + trace, params, sharedModule); return sharedModule; @@ -76,14 +71,7 @@ public class LazyResolveTestUtil { @NotNull JetCoreEnvironment environment, boolean addBuiltIns ) { - JetTestUtils.newTrace(environment); - - Project project = environment.getProject(); - CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(project); - ResolveSession lazyResolveSession = createResolveSessionForFiles(project, files, addBuiltIns); - support.setModule((ModuleDescriptorImpl) lazyResolveSession.getModuleDescriptor()); - - return lazyResolveSession; + return createResolveSessionForFiles(environment.getProject(), files, addBuiltIns); } public static ModuleDescriptor resolveLazily(List files, JetCoreEnvironment environment) { diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 481fee8293a..df4aab1f919 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -45,6 +45,8 @@ import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider import org.jetbrains.jet.context.LazyResolveToken +import org.jetbrains.jet.lang.resolve.java.JavaLazyAnalyzerPostConstruct +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolverPostConstruct // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -172,8 +174,9 @@ private fun generatorForTopDownAnalyzerForJvm() = javaClass(), javaClass(), javaClass(), - javaClass(), javaClass(), + javaClass(), + javaClass(), javaClass() ) @@ -209,7 +212,8 @@ private fun generatorForJavaDescriptorResolver() = javaClass(), javaClass(), javaClass(), - javaClass() + javaClass(), + javaClass() ) field(javaClass(), init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) @@ -247,7 +251,8 @@ private fun generatorForLazyResolveWithJava() = javaClass(), javaClass(), javaClass(), - javaClass() + javaClass(), + javaClass() ) field(javaClass(), init = GivenExpression(javaClass().getName() + ".INSTANCE$")) diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt index 58a9a8f3216..773606c428c 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt @@ -247,8 +247,6 @@ private object KotlinResolveDataProvider { TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile()).getAdditionalCheckerProvider() ).getLazyTopDownAnalyzer()!! - lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession); - lazyTopDownAnalyzer.analyzeDeclarations( TopDownAnalysisParameters.createForLazy( resolveSession.getStorageManager(), diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index 38a72dd99ca..e2625ba1e09 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -158,6 +158,9 @@ + +