azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

StorageManager&ExceptionTracker delivered where needed

Browse Source 
- GlobalContext introduced to group the two
- Caches track exceptions
This commit is contained in:
Andrey Breslav
2014-02-03 18:30:16 +04:00
parent 364182e3f0
commit e60bd514fa
36 changed files with 284 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java
+3
View File
@@ -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();
compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java
+2
View File
@@ -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("<repl>");
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
new LockBasedStorageManager(),
new ExceptionTracker(), // dummy
Predicates.<PsiFile>alwaysTrue(),
false,
true,
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java
+9 -9
View File
@@ -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() {
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
+1 -1
View File
@@ -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();
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java
+21 -11
View File
@@ -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<FqName>() {
@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<FqName>() {
@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 {
compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java
+7 -1
View File
@@ -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);
compiler/frontend/src/org/jetbrains/jet/context/context.kt
+36
View File
@@ -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)
}
compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java
+1 -1
View File
@@ -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();
compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java
+10 -7
View File
@@ -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);
compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java
+8 -5
View File
@@ -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);
compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java
+1 -1
View File
@@ -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();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java
+8 -1
View File
@@ -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<JetFile> getFiles();
Map<JetClassOrObject, MutableClassDescriptor> getClasses();
Map<JetProperty, PropertyDescriptor> getProperties();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java
+6
View File
@@ -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<JetFile> getFiles() {
return files;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
+6
View File
@@ -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<JetFile> getFiles() {
return packageFragments.keySet();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java
+12
View File
@@ -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<PsiFile> 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<PsiFile> analyzeCompletely,
boolean analyzingBootstrapLibrary,
boolean declaredLocally,
@NotNull List<AnalyzerScriptParameter> 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<PsiFile> getAnalyzeCompletely() {
return analyzeCompletely;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
+10 -4
View File
@@ -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.<AnalyzerScriptParameter>emptyList());
new TopDownAnalysisParameters(
globalContext.getStorageManager(),
globalContext.getExceptionTracker(),
Predicates.equalTo(object.getContainingFile()),
false,
true,
Collections.<AnalyzerScriptParameter>emptyList()
);
InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
object.getProject(), topDownAnalysisParameters, new ObservableBindingTrace(context.trace),
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java
+10 -4
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java
+9 -6
View File
@@ -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<PsiElement, ClassDescriptor> 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<JetType>() {
@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(),
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java
+7 -7
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java
+11 -11
View File
@@ -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<JetTypeInfo, ExpressionTypingContext> 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 JetVisitor<JetTypeInfo, E
}
private ExpressionTypingVisitorForStatements createStatementVisitor(ExpressionTypingContext context) {
return new ExpressionTypingVisitorForStatements(storageManager, this,
return new ExpressionTypingVisitorForStatements(globalContext, this,
ExpressionTypingUtils.newWritableScopeImpl(context, "statement scope"),
basic, controlStructures, patterns);
}
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java
+10 -7
View File
@@ -20,7 +20,11 @@ import com.google.common.collect.Sets;
import com.intellij.psi.tree.IElementType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.context.GlobalContext;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.evaluate.EvaluatePackage;
import org.jetbrains.jet.lang.psi.*;
@@ -39,7 +43,6 @@ import org.jetbrains.jet.lang.types.JetTypeInfo;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lexer.JetTokens;
import org.jetbrains.jet.storage.StorageManager;
import java.util.Collection;
@@ -52,21 +55,21 @@ import static org.jetbrains.jet.lang.types.TypeUtils.noExpectedType;
@SuppressWarnings("SuspiciousMethodCalls")
public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisitor {
private final StorageManager storageManager;
private final GlobalContext globalContext;
private final WritableScope scope;
private final BasicExpressionTypingVisitor basic;
private final ControlStructureTypingVisitor controlStructures;
private final PatternMatchingTypingVisitor patterns;
public ExpressionTypingVisitorForStatements(
@NotNull StorageManager storageManager,
@NotNull GlobalContext globalContext,
@NotNull ExpressionTypingInternals facade,
@NotNull WritableScope scope,
BasicExpressionTypingVisitor basic,
@NotNull ControlStructureTypingVisitor controlStructures,
@NotNull PatternMatchingTypingVisitor patterns) {
super(facade);
this.storageManager = storageManager;
this.globalContext = globalContext;
this.scope = scope;
this.basic = basic;
this.controlStructures = controlStructures;
@@ -90,7 +93,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
@Override
public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
TopDownAnalyzer.processClassOrObject(
storageManager,
globalContext,
scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration);
return DataFlowUtils.checkStatementType(declaration, context, context.dataFlowInfo);
}
@@ -185,7 +188,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
@Override
public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
TopDownAnalyzer.processClassOrObject(
storageManager,
globalContext,
scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass);
return DataFlowUtils.checkStatementType(klass, context, context.dataFlowInfo);
}
compiler/frontend/src/org/jetbrains/jet/storage/LockBasedStorageManagerWithExceptionTracking.java
-38
View File
@@ -1,38 +0,0 @@
/*
* 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.storage;
import org.jetbrains.annotations.NotNull;
public class LockBasedStorageManagerWithExceptionTracking extends LockBasedStorageManager {
@NotNull
public static LockBasedStorageManagerWithExceptionTracking create() {
return new LockBasedStorageManagerWithExceptionTracking(new ExceptionTracker());
}
private final ExceptionTracker tracker;
public LockBasedStorageManagerWithExceptionTracking(@NotNull ExceptionTracker tracker) {
super(tracker);
this.tracker = tracker;
}
@NotNull
public ExceptionTracker getTracker() {
return tracker;
}
}
compiler/tests/org/jetbrains/jet/di/InjectorForTests.java
+8 -5
View File
@@ -21,9 +21,10 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
import org.jetbrains.jet.lang.resolve.TypeResolver;
import org.jetbrains.jet.lang.resolve.calls.CallResolver;
import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
import org.jetbrains.jet.storage.LockBasedStorageManager;
import org.jetbrains.jet.storage.StorageManager;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.context.GlobalContext;
import com.intellij.openapi.project.Project;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.resolve.AnnotationResolver;
@@ -44,9 +45,10 @@ public class InjectorForTests {
private final TypeResolver typeResolver;
private final CallResolver callResolver;
private final CallResolverExtensionProvider callResolverExtensionProvider;
private final LockBasedStorageManager lockBasedStorageManager;
private final StorageManager storageManager;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final GlobalContext globalContext;
private final Project project;
private final ModuleDescriptor moduleDescriptor;
private final AnnotationResolver annotationResolver;
@@ -61,12 +63,13 @@ public class InjectorForTests {
@NotNull ModuleDescriptor moduleDescriptor
) {
this.descriptorResolver = new DescriptorResolver();
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.typeResolver = new TypeResolver();
this.callResolver = new CallResolver();
this.callResolverExtensionProvider = new CallResolverExtensionProvider();
this.storageManager = globalContext.getStorageManager();
this.kotlinBuiltIns = KotlinBuiltIns.getInstance();
this.project = project;
this.moduleDescriptor = moduleDescriptor;
@@ -80,7 +83,7 @@ public class InjectorForTests {
this.descriptorResolver.setAnnotationResolver(annotationResolver);
this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
this.descriptorResolver.setStorageManager(lockBasedStorageManager);
this.descriptorResolver.setStorageManager(storageManager);
this.descriptorResolver.setTypeResolver(typeResolver);
this.expressionTypingServices.setAnnotationResolver(annotationResolver);
compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java
+8 -1
View File
@@ -35,6 +35,7 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClass
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.storage.ExceptionTracker;
import org.jetbrains.jet.storage.LockBasedStorageManager;
import org.jetbrains.jet.test.TestCaseWithTmpdir;
import org.jetbrains.jet.test.util.RecursiveDescriptorComparator;
@@ -142,7 +143,13 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm(
environment.getProject(),
new TopDownAnalysisParameters(
new LockBasedStorageManager(), Predicates.<PsiFile>alwaysFalse(), false, false, Collections.<AnalyzerScriptParameter>emptyList()),
new LockBasedStorageManager(),
new ExceptionTracker(), // dummy
Predicates.<PsiFile>alwaysFalse(),
false,
false,
Collections.<AnalyzerScriptParameter>emptyList()
),
trace,
module);
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java
+5 -4
View File
@@ -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("<lazy module>");
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<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java
+4 -2
View File
@@ -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.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
globalContext.getStorageManager(), globalContext.getExceptionTracker(), Predicates.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject());
BindingTrace sharedTrace = support.getTrace();
ModuleDescriptorImpl sharedModule = support.getModule();
core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java
+1
View File
@@ -59,6 +59,7 @@ public class LockBasedStorageManager implements StorageManager {
}
};
@NotNull
public static LockBasedStorageManager createWithExceptionHandling(@NotNull ExceptionHandlingStrategy exceptionHandlingStrategy) {
return new LockBasedStorageManager(exceptionHandlingStrategy);
}
generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java
+12 -6
View File
@@ -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",
idea/src/org/jetbrains/jet/plugin/caches/resolve/JSDeclarationsCacheProvider.java
+1 -1
View File
@@ -77,7 +77,7 @@ class JSDeclarationsCacheProvider extends DeclarationsCacheProvider {
project,
cachedKey,
declarationsProvider,
false
true
);
}
}
idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java
+1 -1
View File
@@ -105,7 +105,7 @@ class JvmDeclarationsCacheProvider extends DeclarationsCacheProvider {
project,
cachedKey,
declarationsProvider,
false
true
);
}
}
idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinDeclarationsCacheImpl.java
+10 -1
View File
@@ -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;
idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java
+5 -4
View File
@@ -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<FqName>() {
@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();
idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java
+28 -13
View File
@@ -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<JetDeclaration, JetScope>() {
@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.<PsiFile>alwaysTrue(), false, true, Collections.<AnalyzerScriptParameter>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.<JetScope>constant(null)), module);
return createBodyResolver(trace, file,
new BodyResolveContextForLazy(
resolveSession.getStorageManager(),
resolveSession.getExceptionTracker(),
Functions.<JetScope>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<? super JetDeclaration, JetScope> declaringScopes;
private BodyResolveContextForLazy(StorageManager storageManager, @NotNull Function<? super JetDeclaration, JetScope> declaringScopes) {
private BodyResolveContextForLazy(
@NotNull StorageManager storageManager,
@NotNull ExceptionTracker exceptionTracker,
@NotNull Function<? super JetDeclaration, JetScope> 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<JetFile> getFiles() {
return Collections.emptySet();
idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java
+5 -2
View File
@@ -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.<PsiFile>alwaysFalse(), true, false, Collections.<AnalyzerScriptParameter>emptyList());
ModuleDescriptorImpl module = new ModuleDescriptorImpl(
Name.special("<fake_module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY);
js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java
+1 -1
View File
@@ -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();
js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java
+7 -6
View File
@@ -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<PsiFile> completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely);
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
new LockBasedStorageManager(), completely, false, false, Collections.<AnalyzerScriptParameter>emptyList());
globalContext.getStorageManager(), globalContext.getExceptionTracker(), completely, false, false, Collections.<AnalyzerScriptParameter>emptyList());
ModuleDescriptor libraryModule = config.getLibraryModule();
if (libraryModule != null) {
@@ -154,15 +155,15 @@ public final class AnalyzerFacadeForJS {
@NotNull
public static ResolveSession getLazyResolveSession(Collection<JetFile> files, Config config) {
LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create();
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
globalContext.getStorageManager(), Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
ModuleDescriptorImpl module = createJsModule("<lazy module>");
module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
return new InjectorForLazyResolve(
config.getProject(),
storageManager,
globalContext,
module,
declarationProviderFactory,
new BindingTraceContext()).getResolveSession();