diff --git a/compiler/builtins-serializer/src/BuiltInsSerializer.kt b/compiler/builtins-serializer/src/BuiltInsSerializer.kt index 8cbe7f1fc64..3064a250146 100644 --- a/compiler/builtins-serializer/src/BuiltInsSerializer.kt +++ b/compiler/builtins-serializer/src/BuiltInsSerializer.kt @@ -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) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java new file mode 100644 index 00000000000..56a14cbbd36 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -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(""); + 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; + } + +} 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 a7bb58f4a83..73e6de19ad9 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 @@ -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 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 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 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 73c4575914d..d53d0618fa7 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -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 files, JetCoreEnvironment environment) { diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index bdd6e8acae4..8f95a18c2cd 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -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 = generatorForTopDownAnalyzerBasic(), generatorForTopDownAnalyzerForJvm(), generatorForJavaDescriptorResolver(), + generatorForLazyResolveWithJava(), generatorForTopDownAnalyzerForJs(), generatorForMacro(), generatorForTests(), @@ -132,6 +134,34 @@ private fun generatorForJavaDescriptorResolver() = init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) } +private fun generatorForLazyResolveWithJava() = + generator("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForLazyResolveWithJava") { + parameter(javaClass()) + parameter(javaClass(), useAsContext = true) + parameters( + javaClass(), + javaClass() + ) + + publicField(javaClass(), name = "module", useAsContext = true, + init = GivenExpression("org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule(\"\")")) + publicFields( + javaClass(), + javaClass() + ) + + field(javaClass(), + init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) + fields( + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass(), + javaClass() + ) + } + private fun generatorForMacro() = generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros") { parameter(javaClass()) diff --git a/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt b/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt index 1f9e3f13dcf..911cc4b3e10 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt +++ b/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt @@ -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>("KOTLIN_LIGHT_CLASS_CONTEXT_CACHE") - - private val provider = object: CachedValueProvider { - override fun compute(): CachedValueProvider.Result { - 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()