From e60bd514fa64f09dd60a30270bfc166a0882cad5 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 3 Feb 2014 18:30:16 +0400 Subject: [PATCH] StorageManager&ExceptionTracker delivered where needed - GlobalContext introduced to group the two - Caches track exceptions --- .../jet/di/InjectorForJvmCodegen.java | 3 ++ .../jet/cli/jvm/repl/ReplInterpreter.java | 2 + .../di/InjectorForJavaDescriptorResolver.java | 18 ++++---- .../di/InjectorForTopDownAnalyzerForJvm.java | 2 +- .../resolve/java/AnalyzerFacadeForJVM.java | 32 ++++++++++----- .../analyzer/AnalyzerFacadeForEverything.java | 8 +++- .../src/org/jetbrains/jet/context/context.kt | 36 ++++++++++++++++ .../jet/di/InjectorForBodyResolve.java | 2 +- .../jet/di/InjectorForLazyResolve.java | 17 ++++---- .../jetbrains/jet/di/InjectorForMacros.java | 13 +++--- .../di/InjectorForTopDownAnalyzerBasic.java | 2 +- .../lang/resolve/BodiesResolveContext.java | 9 +++- .../resolve/CachedBodiesResolveContext.java | 6 +++ .../lang/resolve/TopDownAnalysisContext.java | 6 +++ .../resolve/TopDownAnalysisParameters.java | 12 ++++++ .../jet/lang/resolve/TopDownAnalyzer.java | 14 +++++-- .../jet/lang/resolve/lazy/ResolveSession.java | 14 +++++-- .../ClosureExpressionsTypingVisitor.java | 15 ++++--- .../expressions/ExpressionTypingServices.java | 14 +++---- .../ExpressionTypingVisitorDispatcher.java | 22 +++++----- .../ExpressionTypingVisitorForStatements.java | 17 ++++---- ...edStorageManagerWithExceptionTracking.java | 38 ----------------- .../jetbrains/jet/di/InjectorForTests.java | 13 +++--- .../jvm/compiler/AbstractLoadJavaTest.java | 9 +++- ...ractLazyResolveDescriptorRendererTest.java | 9 ++-- .../resolve/lazy/LazyResolveTestUtil.java | 6 ++- .../jet/storage/LockBasedStorageManager.java | 1 + .../injectors/GenerateInjectors.java | 18 +++++--- .../resolve/JSDeclarationsCacheProvider.java | 2 +- .../resolve/JvmDeclarationsCacheProvider.java | 2 +- .../resolve/KotlinDeclarationsCacheImpl.java | 11 ++++- .../libraries/JetSourceNavigationHelper.java | 9 ++-- .../plugin/project/ResolveElementCache.java | 41 +++++++++++++------ .../references/BuiltInsReferenceResolver.java | 7 +++- .../di/InjectorForTopDownAnalyzerForJs.java | 2 +- .../k2js/analyze/AnalyzerFacadeForJS.java | 13 +++--- 36 files changed, 284 insertions(+), 161 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/context/context.kt delete mode 100644 compiler/frontend/src/org/jetbrains/jet/storage/LockBasedStorageManagerWithExceptionTracking.java diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java index 7513b4a7be7..6f90139a281 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java @@ -20,6 +20,7 @@ import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.codegen.ClassBuilderFactory; import com.intellij.openapi.project.Project; +import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.codegen.ClassBuilderMode; @@ -36,6 +37,7 @@ public class InjectorForJvmCodegen { private final GenerationState generationState; private final ClassBuilderFactory classBuilderFactory; private final Project project; + private final GlobalContext globalContext; private final BindingTrace bindingTrace; private final BindingContext bindingContext; private final ClassBuilderMode classBuilderMode; @@ -52,6 +54,7 @@ public class InjectorForJvmCodegen { this.generationState = generationState; this.classBuilderFactory = classBuilderFactory; this.project = project; + this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext(); this.bindingTrace = jetTypeMapper.getBindingTrace(); this.bindingContext = bindingTrace.getBindingContext(); this.classBuilderMode = classBuilderFactory.getClassBuilderMode(); 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 0a19fd80dfc..81312baf01f 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 @@ -59,6 +59,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.types.lang.InlineUtil; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetLanguage; +import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.LockBasedStorageManager; import org.jetbrains.jet.utils.UtilsPackage; @@ -103,6 +104,7 @@ public class ReplInterpreter { module = AnalyzerFacadeForJVM.createJavaModule(""); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( new LockBasedStorageManager(), + new ExceptionTracker(), // dummy Predicates.alwaysTrue(), false, true, 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 f39632ee371..0cc583bb2af 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -18,7 +18,8 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; +import org.jetbrains.jet.context.GlobalContextImpl; +import org.jetbrains.jet.storage.StorageManager; 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; @@ -29,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProviderImpl; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; @@ -52,7 +52,8 @@ public class InjectorForJavaDescriptorResolver { private final Project project; private final BindingTrace bindingTrace; - private final LockBasedStorageManagerWithExceptionTracking storageManager; + private final GlobalContextImpl globalContext; + private final StorageManager storageManager; private final JavaClassFinderImpl javaClassFinder; private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; private final TraceBasedJavaResolverCache traceBasedJavaResolverCache; @@ -63,7 +64,6 @@ public class InjectorForJavaDescriptorResolver { private final JavaPackageFragmentProviderImpl javaPackageFragmentProvider; private final VirtualFileFinder virtualFileFinder; private final ModuleDescriptorImpl module; - private final ExceptionTracker exceptionTracker; private final JavaAnnotationResolver javaAnnotationResolver; private final JavaAnnotationArgumentResolver javaAnnotationArgumentResolver; private final JavaClassResolver javaClassResolver; @@ -84,8 +84,8 @@ public class InjectorForJavaDescriptorResolver { ) { this.project = project; this.bindingTrace = bindingTrace; - this.exceptionTracker = new ExceptionTracker(); - this.storageManager = new LockBasedStorageManagerWithExceptionTracking(exceptionTracker); + this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext(); + this.storageManager = globalContext.getStorageManager(); this.javaClassFinder = new JavaClassFinderImpl(); this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver(); this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache(); @@ -100,7 +100,7 @@ public class InjectorForJavaDescriptorResolver { this.javaAnnotationArgumentResolver = new JavaAnnotationArgumentResolver(); this.javaClassResolver = new JavaClassResolver(); this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); - this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(getStorageManager()); + this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(storageManager); this.javaFunctionResolver = new JavaFunctionResolver(); this.javaTypeParameterResolver = new JavaTypeParameterResolver(); this.javaTypeTransformer = new JavaTypeTransformer(); @@ -215,8 +215,8 @@ public class InjectorForJavaDescriptorResolver { public void destroy() { } - public LockBasedStorageManagerWithExceptionTracking getStorageManager() { - return this.storageManager; + public GlobalContextImpl getGlobalContext() { + return this.globalContext; } public JavaClassFinderImpl getJavaClassFinder() { 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 6c93c444086..edd75b25608 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -165,7 +165,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); - this.expressionTypingServices = new ExpressionTypingServices(storageManager, javaToKotlinClassMap); + this.expressionTypingServices = new ExpressionTypingServices(getTopDownAnalysisContext(), javaToKotlinClassMap); this.callExpressionResolver = new CallExpressionResolver(); this.typeResolver = new TypeResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index 91d3eae991f..aa88c64faf5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -25,6 +25,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.analyzer.AnalyzerFacade; import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything; +import org.jetbrains.jet.context.ContextPackage; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.di.InjectorForLazyResolve; @@ -40,8 +42,6 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProv import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.storage.LockBasedStorageManager; -import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; import java.util.Collection; import java.util.Collections; @@ -102,13 +102,16 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { final JavaClassFinderImpl classFinder = injector.getJavaClassFinder(); // TODO: Replace with stub declaration provider - LockBasedStorageManagerWithExceptionTracking storageManager = injector.getStorageManager(); - FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(storageManager, files, new Predicate() { - @Override - public boolean apply(FqName fqName) { - return classFinder.findPackage(fqName) != null || KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName); - } - }); + GlobalContextImpl globalContext = injector.getGlobalContext(); + FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( + globalContext.getStorageManager(), + files, + new Predicate() { + @Override + public boolean apply(FqName fqName) { + return classFinder.findPackage(fqName) != null || KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName); + } + }); ModuleDescriptorImpl module = injector.getModule(); @@ -116,7 +119,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); } - return new InjectorForLazyResolve(project, storageManager, module, declarationProviderFactory, trace).getResolveSession(); + return new InjectorForLazyResolve(project, globalContext, module, declarationProviderFactory, trace).getResolveSession(); } @NotNull @@ -201,8 +204,15 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { boolean storeContextForBodiesResolve, ModuleDescriptorImpl module ) { + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - new LockBasedStorageManager(), filesToAnalyzeCompletely, false, false, scriptParameters); + globalContext.getStorageManager(), + globalContext.getExceptionTracker(), + filesToAnalyzeCompletely, + false, + false, + scriptParameters + ); InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module); try { diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java index c08a4d708c0..be00b709797 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java @@ -38,7 +38,13 @@ public class AnalyzerFacadeForEverything { @NotNull ModuleDescriptor module) { TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - bodiesResolveContext.getStorageManager(), filesToAnalyzeCompletely, false, false, scriptParameters); + bodiesResolveContext.getStorageManager(), + bodiesResolveContext.getExceptionTracker(), + filesToAnalyzeCompletely, + false, + false, + scriptParameters + ); bodiesResolveContext.setTopDownAnalysisParameters(topDownAnalysisParameters); diff --git a/compiler/frontend/src/org/jetbrains/jet/context/context.kt b/compiler/frontend/src/org/jetbrains/jet/context/context.kt new file mode 100644 index 00000000000..df48ed61b73 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/context/context.kt @@ -0,0 +1,36 @@ +/* + * 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.context + +import org.jetbrains.jet.storage.StorageManager +import org.jetbrains.jet.storage.ExceptionTracker +import org.jetbrains.jet.storage.LockBasedStorageManager + +trait GlobalContext { + val storageManager: StorageManager + val exceptionTracker: ExceptionTracker +} + +open class GlobalContextImpl( + override val storageManager: LockBasedStorageManager, + override val exceptionTracker: ExceptionTracker +) : GlobalContext + +fun GlobalContext(): GlobalContextImpl { + val tracker = ExceptionTracker() + return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling(tracker), tracker) +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index ba8b5e17b58..66bb139f144 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -92,7 +92,7 @@ public class InjectorForBodyResolve { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); - this.expressionTypingServices = new ExpressionTypingServices(storageManager, platformToKotlinClassMap); + this.expressionTypingServices = new ExpressionTypingServices(getBodiesResolveContext(), platformToKotlinClassMap); this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 4ded6beda22..78f96930423 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -17,12 +17,13 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; -import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -44,12 +45,13 @@ import javax.annotation.PreDestroy; public class InjectorForLazyResolve { private final Project project; - private final LockBasedStorageManagerWithExceptionTracking lockBasedStorageManagerWithExceptionTracking; + private final GlobalContextImpl globalContext; private final ModuleDescriptorImpl moduleDescriptor; private final DeclarationProviderFactory declarationProviderFactory; private final BindingTrace bindingTrace; private final ResolveSession resolveSession; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final StorageManager storageManager; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -66,23 +68,24 @@ public class InjectorForLazyResolve { public InjectorForLazyResolve( @NotNull Project project, - @NotNull LockBasedStorageManagerWithExceptionTracking lockBasedStorageManagerWithExceptionTracking, + @NotNull GlobalContextImpl globalContext, @NotNull ModuleDescriptorImpl moduleDescriptor, @NotNull DeclarationProviderFactory declarationProviderFactory, @NotNull BindingTrace bindingTrace ) { this.project = project; - this.lockBasedStorageManagerWithExceptionTracking = lockBasedStorageManagerWithExceptionTracking; + this.globalContext = globalContext; this.moduleDescriptor = moduleDescriptor; this.declarationProviderFactory = declarationProviderFactory; this.bindingTrace = bindingTrace; - this.resolveSession = new ResolveSession(project, lockBasedStorageManagerWithExceptionTracking, moduleDescriptor, declarationProviderFactory, bindingTrace); + this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.storageManager = resolveSession.getStorageManager(); this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); - this.expressionTypingServices = new ExpressionTypingServices(lockBasedStorageManagerWithExceptionTracking, platformToKotlinClassMap); + this.expressionTypingServices = new ExpressionTypingServices(globalContext, platformToKotlinClassMap); this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); @@ -123,7 +126,7 @@ public class InjectorForLazyResolve { descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setStorageManager(lockBasedStorageManagerWithExceptionTracking); + descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index 0420ca7505c..2178a0028e1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -18,7 +18,8 @@ package org.jetbrains.jet.di; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; -import org.jetbrains.jet.storage.LockBasedStorageManager; +import org.jetbrains.jet.context.GlobalContext; +import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; @@ -40,7 +41,8 @@ public class InjectorForMacros { private final ExpressionTypingServices expressionTypingServices; private final CallResolverExtensionProvider callResolverExtensionProvider; - private final LockBasedStorageManager lockBasedStorageManager; + private final GlobalContext globalContext; + private final StorageManager storageManager; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final Project project; private final ModuleDescriptor moduleDescriptor; @@ -58,10 +60,11 @@ public class InjectorForMacros { @NotNull Project project, @NotNull ModuleDescriptor moduleDescriptor ) { - this.lockBasedStorageManager = new LockBasedStorageManager(); + this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext(); this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); - this.expressionTypingServices = new ExpressionTypingServices(lockBasedStorageManager, platformToKotlinClassMap); + this.expressionTypingServices = new ExpressionTypingServices(globalContext, platformToKotlinClassMap); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.storageManager = globalContext.getStorageManager(); this.project = project; this.moduleDescriptor = moduleDescriptor; this.annotationResolver = new AnnotationResolver(); @@ -104,7 +107,7 @@ public class InjectorForMacros { descriptorResolver.setAnnotationResolver(annotationResolver); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setStorageManager(lockBasedStorageManager); + descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 827dc19f7e0..c31772a06fd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -116,7 +116,7 @@ public class InjectorForTopDownAnalyzerBasic { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); - this.expressionTypingServices = new ExpressionTypingServices(storageManager, platformToKotlinClassMap); + this.expressionTypingServices = new ExpressionTypingServices(getTopDownAnalysisContext(), platformToKotlinClassMap); this.callExpressionResolver = new CallExpressionResolver(); this.typeResolver = new TypeResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java index 422fc0656ae..544b1987915 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Function; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; @@ -27,13 +28,19 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.StorageManager; import java.util.Collection; import java.util.Map; -public interface BodiesResolveContext { +public interface BodiesResolveContext extends GlobalContext { + @NotNull + @Override StorageManager getStorageManager(); + @NotNull + @Override + ExceptionTracker getExceptionTracker(); Collection getFiles(); Map getClasses(); Map getProperties(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java index 30f98458bfe..ced51769934 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.StorageManager; import java.util.Collection; @@ -68,6 +69,11 @@ public class CachedBodiesResolveContext implements BodiesResolveContext { return topDownAnalysisParameters.getStorageManager(); } + @Override + public ExceptionTracker getExceptionTracker() { + return topDownAnalysisParameters.getExceptionTracker(); + } + @Override public Collection getFiles() { return files; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index ba2f67d8392..6b57296bd5e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.StorageManager; import javax.inject.Inject; @@ -124,6 +125,11 @@ public class TopDownAnalysisContext implements BodiesResolveContext { return topDownAnalysisParameters.getStorageManager(); } + @Override + public ExceptionTracker getExceptionTracker() { + return topDownAnalysisParameters.getExceptionTracker(); + } + @Override public Collection getFiles() { return packageFragments.keySet(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java index 7ea26ad2443..08146565f30 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Predicate; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.StorageManager; import java.util.List; @@ -30,6 +31,8 @@ public class TopDownAnalysisParameters { @NotNull private final StorageManager storageManager; @NotNull + private final ExceptionTracker exceptionTracker; + @NotNull private final Predicate analyzeCompletely; private final boolean analyzingBootstrapLibrary; private final boolean declaredLocally; @@ -38,23 +41,32 @@ public class TopDownAnalysisParameters { public TopDownAnalysisParameters( @NotNull StorageManager storageManager, + @NotNull ExceptionTracker exceptionTracker, @NotNull Predicate analyzeCompletely, boolean analyzingBootstrapLibrary, boolean declaredLocally, @NotNull List scriptParameters ) { this.storageManager = storageManager; + this.exceptionTracker = exceptionTracker; this.analyzeCompletely = analyzeCompletely; this.analyzingBootstrapLibrary = analyzingBootstrapLibrary; this.declaredLocally = declaredLocally; this.scriptParameters = scriptParameters; } + //@Override @NotNull public StorageManager getStorageManager() { return storageManager; } + //@Override + @NotNull + public ExceptionTracker getExceptionTracker() { + return exceptionTracker; + } + @NotNull public Predicate getAnalyzeCompletely() { return analyzeCompletely; 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 11193e6c8f7..7a14056a146 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -21,6 +21,7 @@ import com.google.common.collect.Sets; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.*; @@ -34,7 +35,6 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.storage.StorageManager; import javax.inject.Inject; import java.util.Collection; @@ -159,7 +159,7 @@ public class TopDownAnalyzer { } public static void processClassOrObject( - @NotNull StorageManager storageManager, + @NotNull GlobalContext globalContext, @Nullable final WritableScope scope, @NotNull ExpressionTypingContext context, @NotNull final DeclarationDescriptor containingDeclaration, @@ -170,8 +170,14 @@ public class TopDownAnalyzer { PlatformToKotlinClassMap.EMPTY); TopDownAnalysisParameters topDownAnalysisParameters = - new TopDownAnalysisParameters(storageManager, Predicates.equalTo(object.getContainingFile()), - false, true, Collections.emptyList()); + new TopDownAnalysisParameters( + globalContext.getStorageManager(), + globalContext.getExceptionTracker(), + Predicates.equalTo(object.getContainingFile()), + false, + true, + Collections.emptyList() + ); InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( object.getProject(), topDownAnalysisParameters, new ObservableBindingTrace(context.trace), 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 06a40b1c068..352fbc001e9 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 @@ -27,6 +27,7 @@ import com.intellij.util.containers.ContainerUtil; import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; @@ -41,7 +42,10 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.SpecialNames; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.renderer.DescriptorRenderer; -import org.jetbrains.jet.storage.*; +import org.jetbrains.jet.storage.ExceptionTracker; +import org.jetbrains.jet.storage.LazyResolveStorageManager; +import org.jetbrains.jet.storage.LockBasedLazyResolveStorageManager; +import org.jetbrains.jet.storage.MemoizedFunctionToNullable; import javax.inject.Inject; import java.util.Collection; @@ -115,14 +119,14 @@ public class ResolveSession implements KotlinCodeAnalyzer { @Deprecated public ResolveSession( @NotNull Project project, - @NotNull LockBasedStorageManagerWithExceptionTracking storageManager, + @NotNull GlobalContextImpl globalContext, @NotNull ModuleDescriptorImpl rootDescriptor, @NotNull DeclarationProviderFactory declarationProviderFactory, @NotNull BindingTrace delegationTrace ) { - LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager = new LockBasedLazyResolveStorageManager(storageManager); + LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager = new LockBasedLazyResolveStorageManager(globalContext.getStorageManager()); this.storageManager = lockBasedLazyResolveStorageManager; - this.exceptionTracker = storageManager.getTracker(); + this.exceptionTracker = globalContext.getExceptionTracker(); this.trace = lockBasedLazyResolveStorageManager.createSafeTrace(delegationTrace); this.module = rootDescriptor; @@ -193,11 +197,13 @@ public class ResolveSession implements KotlinCodeAnalyzer { } @NotNull + //@Override public LazyResolveStorageManager getStorageManager() { return storageManager; } @NotNull + //@Override public ExceptionTracker getExceptionTracker() { return exceptionTracker; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 08cb2c28391..5a03840dac4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -23,6 +23,7 @@ import com.intellij.util.containers.ContainerUtil; import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; import org.jetbrains.jet.lang.descriptors.impl.*; @@ -37,7 +38,6 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetTypeInfo; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.util.slicedmap.WritableSlice; import java.util.Collection; @@ -51,11 +51,14 @@ import static org.jetbrains.jet.lang.types.TypeUtils.*; import static org.jetbrains.jet.lang.types.expressions.CoercionStrategy.COERCION_TO_UNIT; public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { - private final StorageManager storageManager; + private final GlobalContext globalContext; - protected ClosureExpressionsTypingVisitor(@NotNull ExpressionTypingInternals facade, @NotNull StorageManager storageManager) { + protected ClosureExpressionsTypingVisitor( + @NotNull GlobalContext globalContext, + @NotNull ExpressionTypingInternals facade + ) { super(facade); - this.storageManager = storageManager; + this.globalContext = globalContext; } @Override @@ -73,7 +76,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { @Override public void handleRecord(WritableSlice slice, PsiElement declaration, final ClassDescriptor descriptor) { if (slice == CLASS && declaration == expression.getObjectDeclaration()) { - JetType defaultType = DeferredType.createRecursionIntolerant(storageManager, context.trace, + JetType defaultType = DeferredType.createRecursionIntolerant(globalContext.getStorageManager(), context.trace, new Function0() { @Override public JetType invoke() { @@ -90,7 +93,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { }; ObservableBindingTrace traceAdapter = new ObservableBindingTrace(temporaryTrace); traceAdapter.addHandler(CLASS, handler); - TopDownAnalyzer.processClassOrObject(storageManager, + TopDownAnalyzer.processClassOrObject(globalContext, null, // don't need to add classifier of object literal to any scope context.replaceBindingTrace(traceAdapter).replaceContextDependency(INDEPENDENT), context.scope.getContainingDeclaration(), diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java index cb5d3dcd4fb..79fdb80a532 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java @@ -21,6 +21,7 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.tree.IElementType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; @@ -44,7 +45,6 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetTypeInfo; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; -import org.jetbrains.jet.storage.StorageManager; import javax.inject.Inject; import java.util.Iterator; @@ -75,7 +75,7 @@ public class ExpressionTypingServices { @NotNull private CallResolverExtensionProvider extensionProvider; @NotNull - private StorageManager storageManager; + private GlobalContext globalContext; @NotNull public Project getProject() { @@ -148,12 +148,12 @@ public class ExpressionTypingServices { } public ExpressionTypingServices( - @NotNull StorageManager storageManager, + @NotNull GlobalContext globalContext, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap ) { - this.storageManager = storageManager; + this.globalContext = globalContext; this.platformToKotlinClassMap = platformToKotlinClassMap; - this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(storageManager, platformToKotlinClassMap); + this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(globalContext, platformToKotlinClassMap); } @NotNull @@ -282,7 +282,7 @@ public class ExpressionTypingServices { return JetTypeInfo.create(KotlinBuiltIns.getInstance().getUnitType(), context.dataFlowInfo); } - ExpressionTypingInternals blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(storageManager, platformToKotlinClassMap, scope); + ExpressionTypingInternals blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(globalContext, platformToKotlinClassMap, scope); ExpressionTypingContext newContext = createContext(context, trace, scope, context.dataFlowInfo, NO_EXPECTED_TYPE); JetTypeInfo result = JetTypeInfo.create(null, context.dataFlowInfo); @@ -306,7 +306,7 @@ public class ExpressionTypingServices { if (newDataFlowInfo != context.dataFlowInfo) { newContext = newContext.replaceDataFlowInfo(newDataFlowInfo); } - blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(storageManager, platformToKotlinClassMap, scope); + blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(globalContext, platformToKotlinClassMap, scope); } return result; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java index 92da4c3fec8..d6967339126 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.types.expressions; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -27,7 +28,6 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.DeferredType; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetTypeInfo; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.util.ReenteringLazyValueComputationException; import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM; @@ -35,36 +35,36 @@ import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO public class ExpressionTypingVisitorDispatcher extends JetVisitor implements ExpressionTypingInternals { @NotNull - public static ExpressionTypingFacade create(@NotNull StorageManager storageManager, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { - return new ExpressionTypingVisitorDispatcher(storageManager, platformToKotlinClassMap, null); + public static ExpressionTypingFacade create(@NotNull GlobalContext globalContext, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { + return new ExpressionTypingVisitorDispatcher(globalContext, platformToKotlinClassMap, null); } @NotNull public static ExpressionTypingInternals createForBlock( - @NotNull StorageManager storageManager, + @NotNull GlobalContext globalContext, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap, @NotNull WritableScope writableScope ) { - return new ExpressionTypingVisitorDispatcher(storageManager, platformToKotlinClassMap, writableScope); + return new ExpressionTypingVisitorDispatcher(globalContext, platformToKotlinClassMap, writableScope); } - private final StorageManager storageManager; + private final GlobalContext globalContext; private final BasicExpressionTypingVisitor basic; private final ExpressionTypingVisitorForStatements statements; private final ClosureExpressionsTypingVisitor closures; private final ControlStructureTypingVisitor controlStructures = new ControlStructureTypingVisitor(this); private final PatternMatchingTypingVisitor patterns = new PatternMatchingTypingVisitor(this); - private ExpressionTypingVisitorDispatcher(StorageManager storageManager, PlatformToKotlinClassMap platformToKotlinClassMap, WritableScope writableScope) { - this.storageManager = storageManager; + private ExpressionTypingVisitorDispatcher(GlobalContext globalContext, PlatformToKotlinClassMap platformToKotlinClassMap, WritableScope writableScope) { + this.globalContext = globalContext; this.basic = new BasicExpressionTypingVisitor(this, platformToKotlinClassMap); if (writableScope != null) { - this.statements = new ExpressionTypingVisitorForStatements(storageManager, this, writableScope, basic, controlStructures, patterns); + this.statements = new ExpressionTypingVisitorForStatements(globalContext, this, writableScope, basic, controlStructures, patterns); } else { this.statements = null; } - this.closures = new ClosureExpressionsTypingVisitor(this, storageManager); + this.closures = new ClosureExpressionsTypingVisitor(globalContext, this); } @NotNull @@ -100,7 +100,7 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitoralwaysFalse(), false, false, Collections.emptyList()), + new LockBasedStorageManager(), + new ExceptionTracker(), // dummy + Predicates.alwaysFalse(), + false, + false, + Collections.emptyList() + ), trace, module); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 8efbec1e3ae..3a5b6274c95 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -26,6 +26,8 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForLazyResolve; +import org.jetbrains.jet.context.ContextPackage; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -34,7 +36,6 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProv import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.renderer.DescriptorRenderer; -import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; import java.io.File; import java.io.IOException; @@ -60,10 +61,10 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); lazyModule.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create(); + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); final ResolveSession resolveSession = new InjectorForLazyResolve( - getProject(), storageManager, lazyModule, - new FileBasedDeclarationProviderFactory(storageManager, files), + getProject(), globalContext, lazyModule, + new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), files), new BindingTraceContext()).getResolveSession(); final List descriptors = new ArrayList(); 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 21f16429934..73c4575914d 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -24,6 +24,8 @@ 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; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; @@ -40,7 +42,6 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.SpecialNames; -import org.jetbrains.jet.storage.LockBasedStorageManager; import java.util.Collections; import java.util.List; @@ -53,8 +54,9 @@ public class LazyResolveTestUtil { public static InjectorForTopDownAnalyzer createInjectorForTDA(JetCoreEnvironment environment) { JetTestUtils.newTrace(environment); + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); TopDownAnalysisParameters params = new TopDownAnalysisParameters( - new LockBasedStorageManager(), Predicates.alwaysTrue(), false, false, Collections.emptyList()); + globalContext.getStorageManager(), globalContext.getExceptionTracker(), Predicates.alwaysTrue(), false, false, Collections.emptyList()); CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); BindingTrace sharedTrace = support.getTrace(); ModuleDescriptorImpl sharedModule = support.getModule(); diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java index 9b03ca18e5d..adc28717741 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java @@ -59,6 +59,7 @@ public class LockBasedStorageManager implements StorageManager { } }; + @NotNull public static LockBasedStorageManager createWithExceptionHandling(@NotNull ExceptionHandlingStrategy exceptionHandlingStrategy) { return new LockBasedStorageManager(exceptionHandlingStrategy); } diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index db2be17b2ba..99617ba54d8 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -23,6 +23,8 @@ import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.codegen.state.JetTypeMapper; +import org.jetbrains.jet.context.GlobalContext; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.DependencyInjectorGenerator; import org.jetbrains.jet.di.GivenExpression; import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; @@ -42,8 +44,6 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFacto import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.storage.LockBasedStorageManager; -import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; import org.jetbrains.jet.storage.StorageManager; import java.io.IOException; @@ -87,7 +87,7 @@ public class GenerateInjectors { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(); generator.addParameter(Project.class); - generator.addParameter(LockBasedStorageManagerWithExceptionTracking.class); + generator.addParameter(GlobalContextImpl.class); generator.addParameter(ModuleDescriptorImpl.class); generator.addParameter(DeclarationProviderFactory.class); generator.addParameter(BindingTrace.class); @@ -95,6 +95,7 @@ public class GenerateInjectors { generator.addPublicField(ResolveSession.class); generator.addField(CallResolverExtensionProvider.class); + generator.addField(false, StorageManager.class, null, new GivenExpression("resolveSession.getStorageManager()")); generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()")); generator.configure("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve", GenerateInjectors.class); @@ -151,7 +152,8 @@ public class GenerateInjectors { generator.addParameter(BindingTrace.class); // Fields - generator.addField(true, LockBasedStorageManagerWithExceptionTracking.class, "storageManager", null); + generator.addField(true, GlobalContextImpl.class, null, new GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()")); + generator.addField(false, StorageManager.class, null, new GivenExpression("globalContext.getStorageManager()")); generator.addPublicField(JavaClassFinderImpl.class); generator.addField(TraceBasedExternalSignatureResolver.class); generator.addField(TraceBasedJavaResolverCache.class); @@ -195,7 +197,8 @@ public class GenerateInjectors { // Fields generator.addPublicField(ExpressionTypingServices.class); generator.addField(CallResolverExtensionProvider.class); - generator.addField(LockBasedStorageManager.class); + generator.addField(false, GlobalContext.class, null, new GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()")); + generator.addField(false, StorageManager.class, null, new GivenExpression("globalContext.getStorageManager()")); generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()")); // Parameters @@ -215,9 +218,10 @@ public class GenerateInjectors { generator.addPublicField(TypeResolver.class); generator.addPublicField(CallResolver.class); generator.addField(CallResolverExtensionProvider.class); - generator.addField(LockBasedStorageManager.class); + generator.addField(false, StorageManager.class, null, new GivenExpression("globalContext.getStorageManager()")); generator.addField(true, KotlinBuiltIns.class, null, new GivenExpression("KotlinBuiltIns.getInstance()")); generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()")); + generator.addField(false, GlobalContext.class, null, new GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()")); // Parameters generator.addPublicParameter(Project.class); @@ -237,6 +241,8 @@ public class GenerateInjectors { generator.addPublicParameter(Project.class); // Fields + generator.addField(false, GlobalContext.class, null, + new GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()")); generator.addField(false, BindingTrace.class, "bindingTrace", new GivenExpression("jetTypeMapper.getBindingTrace()")); generator.addField(false, BindingContext.class, "bindingContext", diff --git a/idea/src/org/jetbrains/jet/plugin/caches/resolve/JSDeclarationsCacheProvider.java b/idea/src/org/jetbrains/jet/plugin/caches/resolve/JSDeclarationsCacheProvider.java index 7eb0127a545..4e2dc6fcaa0 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/resolve/JSDeclarationsCacheProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/resolve/JSDeclarationsCacheProvider.java @@ -77,7 +77,7 @@ class JSDeclarationsCacheProvider extends DeclarationsCacheProvider { project, cachedKey, declarationsProvider, - false + true ); } } diff --git a/idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java b/idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java index 2fe38f0f554..e6c6126bec7 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java @@ -105,7 +105,7 @@ class JvmDeclarationsCacheProvider extends DeclarationsCacheProvider { project, cachedKey, declarationsProvider, - false + true ); } } diff --git a/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinDeclarationsCacheImpl.java b/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinDeclarationsCacheImpl.java index 933d0cbe8a7..9c4af39442d 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinDeclarationsCacheImpl.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinDeclarationsCacheImpl.java @@ -17,11 +17,13 @@ package org.jetbrains.jet.plugin.caches.resolve; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.util.ModificationTracker; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.BodiesResolveContext; -public class KotlinDeclarationsCacheImpl implements KotlinDeclarationsCache { +public class KotlinDeclarationsCacheImpl implements KotlinDeclarationsCache, ModificationTracker { private static final Logger LOG = Logger.getInstance(KotlinDeclarationsCacheImpl.class); @@ -40,6 +42,13 @@ public class KotlinDeclarationsCacheImpl implements KotlinDeclarationsCache { return exhaust.getBindingContext(); } + @Override + public long getModificationCount() { + BodiesResolveContext context = exhaust.getBodiesResolveContext(); + if (context == null) return 0; + return context.getExceptionTracker().getModificationCount(); + } + @NotNull public AnalyzeExhaust getAnalyzeExhaust() { return exhaust; diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index 2c97d046353..73bb47675ee 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -43,6 +43,8 @@ import org.jetbrains.annotations.TestOnly; import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor; import org.jetbrains.jet.di.InjectorForLazyResolve; +import org.jetbrains.jet.context.ContextPackage; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -64,7 +66,6 @@ import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex; import org.jetbrains.jet.plugin.stubindex.JetTopLevelFunctionsFqnNameIndex; import org.jetbrains.jet.plugin.stubindex.JetTopLevelPropertiesFqnNameIndex; -import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; import java.util.Collection; import java.util.Collections; @@ -215,8 +216,8 @@ public class JetSourceNavigationHelper { } Project project = decompiledDeclaration.getProject(); - LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create(); - FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(storageManager, getContainingFiles(candidates), + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); + FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), getContainingFiles(candidates), new Predicate() { @Override public boolean apply(@Nullable FqName fqName) { @@ -231,7 +232,7 @@ public class JetSourceNavigationHelper { KotlinCodeAnalyzer analyzer = new InjectorForLazyResolve( project, - storageManager, + globalContext, moduleDescriptor, providerFactory, new BindingTraceContext()).getResolveSession(); diff --git a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index b229b1a5536..b9565d8a165 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.TypeConstructor; +import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.LazyResolveStorageManager; import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; import org.jetbrains.jet.storage.StorageManager; @@ -229,8 +230,7 @@ public class ResolveElementCache { private static void delegationSpecifierAdditionalResolve( ResolveSession resolveSession, JetDelegationSpecifierList specifier, BindingTrace trace, JetFile file) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(), - trace, file, resolveSession.getModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); JetClassOrObject classOrObject = (JetClassOrObject) specifier.getParent(); LazyClassDescriptor descriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject); @@ -249,6 +249,7 @@ public class ResolveElementCache { BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy( resolveSession.getStorageManager(), + resolveSession.getExceptionTracker(), new Function() { @Override public JetScope apply(JetDeclaration declaration) { @@ -279,8 +280,7 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(), - trace, file, resolveSession.getModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction); FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction); bodyResolver.resolveFunctionBody(trace, namedFunction, functionDescriptor, scope); @@ -292,8 +292,7 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(), - trace, file, resolveSession.getModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass); ClassDescriptor classDescriptor = (ClassDescriptor) resolveSession.resolveToDescriptor(klass); @@ -309,8 +308,7 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(), - trace, file, resolveSession.getModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file); JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class); LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject); bodyResolver.resolveAnonymousInitializers(classOrObject, classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(), @@ -323,18 +321,23 @@ public class ResolveElementCache { ModuleDescriptor module) { TopDownAnalysisParameters parameters = new TopDownAnalysisParameters( bodyResolveContext.getStorageManager(), + bodyResolveContext.getExceptionTracker(), Predicates.alwaysTrue(), false, true, Collections.emptyList()); InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(file.getProject(), parameters, trace, bodyResolveContext, module); return bodyResolve.getBodyResolver(); } private static BodyResolver createBodyResolverWithEmptyContext( - StorageManager storageManager, + ResolveSession resolveSession, BindingTrace trace, - JetFile file, - ModuleDescriptor module + JetFile file ) { - return createBodyResolver(trace, file, new BodyResolveContextForLazy(storageManager, Functions.constant(null)), module); + return createBodyResolver(trace, file, + new BodyResolveContextForLazy( + resolveSession.getStorageManager(), + resolveSession.getExceptionTracker(), + Functions.constant(null)), + resolveSession.getModuleDescriptor()); } private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) { @@ -424,18 +427,30 @@ public class ResolveElementCache { private static class BodyResolveContextForLazy implements BodiesResolveContext { private final StorageManager storageManager; + private final ExceptionTracker exceptionTracker; private final Function declaringScopes; - private BodyResolveContextForLazy(StorageManager storageManager, @NotNull Function declaringScopes) { + private BodyResolveContextForLazy( + @NotNull StorageManager storageManager, + @NotNull ExceptionTracker exceptionTracker, + @NotNull Function declaringScopes) { this.storageManager = storageManager; + this.exceptionTracker = exceptionTracker; this.declaringScopes = declaringScopes; } + @NotNull @Override public StorageManager getStorageManager() { return storageManager; } + @NotNull + @Override + public ExceptionTracker getExceptionTracker() { + return exceptionTracker; + } + @Override public Collection getFiles() { return Collections.emptySet(); diff --git a/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java b/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java index 655bb6b0892..71c3386f521 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java +++ b/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java @@ -34,6 +34,8 @@ import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.asJava.LightClassUtil; +import org.jetbrains.jet.context.ContextPackage; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.*; @@ -44,7 +46,6 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.renderer.DescriptorRenderer; -import org.jetbrains.jet.storage.LockBasedStorageManager; import org.jetbrains.jet.utils.UtilsPackage; import java.io.File; @@ -84,8 +85,10 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { final Runnable initializeRunnable = new Runnable() { @Override public void run() { + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - new LockBasedStorageManager(), + globalContext.getStorageManager(), + globalContext.getExceptionTracker(), Predicates.alwaysFalse(), true, false, Collections.emptyList()); ModuleDescriptorImpl module = new ModuleDescriptorImpl( Name.special(""), Collections.emptyList(), PlatformToKotlinClassMap.EMPTY); diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 4a140724353..f4d8658ff33 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -115,7 +115,7 @@ public class InjectorForTopDownAnalyzerForJs { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); - this.expressionTypingServices = new ExpressionTypingServices(storageManager, platformToKotlinClassMap); + this.expressionTypingServices = new ExpressionTypingServices(getTopDownAnalysisContext(), platformToKotlinClassMap); this.callExpressionResolver = new CallExpressionResolver(); this.typeResolver = new TypeResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index 287dcf5a205..a7050340f66 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -26,6 +26,8 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything; import org.jetbrains.jet.di.InjectorForLazyResolve; +import org.jetbrains.jet.context.ContextPackage; +import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.DependencyKind; @@ -38,8 +40,6 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProv import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.storage.LockBasedStorageManager; -import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; import org.jetbrains.k2js.config.Config; import java.util.Collection; @@ -91,8 +91,9 @@ public final class AnalyzerFacadeForJS { Predicate completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely); + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - new LockBasedStorageManager(), completely, false, false, Collections.emptyList()); + globalContext.getStorageManager(), globalContext.getExceptionTracker(), completely, false, false, Collections.emptyList()); ModuleDescriptor libraryModule = config.getLibraryModule(); if (libraryModule != null) { @@ -154,15 +155,15 @@ public final class AnalyzerFacadeForJS { @NotNull public static ResolveSession getLazyResolveSession(Collection files, Config config) { - LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create(); + GlobalContextImpl globalContext = ContextPackage.GlobalContext(); FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( - storageManager, Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); + globalContext.getStorageManager(), Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); ModuleDescriptorImpl module = createJsModule(""); module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); return new InjectorForLazyResolve( config.getProject(), - storageManager, + globalContext, module, declarationProviderFactory, new BindingTraceContext()).getResolveSession();