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

Common injector for lazy resolve with java lazy resolve

Browse Source
This commit is contained in:
Nikolay Krasko
2014-02-05 15:08:26 +04:00
parent 2ef879ea3e
commit a2c567da93
6 changed files with 275 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/builtins-serializer/src/BuiltInsSerializer.kt
+3 -4
View File
@@ -72,10 +72,9 @@ public class BuiltInsSerializer(val out: PrintStream?) {
val files = environment.getSourceFiles() ?: error("No source files in $sourceRoots")
val project = environment.getProject()
val trace = BindingTraceContext()
val session = AnalyzerFacadeForJVM.createLazyResolveSession(project, files, trace,
InjectorForJavaDescriptorResolverUtil.create(project, trace), false)
val module = session.getModuleDescriptor() ?: error("No module resolved for $sourceRoots")
val session = AnalyzerFacadeForJVM.createLazyResolveSession(project, files, BindingTraceContext(), false)
val module = session.getModuleDescriptor()
if (!FileUtil.delete(destDir)) {
System.err.println("Could not delete: " + destDir)
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java
+219
View File
@@ -0,0 +1,219 @@
/*
* 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.di;
import com.intellij.openapi.project.Project;
import org.jetbrains.jet.context.GlobalContextImpl;
import org.jetbrains.jet.storage.LockBasedStorageManager;
import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.LazyResolveBasedCache;
import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
import org.jetbrains.jet.lang.resolve.AnnotationResolver;
import org.jetbrains.jet.lang.resolve.calls.CallResolver;
import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver;
import org.jetbrains.jet.lang.resolve.TypeResolver;
import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
import org.jetbrains.jet.lang.psi.JetImportsFactory;
import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
import org.jetbrains.annotations.NotNull;
import javax.annotation.PreDestroy;
/* This file is generated by org.jetbrains.jet.generators.injectors.InjectorsPackage. DO NOT EDIT! */
@SuppressWarnings("ALL")
public class InjectorForLazyResolveWithJava {
private final Project project;
private final GlobalContextImpl globalContext;
private final LockBasedStorageManager lockBasedStorageManager;
private final DeclarationProviderFactory declarationProviderFactory;
private final BindingTrace bindingTrace;
private final ModuleDescriptorImpl module;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final ResolveSession resolveSession;
private final JavaDescriptorResolver javaDescriptorResolver;
private final VirtualFileFinder virtualFileFinder;
private final JavaClassFinderImpl javaClassFinder;
private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
private final LazyResolveBasedCache lazyResolveBasedCache;
private final TraceBasedErrorReporter traceBasedErrorReporter;
private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final TypeResolver typeResolver;
private final QualifiedExpressionResolver qualifiedExpressionResolver;
private final CallResolverExtensionProvider callResolverExtensionProvider;
private final CandidateResolver candidateResolver;
private final JetImportsFactory jetImportsFactory;
private final ScopeProvider scopeProvider;
private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
private final GlobalJavaResolverContext globalJavaResolverContext;
private final DeserializedDescriptorResolver deserializedDescriptorResolver;
private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
public InjectorForLazyResolveWithJava(
@NotNull Project project,
@NotNull GlobalContextImpl globalContext,
@NotNull DeclarationProviderFactory declarationProviderFactory,
@NotNull BindingTrace bindingTrace
) {
this.project = project;
this.globalContext = globalContext;
this.lockBasedStorageManager = globalContext.getStorageManager();
this.declarationProviderFactory = declarationProviderFactory;
this.bindingTrace = bindingTrace;
this.module = org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule("<fake-jdr-module>");
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
this.javaClassFinder = new JavaClassFinderImpl();
this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
this.traceBasedErrorReporter = new TraceBasedErrorReporter();
this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
this.lazyResolveBasedCache = new LazyResolveBasedCache();
this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache);
this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
this.argumentTypeResolver = new ArgumentTypeResolver();
this.expressionTypingServices = new ExpressionTypingServices(globalContext, platformToKotlinClassMap);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.typeResolver = new TypeResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.callResolverExtensionProvider = new CallResolverExtensionProvider();
this.candidateResolver = new CandidateResolver();
this.jetImportsFactory = new JetImportsFactory();
this.scopeProvider = new ScopeProvider(getResolveSession());
this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(lockBasedStorageManager);
this.resolveSession.setAnnotationResolve(annotationResolver);
this.resolveSession.setDescriptorResolver(descriptorResolver);
this.resolveSession.setJetImportFactory(jetImportsFactory);
this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
this.resolveSession.setScopeProvider(scopeProvider);
this.resolveSession.setTypeResolver(typeResolver);
javaClassFinder.setProject(project);
traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
traceBasedExternalSignatureResolver.setTrace(bindingTrace);
lazyResolveBasedCache.setSession(resolveSession);
traceBasedErrorReporter.setTrace(bindingTrace);
psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
annotationResolver.setCallResolver(callResolver);
annotationResolver.setExpressionTypingServices(expressionTypingServices);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCandidateResolver(candidateResolver);
callResolver.setExpressionTypingServices(expressionTypingServices);
callResolver.setTypeResolver(typeResolver);
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setTypeResolver(typeResolver);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
descriptorResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setStorageManager(lockBasedStorageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
typeResolver.setAnnotationResolver(annotationResolver);
typeResolver.setModuleDescriptor(module);
typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
jetImportsFactory.setProject(project);
deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer);
deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
annotationDescriptorDeserializer.setJavaDescriptorResolver(javaDescriptorResolver);
annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
javaClassFinder.initialize();
}
@PreDestroy
public void destroy() {
}
public ModuleDescriptorImpl getModule() {
return this.module;
}
public ResolveSession getResolveSession() {
return this.resolveSession;
}
public JavaDescriptorResolver getJavaDescriptorResolver() {
return this.javaDescriptorResolver;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java
+16 -12
View File
@@ -28,9 +28,7 @@ import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
import org.jetbrains.jet.context.ContextPackage;
import org.jetbrains.jet.context.GlobalContext;
import org.jetbrains.jet.context.GlobalContextImpl;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
import org.jetbrains.jet.di.InjectorForLazyResolve;
import org.jetbrains.jet.di.InjectorForLazyResolveWithJava;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -86,9 +84,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
@NotNull
@Override
public ResolveSession getLazyResolveSession(@NotNull Project fileProject, @NotNull Collection<JetFile> files) {
BindingTraceContext javaResolverTrace = new BindingTraceContext();
InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(fileProject, javaResolverTrace);
return createLazyResolveSession(fileProject, files, javaResolverTrace, injector, true);
return createLazyResolveSession(fileProject, files, new BindingTraceContext(), true);
}
@NotNull
@@ -96,23 +92,31 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
@NotNull Project project,
@NotNull Collection<JetFile> files,
@NotNull BindingTrace trace,
@NotNull InjectorForJavaDescriptorResolver injector,
boolean addBuiltIns
) {
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
// TODO: Replace with stub declaration provider
GlobalContextImpl globalContext = injector.getGlobalContext();
FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
globalContext.getStorageManager(),
files);
ModuleDescriptorImpl module = injector.getModule();
InjectorForLazyResolveWithJava resolveWithJava = new InjectorForLazyResolveWithJava(
project,
globalContext,
declarationProviderFactory,
trace);
resolveWithJava.getModule().addFragmentProvider(
DependencyKind.BINARIES, resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider());
if (addBuiltIns) {
module.addFragmentProvider(DependencyKind.BUILT_INS,
KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
resolveWithJava.getModule().addFragmentProvider(
DependencyKind.BUILT_INS,
KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
}
return new InjectorForLazyResolve(project, globalContext, module, declarationProviderFactory, trace).getResolveSession();
return resolveWithJava.getResolveSession();
}
@NotNull
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java
+5 -6
View File
@@ -1,5 +1,5 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
* 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.
@@ -26,8 +26,6 @@ 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;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
@@ -79,10 +77,11 @@ public class LazyResolveTestUtil {
Project project = environment.getProject();
CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(project);
BindingTrace sharedTrace = support.getTrace();
InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, sharedTrace);
support.setModule(injector.getModule());
return AnalyzerFacadeForJVM.createLazyResolveSession(project, files, sharedTrace, injector, addBuiltIns);
ResolveSession lazyResolveSession = AnalyzerFacadeForJVM.createLazyResolveSession(project, files, sharedTrace, addBuiltIns);
support.setModule((ModuleDescriptorImpl)lazyResolveSession.getModuleDescriptor());
return lazyResolveSession;
}
public static ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment) {
generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt
+30
View File
@@ -33,6 +33,7 @@ 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.di.*
import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider
// NOTE: After making changes, you need to re-generate the injectors.
// To do that, you can run main in this file.
@@ -53,6 +54,7 @@ public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
generatorForTopDownAnalyzerBasic(),
generatorForTopDownAnalyzerForJvm(),
generatorForJavaDescriptorResolver(),
generatorForLazyResolveWithJava(),
generatorForTopDownAnalyzerForJs(),
generatorForMacro(),
generatorForTests(),
@@ -132,6 +134,34 @@ private fun generatorForJavaDescriptorResolver() =
init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
}
private fun generatorForLazyResolveWithJava() =
generator("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForLazyResolveWithJava") {
parameter(javaClass<Project>())
parameter(javaClass<GlobalContextImpl>(), useAsContext = true)
parameters(
javaClass<DeclarationProviderFactory>(),
javaClass<BindingTrace>()
)
publicField(javaClass<ModuleDescriptorImpl>(), name = "module", useAsContext = true,
init = GivenExpression("org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule(\"<fake-jdr-module>\")"))
publicFields(
javaClass<ResolveSession>(),
javaClass<JavaDescriptorResolver>()
)
field(javaClass<VirtualFileFinder>(),
init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
fields(
javaClass<JavaClassFinderImpl>(),
javaClass<TraceBasedExternalSignatureResolver>(),
javaClass<LazyResolveBasedCache>(),
javaClass<TraceBasedErrorReporter>(),
javaClass<PsiBasedMethodSignatureChecker>(),
javaClass<PsiBasedExternalAnnotationResolver>()
)
}
private fun generatorForMacro() =
generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros") {
parameter(javaClass<Project>())
idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt
+2 -37
View File
@@ -16,52 +16,17 @@
package org.jetbrains.jet.asJava
import com.intellij.psi.util.CachedValueProvider
import com.intellij.psi.util.CachedValueProvider.Result
import org.jetbrains.jet.lang.resolve.BindingContext
import org.jetbrains.jet.lang.psi.JetClassOrObject
import com.intellij.openapi.project.Project
import org.jetbrains.jet.lang.psi.JetPsiUtil
import com.intellij.openapi.util.Key
import com.intellij.psi.util.PsiModificationTracker
import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager
import org.jetbrains.jet.plugin.project.ResolveElementCache
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM
import com.intellij.psi.util.CachedValuesManager
import com.intellij.psi.util.CachedValue
import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace
import org.jetbrains.jet.lang.resolve.java.JetFilesProvider
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil
import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
class KotlinLightClassContextCache(val project: Project) {
private val cacheKey = Key.create<CachedValue<ResolveElementCache>>("KOTLIN_LIGHT_CLASS_CONTEXT_CACHE")
private val provider = object: CachedValueProvider<ResolveElementCache> {
override fun compute(): CachedValueProvider.Result<ResolveElementCache> {
val trace = DelegatingBindingTrace(
KotlinCacheManager.getInstance(project).getPossiblyIncompleteDeclarationsForLightClassGeneration().getBindingContext(),
"Trace for KotlinLightClassContextCache"
)
val resolveSession = AnalyzerFacadeForJVM.createLazyResolveSession(
project,
JetFilesProvider.getInstance(project)!!.allInScope(GlobalSearchScope.allScope(project)),
trace,
InjectorForJavaDescriptorResolverUtil.create(project, trace),
true
)
return Result.create(
ResolveElementCache(resolveSession, project),
PsiModificationTracker.MODIFICATION_COUNT,
KotlinCacheManager.getInstance(project).getDeclarationsTracker()
)
}
}
public fun getLightClassBindingContext(classOrObject: JetClassOrObject): BindingContext {
if (JetPsiUtil.isLocal(classOrObject)) {
val resolveElementCache = CachedValuesManager.getManager(project).getCachedValue(project, cacheKey, provider, false)
return resolveElementCache?.resolveToElement(classOrObject) ?: BindingContext.EMPTY
return AnalyzerFacadeWithCache.getContextForElement(classOrObject)
}
return KotlinCacheManager.getInstance(project).getPossiblyIncompleteDeclarationsForLightClassGeneration().getBindingContext()