From 23c6498e1e075e1c89858e40ab47e536c6b58f04 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 19 Sep 2014 13:24:15 +0400 Subject: [PATCH] LTDA: Injector with lazy TDA for JVM target - REPL is broken - Tests for Kotlin - Java - Kotlin hierarchy may fail --- .../jet/cli/jvm/repl/ReplInterpreter.java | 6 +- .../di/InjectorForTopDownAnalyzerForJvm.java | 121 ++++++++---------- .../java/TopDownAnalyzerFacadeForJVM.java | 29 ++++- .../jet/di/InjectorForLazyBodyResolve.java | 5 +- .../di/InjectorForTopDownAnalyzerBasic.java | 15 --- .../jet/lang/resolve/LazyTopDownAnalyzer.java | 38 ++---- .../jet/lang/resolve/TopDownAnalyzer.java | 14 +- .../lang/resolve/lazy/KotlinCodeAnalyzer.java | 8 +- .../jet/lang/resolve/lazy/ResolveSession.java | 1 + .../generators/injectors/GenerateInjectors.kt | 40 ++++-- .../project/ResolveSessionForBodies.java | 11 +- .../references/BuiltInsReferenceResolver.java | 2 + .../di/InjectorForTopDownAnalyzerForJs.java | 15 --- 13 files changed, 140 insertions(+), 165 deletions(-) diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index 2878b19f45e..72dc9a17c70 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -106,9 +106,11 @@ public class ReplInterpreter { new ExceptionTracker(), // dummy Predicates.alwaysTrue() ); - InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module); + + // FIXME: Make it work for lazy resolve + InjectorForTopDownAnalyzerForJvm injector = null; this.topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters); - this.topDownAnalyzer = injector.getTopDownAnalyzer(); + this.topDownAnalyzer = null; module.initialize(new CompositePackageFragmentProvider( Arrays.asList( 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 4d590b5c3eb..2d876b59e11 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -20,18 +20,18 @@ import com.intellij.openapi.project.Project; import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import com.intellij.psi.search.GlobalSearchScope; +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.DeserializationComponentsForJava; -import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; -import com.intellij.psi.search.GlobalSearchScope; +import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache; +import org.jetbrains.jet.lang.resolve.java.resolver.LazyResolveBasedCache; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter; import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker; import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; @@ -40,7 +40,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.lazy.SingleModuleClassResolver; import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider; -import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -72,8 +72,7 @@ import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.psi.JetImportsFactory; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; -import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; -import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; +import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext; import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; @@ -90,18 +89,18 @@ public class InjectorForTopDownAnalyzerForJvm { private final GlobalContext globalContext; private final StorageManager storageManager; private final BindingTrace bindingTrace; - private final ModuleDescriptor moduleDescriptor; + private final ModuleDescriptorImpl module; private final PlatformToKotlinClassMap platformToKotlinClassMap; - private final TopDownAnalyzer topDownAnalyzer; + private final GlobalSearchScope moduleContentScope; + private final DeclarationProviderFactory declarationProviderFactory; private final LazyTopDownAnalyzer lazyTopDownAnalyzer; - private final MutablePackageFragmentProvider mutablePackageFragmentProvider; + private final ResolveSession resolveSession; private final JavaDescriptorResolver javaDescriptorResolver; private final DeserializationComponentsForJava deserializationComponentsForJava; - private final AdditionalCheckerProvider additionalCheckerProvider; - private final GlobalSearchScope globalSearchScope; + private final VirtualFileFinder virtualFileFinder; private final JavaClassFinderImpl javaClassFinder; private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; - private final TraceBasedJavaResolverCache traceBasedJavaResolverCache; + private final LazyResolveBasedCache lazyResolveBasedCache; private final TraceBasedErrorReporter traceBasedErrorReporter; private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker; private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; @@ -110,7 +109,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final JavaSourceElementFactoryImpl javaSourceElementFactory; private final SingleModuleClassResolver singleModuleClassResolver; private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider; - private final VirtualFileFinder virtualFileFinder; + private final AdditionalCheckerProvider additionalCheckerProvider; private final BodyResolver bodyResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -142,8 +141,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final JetImportsFactory jetImportsFactory; private final OverloadResolver overloadResolver; private final OverrideResolver overrideResolver; - private final TypeHierarchyResolver typeHierarchyResolver; - private final ScriptHeaderResolver scriptHeaderResolver; + private final ScopeProvider scopeProvider; private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; private final DeserializedDescriptorResolver deserializedDescriptorResolver; @@ -154,38 +152,40 @@ public class InjectorForTopDownAnalyzerForJvm { @NotNull Project project, @NotNull GlobalContext globalContext, @NotNull BindingTrace bindingTrace, - @NotNull ModuleDescriptor moduleDescriptor + @NotNull ModuleDescriptorImpl module, + @NotNull GlobalSearchScope moduleContentScope, + @NotNull DeclarationProviderFactory declarationProviderFactory ) { this.project = project; this.globalContext = globalContext; this.storageManager = globalContext.getStorageManager(); this.bindingTrace = bindingTrace; - this.moduleDescriptor = moduleDescriptor; - this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); - this.topDownAnalyzer = new TopDownAnalyzer(); + this.module = module; + this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap(); + this.moduleContentScope = moduleContentScope; + this.declarationProviderFactory = declarationProviderFactory; this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); - this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); + this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace); this.javaClassFinder = new JavaClassFinderImpl(); - this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project); + this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope); this.traceBasedErrorReporter = new TraceBasedErrorReporter(); this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter); this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver(); this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver(); this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker(); - this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache(); + this.lazyResolveBasedCache = new LazyResolveBasedCache(); this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl(); this.samConversionResolver = SamConversionResolverImpl.INSTANCE$; this.javaSourceElementFactory = new JavaSourceElementFactoryImpl(); this.singleModuleClassResolver = new SingleModuleClassResolver(); - this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver); - this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor()); - this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor()); + this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver); + this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, module); + this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module); this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver); - this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModuleDescriptor(), storageManager, virtualFileFinder, traceBasedErrorReporter); - this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModuleDescriptor(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider); - this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; - this.globalSearchScope = com.intellij.psi.search.GlobalSearchScope.allScope(project); + this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter); + this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider); this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider(); + this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; this.bodyResolver = new BodyResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -195,13 +195,13 @@ public class InjectorForTopDownAnalyzerForJvm { this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); - this.reflectionTypes = new ReflectionTypes(getModuleDescriptor()); + this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); @@ -217,36 +217,32 @@ public class InjectorForTopDownAnalyzerForJvm { this.jetImportsFactory = new JetImportsFactory(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); - this.typeHierarchyResolver = new TypeHierarchyResolver(); - this.scriptHeaderResolver = new ScriptHeaderResolver(); - - this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider); - this.topDownAnalyzer.setBodyResolver(bodyResolver); - this.topDownAnalyzer.setDeclarationResolver(declarationResolver); - this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer); - this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); - this.topDownAnalyzer.setOverloadResolver(overloadResolver); - this.topDownAnalyzer.setOverrideResolver(overrideResolver); - this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); - this.topDownAnalyzer.setProject(project); - this.topDownAnalyzer.setTrace(bindingTrace); - this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); + this.scopeProvider = new ScopeProvider(getResolveSession()); this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver); - this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor); + this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession); + this.lazyTopDownAnalyzer.setModuleDescriptor(module); this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); this.lazyTopDownAnalyzer.setTrace(bindingTrace); + this.resolveSession.setAnnotationResolve(annotationResolver); + this.resolveSession.setDescriptorResolver(descriptorResolver); + this.resolveSession.setJetImportFactory(jetImportsFactory); + this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver); + this.resolveSession.setScopeProvider(scopeProvider); + this.resolveSession.setScriptBodyResolver(scriptBodyResolver); + this.resolveSession.setTypeResolver(typeResolver); + javaClassFinder.setProject(project); - javaClassFinder.setScope(globalSearchScope); + javaClassFinder.setScope(moduleContentScope); traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); traceBasedExternalSignatureResolver.setProject(project); traceBasedExternalSignatureResolver.setTrace(bindingTrace); - traceBasedJavaResolverCache.setTrace(bindingTrace); + lazyResolveBasedCache.setSession(resolveSession); traceBasedErrorReporter.setTrace(bindingTrace); @@ -331,7 +327,7 @@ public class InjectorForTopDownAnalyzerForJvm { declarationResolver.setTrace(bindingTrace); importsResolver.setImportsFactory(jetImportsFactory); - importsResolver.setModuleDescriptor(moduleDescriptor); + importsResolver.setModuleDescriptor(module); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); @@ -341,15 +337,6 @@ public class InjectorForTopDownAnalyzerForJvm { overrideResolver.setTrace(bindingTrace); - typeHierarchyResolver.setDescriptorResolver(descriptorResolver); - typeHierarchyResolver.setImportsResolver(importsResolver); - typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); - typeHierarchyResolver.setTrace(bindingTrace); - - scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - scriptHeaderResolver.setTrace(bindingTrace); - deserializedDescriptorResolver.setComponents(deserializationComponentsForJava); javaClassFinder.initialize(); @@ -360,18 +347,14 @@ public class InjectorForTopDownAnalyzerForJvm { public void destroy() { } - public ModuleDescriptor getModuleDescriptor() { - return this.moduleDescriptor; - } - - public TopDownAnalyzer getTopDownAnalyzer() { - return this.topDownAnalyzer; - } - public LazyTopDownAnalyzer getLazyTopDownAnalyzer() { return this.lazyTopDownAnalyzer; } + public ResolveSession getResolveSession() { + return this.resolveSession; + } + public JavaDescriptorResolver getJavaDescriptorResolver() { return this.javaDescriptorResolver; } 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 ab073744f3c..94a578e31af 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 @@ -20,11 +20,13 @@ import com.google.common.base.Predicate; import com.google.common.collect.ImmutableList; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; +import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.context.ContextPackage; import org.jetbrains.jet.context.GlobalContext; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; @@ -36,7 +38,9 @@ import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackageFragmentProvider; 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.storage.LockBasedStorageManager; import java.util.ArrayList; import java.util.Collection; @@ -64,7 +68,11 @@ public enum TopDownAnalyzerFacadeForJVM { @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull ModuleDescriptorImpl module ) { - return analyzeFilesWithJavaIntegration(project, files, trace, topDownAnalysisParameters, module, null, null); + GlobalContext globalContext = new GlobalContextImpl( + (LockBasedStorageManager) topDownAnalysisParameters.getStorageManager(), + topDownAnalysisParameters.getExceptionTracker()); + + return analyzeFilesWithJavaIntegration(project, files, trace, topDownAnalysisParameters, module, globalContext, null, null); } @NotNull @@ -103,7 +111,8 @@ public enum TopDownAnalyzerFacadeForJVM { ); return analyzeFilesWithJavaIntegration( - project, files, trace, topDownAnalysisParameters, module, moduleIds, incrementalCacheProvider); + project, files, trace, topDownAnalysisParameters, module, + globalContext, moduleIds, incrementalCacheProvider); } @NotNull @@ -113,10 +122,22 @@ public enum TopDownAnalyzerFacadeForJVM { BindingTrace trace, TopDownAnalysisParameters topDownAnalysisParameters, ModuleDescriptorImpl module, + GlobalContext globalContext, @Nullable List moduleIds, @Nullable IncrementalCacheProvider incrementalCacheProvider ) { - InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module); + FileBasedDeclarationProviderFactory providerFactory = + new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), files); + + InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( + project, + globalContext, + trace, + module, + GlobalSearchScope.allScope(project), + providerFactory + ); + try { List additionalProviders = new ArrayList(); @@ -135,7 +156,7 @@ public enum TopDownAnalyzerFacadeForJVM { } additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider()); - injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files, additionalProviders); + injector.getLazyTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files, additionalProviders); return AnalysisResult.success(trace.getBindingContext(), module); } finally { diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java index 1dfbd141cda..d615a6f2f77 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.storage.StorageManager; +import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; @@ -56,7 +57,6 @@ import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.psi.JetImportsFactory; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; -import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -67,6 +67,7 @@ public class InjectorForLazyBodyResolve { private final Project project; private final GlobalContext globalContext; private final StorageManager storageManager; + private final KotlinCodeAnalyzer analyzer; private final BindingTrace bindingTrace; private final AdditionalCheckerProvider additionalCheckerProvider; private final ModuleDescriptor moduleDescriptor; @@ -115,6 +116,7 @@ public class InjectorForLazyBodyResolve { this.project = project; this.globalContext = globalContext; this.storageManager = globalContext.getStorageManager(); + this.analyzer = analyzer; this.bindingTrace = bindingTrace; this.additionalCheckerProvider = additionalCheckerProvider; this.moduleDescriptor = analyzer.getModuleDescriptor(); @@ -155,6 +157,7 @@ public class InjectorForLazyBodyResolve { this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver); + this.lazyTopDownAnalyzer.setKotlinCodeAnalyzer(analyzer); this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor); this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index c03e0d6953c..b09bd38653c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.BodyResolver; @@ -74,7 +73,6 @@ public class InjectorForTopDownAnalyzerBasic { private final ModuleDescriptor moduleDescriptor; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final TopDownAnalyzer topDownAnalyzer; - private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final AdditionalCheckerProvider additionalCheckerProvider; private final BodyResolver bodyResolver; @@ -126,7 +124,6 @@ public class InjectorForTopDownAnalyzerBasic { this.moduleDescriptor = moduleDescriptor; this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); this.topDownAnalyzer = new TopDownAnalyzer(); - this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); this.additionalCheckerProvider = additionalCheckerProvider; this.bodyResolver = new BodyResolver(); @@ -167,7 +164,6 @@ public class InjectorForTopDownAnalyzerBasic { this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); - this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer); this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); this.topDownAnalyzer.setOverloadResolver(overloadResolver); this.topDownAnalyzer.setOverrideResolver(overrideResolver); @@ -176,13 +172,6 @@ public class InjectorForTopDownAnalyzerBasic { this.topDownAnalyzer.setTrace(bindingTrace); this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); - this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); - this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver); - this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor); - this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); - this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); - this.lazyTopDownAnalyzer.setTrace(bindingTrace); - bodyResolver.setAnnotationResolver(annotationResolver); bodyResolver.setCallResolver(callResolver); bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); @@ -292,8 +281,4 @@ public class InjectorForTopDownAnalyzerBasic { return this.topDownAnalyzer; } - public LazyTopDownAnalyzer getLazyTopDownAnalyzer() { - return this.lazyTopDownAnalyzer; - } - } 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 9eadbc09fd6..d8f8b654d40 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java @@ -77,6 +77,7 @@ public class LazyTopDownAnalyzer { @NotNull private BodyResolver bodyResolver = null; + @Inject public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) { this.resolveSession = kotlinCodeAnalyzer; } @@ -113,36 +114,23 @@ public class LazyTopDownAnalyzer { @NotNull public TopDownAnalysisContext analyzeFiles( - @NotNull Project project, @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull Collection files, - @NotNull List additionalProviders, - AdditionalCheckerProvider additionalCheckerProvider + @NotNull List additionalProviders ) { - TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters); + PackageFragmentProvider provider; + if (additionalProviders.isEmpty()) { + provider = resolveSession.getPackageFragmentProvider(); + } + else { + provider = new CompositePackageFragmentProvider(KotlinPackage.plus( + Arrays.asList(resolveSession.getPackageFragmentProvider()), + additionalProviders)); + } - ResolveSession resolveSession = new InjectorForLazyResolve( - project, - new GlobalContextImpl((LockBasedStorageManager) c.getStorageManager(), c.getExceptionTracker()), // TODO - (ModuleDescriptorImpl) moduleDescriptor, // TODO - new FileBasedDeclarationProviderFactory(c.getStorageManager(), files), - trace, - additionalCheckerProvider - ).getResolveSession(); + ((ModuleDescriptorImpl) resolveSession.getModuleDescriptor()).initialize(provider); - CompositePackageFragmentProvider provider = - new CompositePackageFragmentProvider(KotlinPackage.plus(Arrays.asList(resolveSession.getPackageFragmentProvider()), additionalProviders)); - - ((ModuleDescriptorImpl) moduleDescriptor).initialize(provider); - - setKotlinCodeAnalyzer(resolveSession); - - analyzeDeclarations( - c.getTopDownAnalysisParameters(), - files - ); - - return c; + return analyzeDeclarations(topDownAnalysisParameters, files); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index c8970e6a9a5..1cc34835fe5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -58,9 +58,6 @@ public class TopDownAnalyzer { @NotNull private Project project; - @NotNull - private LazyTopDownAnalyzer lazyTopDownAnalyzer; - @Inject public void setTrace(@NotNull BindingTrace trace) { this.trace = trace; @@ -106,11 +103,6 @@ public class TopDownAnalyzer { this.project = project; } - @Inject - public void setLazyTopDownAnalyzer(@NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer) { - this.lazyTopDownAnalyzer = lazyTopDownAnalyzer; - } - @Inject public void setAdditionalCheckerProvider(@NotNull AdditionalCheckerProvider additionalCheckerProvider) { this.additionalCheckerProvider = additionalCheckerProvider; @@ -185,10 +177,7 @@ public class TopDownAnalyzer { @NotNull Collection files, @NotNull List additionalProviders ) { - if (topDownAnalysisParameters.isLazy()) { - return lazyTopDownAnalyzer.analyzeFiles( - project, topDownAnalysisParameters, files, additionalProviders, additionalCheckerProvider); - } + assert !topDownAnalysisParameters.isLazy() : "Lazy resolve must be disabled for this method"; TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters); CompositePackageFragmentProvider provider = @@ -208,7 +197,6 @@ public class TopDownAnalyzer { public MutablePackageFragmentProvider getPackageFragmentProvider() { return packageFragmentProvider; } - } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java index ebfcbf34676..d20166c8f3e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java @@ -19,10 +19,7 @@ package org.jetbrains.jet.lang.resolve.lazy; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.ReadOnly; -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.ScriptDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetClassOrObject; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetScript; @@ -64,4 +61,7 @@ public interface KotlinCodeAnalyzer { * Use this method when laziness plays against you, e.g. when lazy descriptors may be accessed in a multi-threaded setting */ void forceResolveAll(); + + @NotNull + PackageFragmentProvider getPackageFragmentProvider(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java index 5b3c0f003b6..f91c779829f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java @@ -178,6 +178,7 @@ public class ResolveSession implements KotlinCodeAnalyzer { }); } + @Override @NotNull public PackageFragmentProvider getPackageFragmentProvider() { return packageFragmentProvider; diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 815448c424b..34bcbbbb515 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -22,7 +22,8 @@ import org.jetbrains.jet.context.GlobalContextImpl import org.jetbrains.jet.lang.descriptors.ModuleDescriptor import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.jet.lang.resolve.* -import org.jetbrains.jet.lang.resolve.java.* +import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver import org.jetbrains.jet.lang.resolve.java.resolver.* import org.jetbrains.jet.lang.resolve.java.sam.SamConversionResolverImpl import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder @@ -39,8 +40,10 @@ import org.jetbrains.jet.lang.resolve.java.lazy.ModuleClassResolver import org.jetbrains.jet.lang.resolve.kotlin.DeserializationComponentsForJava import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinderFactory +import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM 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 // NOTE: After making changes, you need to re-generate the injectors. @@ -78,8 +81,7 @@ private fun DependencyInjectorGenerator.commonForTopDownAnalyzer() { publicParameter(javaClass(), useAsContext = true) publicFields( - javaClass(), - javaClass() + javaClass() ) field(javaClass()) @@ -116,30 +118,42 @@ private fun generatorForTopDownAnalyzerForJs() = private fun generatorForTopDownAnalyzerForJvm() = generator("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm") { - commonForTopDownAnalyzer() + parameter(javaClass()) + parameter(javaClass(), useAsContext = true) + parameter(javaClass()) + parameter(javaClass(), name = "module", useAsContext = true) + parameter(javaClass(), name = "moduleContentScope") + parameter(javaClass()) - publicField(javaClass()) - publicField(javaClass()) + publicFields( + javaClass(), + javaClass(), + javaClass(), + javaClass() + ) - field(javaClass(), - init = GivenExpression(javaClass().getName() + ".INSTANCE$")) - - field(javaClass (), - init = GivenExpression(javaClass().getName() + ".allScope(project)")) + field(javaClass(), + init = GivenExpression(javaClass().getName() + + ".SERVICE.getInstance(project).create(moduleContentScope)") + ) fields( javaClass(), javaClass(), - javaClass(), + javaClass(), javaClass(), javaClass(), javaClass(), - javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), + javaClass(), javaClass() ) + + field(javaClass(), + init = GivenExpression(javaClass().getName() + ".INSTANCE$")) + field(javaClass(), init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) } diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveSessionForBodies.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveSessionForBodies.java index b48f46c4f70..99075a566e9 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveSessionForBodies.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveSessionForBodies.java @@ -20,10 +20,7 @@ import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.ReadOnly; -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.ScriptDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; @@ -137,4 +134,10 @@ public class ResolveSessionForBodies implements KotlinCodeAnalyzer { public ExceptionTracker getExceptionTracker() { return resolveSession.getExceptionTracker(); } + + @NotNull + @Override + public PackageFragmentProvider getPackageFragmentProvider() { + return resolveSession.getPackageFragmentProvider(); + } } diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java index 01e841b6b09..477f1c30b32 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java @@ -95,6 +95,8 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { @Override public void run() { GlobalContextImpl globalContext = ContextPackage.GlobalContext(); + + // TODO built-ins and lazy resolve TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create( globalContext.getStorageManager(), globalContext.getExceptionTracker(), diff --git a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 34c62dd4e87..ef5939dc3a8 100644 --- a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.BodyResolver; @@ -74,7 +73,6 @@ public class InjectorForTopDownAnalyzerForJs { private final ModuleDescriptor moduleDescriptor; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final TopDownAnalyzer topDownAnalyzer; - private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final AdditionalCheckerProvider additionalCheckerProvider; private final BodyResolver bodyResolver; @@ -125,7 +123,6 @@ public class InjectorForTopDownAnalyzerForJs { this.moduleDescriptor = moduleDescriptor; this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); this.topDownAnalyzer = new TopDownAnalyzer(); - this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$; this.bodyResolver = new BodyResolver(); @@ -166,7 +163,6 @@ public class InjectorForTopDownAnalyzerForJs { this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); - this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer); this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); this.topDownAnalyzer.setOverloadResolver(overloadResolver); this.topDownAnalyzer.setOverrideResolver(overrideResolver); @@ -175,13 +171,6 @@ public class InjectorForTopDownAnalyzerForJs { this.topDownAnalyzer.setTrace(bindingTrace); this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); - this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); - this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver); - this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor); - this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); - this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); - this.lazyTopDownAnalyzer.setTrace(bindingTrace); - bodyResolver.setAnnotationResolver(annotationResolver); bodyResolver.setCallResolver(callResolver); bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); @@ -291,8 +280,4 @@ public class InjectorForTopDownAnalyzerForJs { return this.topDownAnalyzer; } - public LazyTopDownAnalyzer getLazyTopDownAnalyzer() { - return this.lazyTopDownAnalyzer; - } - }