From 732a08f0dff11aed1312187cc9ff0c633ed93044 Mon Sep 17 00:00:00 2001 From: Dmitry Gridin Date: Tue, 28 Jun 2022 13:52:06 +0200 Subject: [PATCH] Revert "[light classes] drop old light classes and backend: iteration #12" This reverts commit 36d1eef6fec6561ccf6861acfd6a4c304ee2feaf. --- .../compiler/CliExtraDiagnosticsProvider.kt | 112 +++++++++++------- .../CliLightClassGenerationSupport.kt | 34 ++++-- .../jvm/compiler/LightClassDataProvider.kt | 45 ++++--- .../jvm/compiler/builder/LightClassBuilder.kt | 27 +++-- .../compiler/builder/LightClassDataHolder.kt | 26 ++++ .../jvm/compiler/duplicateJvmSignatureUtil.kt | 5 +- .../handlers/ClassicDiagnosticsHandler.kt | 4 +- .../kotlin/checkers/BaseDiagnosticsTest.kt | 14 +-- 8 files changed, 170 insertions(+), 97 deletions(-) create mode 100644 compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassDataHolder.kt diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliExtraDiagnosticsProvider.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliExtraDiagnosticsProvider.kt index 2d19617a810..e9ea6c66ffe 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliExtraDiagnosticsProvider.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliExtraDiagnosticsProvider.kt @@ -8,21 +8,24 @@ package org.jetbrains.kotlin.cli.jvm.compiler import com.intellij.openapi.util.Key import com.intellij.psi.search.GlobalSearchScope import com.intellij.psi.util.CachedValue -import com.intellij.psi.util.CachedValueProvider import com.intellij.psi.util.CachedValuesManager -import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport import org.jetbrains.kotlin.asJava.LightClassGenerationSupport import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject import org.jetbrains.kotlin.asJava.classes.shouldNotBeVisibleAsLightClass -import org.jetbrains.kotlin.cli.jvm.compiler.builder.extraJvmDiagnosticsFromBackend +import org.jetbrains.kotlin.cli.jvm.compiler.builder.InvalidLightClassDataHolder +import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassDataHolder +import org.jetbrains.kotlin.cli.jvm.compiler.builder.buildLightClass import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics import org.jetbrains.kotlin.utils.addToStdlib.cast -private val JAVA_API_STUB = Key.create>("JAVA_API_STUB") +private val JAVA_API_STUB = Key.create>("JAVA_API_STUB") +private val JAVA_API_STUB_LOCK = Key.create("JAVA_API_STUB_LOCK") + +private val javaApiStubInitIsRunning: ThreadLocal = ThreadLocal.withInitial { false } object CliExtraDiagnosticsProvider { fun forClassOrObject(kclass: KtClassOrObject): Diagnostics { @@ -30,65 +33,82 @@ object CliExtraDiagnosticsProvider { return Diagnostics.EMPTY } - return getLightClassCachedValue(kclass).value + val lightClassDataHolder = getLightClassCachedValue(kclass).value + return if (lightClassDataHolder is InvalidLightClassDataHolder) { + Diagnostics.EMPTY + } else { + lightClassDataHolder.extraDiagnostics + } } - fun forFacade(file: KtFile): Diagnostics = CachedValuesManager.getCachedValue(file) { - CachedValueProvider.Result.create( - calculateForFacade(file), - KotlinModificationTrackerService.getInstance(file.project).outOfBlockModificationTracker, - ) - } - - private fun calculateForFacade(file: KtFile): Diagnostics { + fun forFacade(file: KtFile, moduleScope: GlobalSearchScope): Diagnostics { val project = file.project val facadeFqName = JvmFileClassUtil.getFileClassInfoNoResolve(file).facadeClassFqName - val facadeCollection = KotlinAsJavaSupport.getInstance(project) - .findFilesForFacade(facadeFqName, GlobalSearchScope.allScope(project)) + val files = KotlinAsJavaSupport.getInstance(project) + .findFilesForFacade(facadeFqName, moduleScope) .ifEmpty { return Diagnostics.EMPTY } - val context = LightClassGenerationSupport.getInstance(project).cast().context - val (_, _, diagnostics) = extraJvmDiagnosticsFromBackend( - facadeFqName.parent(), - facadeCollection, - ClassFilterForFacade, - context, - ) generate@{ state, files -> - val representativeFile = files.first() - val fileClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(representativeFile) - if (!fileClassInfo.withJvmMultifileClass) { - val codegen = state.factory.forPackage(representativeFile.packageFqName, files) - codegen.generate() - state.factory.done() - return@generate - } + return LightClassGenerationSupport.getInstance(project).cast() + .createDataHolderForFacade { constructionContext -> + buildLightClass(facadeFqName.parent(), files, ClassFilterForFacade, constructionContext) generate@{ state, files -> + val representativeFile = files.first() + val fileClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(representativeFile) + if (!fileClassInfo.withJvmMultifileClass) { + val codegen = state.factory.forPackage(representativeFile.packageFqName, files) + codegen.generate() + state.factory.done() + return@generate + } - val codegen = state.factory.forMultifileClass(facadeFqName, files) - codegen.generate() - state.factory.done() - } - - return diagnostics + val codegen = state.factory.forMultifileClass(facadeFqName, files) + codegen.generate() + state.factory.done() + } + }.extraDiagnostics } } -private fun getLightClassCachedValue(classOrObject: KtClassOrObject): CachedValue { +private fun getLightClassCachedValue(classOrObject: KtClassOrObject): CachedValue { val outerClassValue = getOutermostClassOrObject(classOrObject).getUserData(JAVA_API_STUB) outerClassValue?.let { // stub computed for outer class can be used for inner/nested return it } + // the idea behind this locking approach: + // Thread T1 starts to calculate value for A it acquires lock for A + // + // Assumption 1: Lets say A calculation requires another value e.g. B to be calculated + // Assumption 2: Thread T2 wants to calculate value for B - return computeLightClassCachedValue(classOrObject) -} - -private fun computeLightClassCachedValue(classOrObject: KtClassOrObject): CachedValue { - val value = classOrObject.getUserData(JAVA_API_STUB) ?: run { - val manager = CachedValuesManager.getManager(classOrObject.project) - val cachedValue = manager.createCachedValue(LightClassDataProviderForClassOrObject(classOrObject)) - - classOrObject.putUserDataIfAbsent(JAVA_API_STUB, cachedValue) + // to avoid dead-lock case we mark thread as doing calculation and acquire lock only once per thread + // as a trade-off to prevent dependent value could be calculated several time + // due to CAS (within putUserDataIfAbsent etc) the same instance of calculated value will be used + val value: CachedValue = if (!javaApiStubInitIsRunning.get()) { + classOrObject.getUserData(JAVA_API_STUB) ?: run { + val lock = classOrObject.putUserDataIfAbsent(JAVA_API_STUB_LOCK, Object()) + synchronized(lock) { + try { + javaApiStubInitIsRunning.set(true) + computeLightClassCachedValue(classOrObject) + } finally { + javaApiStubInitIsRunning.set(false) + } + } + } + } else { + computeLightClassCachedValue(classOrObject) } return value } + +private fun computeLightClassCachedValue(classOrObject: KtClassOrObject): CachedValue { + val value = classOrObject.getUserData(JAVA_API_STUB) ?: run { + val manager = CachedValuesManager.getManager(classOrObject.project) + val cachedValue = manager.createCachedValue( + LightClassDataProviderForClassOrObject(classOrObject), false + ) + classOrObject.putUserDataIfAbsent(JAVA_API_STUB, cachedValue) + } + return value +} \ No newline at end of file diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt index aa4e8c89530..8ad494ca9da 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.asJava.classes.KtUltraLightSupport import org.jetbrains.kotlin.asJava.classes.cleanFromAnonymousTypes import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.classes.tryGetPredefinedName -import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassConstructionContext +import org.jetbrains.kotlin.cli.jvm.compiler.builder.* import org.jetbrains.kotlin.codegen.ClassBuilderMode import org.jetbrains.kotlin.codegen.JvmCodegenUtil import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper @@ -89,12 +89,30 @@ class CliLightClassGenerationSupport( return ultraLightSupport } - internal val context: LightClassConstructionContext - get() = LightClassConstructionContext( - traceHolder.bindingContext, - traceHolder.module, - traceHolder.languageVersionSettings, - traceHolder.jvmTarget, + fun createDataHolderForClass(classOrObject: KtClassOrObject, builder: LightClassBuilder): LightClassDataHolder.ForClass { + //force resolve companion for light class generation + traceHolder.bindingContext.get(BindingContext.CLASS, classOrObject)?.companionObjectDescriptor + + val (_, bindingContext, diagnostics) = builder(getContext()) + + bindingContext.get(BindingContext.CLASS, classOrObject) ?: return InvalidLightClassDataHolder + + return LightClassDataHolderImpl(diagnostics) + } + + fun createDataHolderForFacade(builder: LightClassBuilder): LightClassDataHolder.ForFacade { + val (_, _, diagnostics) = builder(getContext()) + return LightClassDataHolderImpl(diagnostics) + } + + fun createDataHolderForScript(builder: LightClassBuilder): LightClassDataHolder.ForScript { + val (_, _, diagnostics) = builder(getContext()) + return LightClassDataHolderImpl(diagnostics) + } + + private fun getContext(): LightClassConstructionContext = + LightClassConstructionContext( + traceHolder.bindingContext, traceHolder.module, null /* TODO: traceHolder.languageVersionSettings? */, traceHolder.jvmTarget ) override fun resolveToDescriptor(declaration: KtDeclaration): DeclarationDescriptor? { @@ -107,3 +125,5 @@ class CliLightClassGenerationSupport( override fun analyzeWithContent(element: KtClassOrObject) = traceHolder.bindingContext } + +typealias LightClassBuilder = (LightClassConstructionContext) -> LightClassBuilderResult diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/LightClassDataProvider.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/LightClassDataProvider.kt index c083f481331..226853627e1 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/LightClassDataProvider.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/LightClassDataProvider.kt @@ -12,45 +12,40 @@ import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService import org.jetbrains.kotlin.asJava.LightClassGenerationSupport import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject import org.jetbrains.kotlin.asJava.classes.safeIsLocal -import org.jetbrains.kotlin.cli.jvm.compiler.builder.extraJvmDiagnosticsFromBackend +import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassDataHolder +import org.jetbrains.kotlin.cli.jvm.compiler.builder.buildLightClass import org.jetbrains.kotlin.codegen.MemberCodegen import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.isAncestor -import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics import org.jetbrains.kotlin.utils.addToStdlib.cast import org.jetbrains.org.objectweb.asm.Type internal class LightClassDataProviderForClassOrObject( private val classOrObject: KtClassOrObject -) : CachedValueProvider { - private fun computeLightClassData(): Diagnostics { +) : CachedValueProvider { + private fun computeLightClassData(): LightClassDataHolder.ForClass { val file = classOrObject.containingKtFile val packageFqName = file.packageFqName - val cliSupport = LightClassGenerationSupport.getInstance(classOrObject.project).cast() - - //force resolve companion for light class generation - cliSupport.traceHolder.bindingContext.get(BindingContext.CLASS, classOrObject)?.companionObjectDescriptor - - val (_, bindingContext, diagnostics) = extraJvmDiagnosticsFromBackend( - packageFqName, - listOf(file), - ClassFilterForClassOrObject(classOrObject), - cliSupport.context, - ) { state, files -> - val packageCodegen = state.factory.forPackage(packageFqName, files) - val packagePartType = Type.getObjectType(JvmFileClassUtil.getFileClassInternalName(file)) - val context = state.rootContext.intoPackagePart(packageCodegen.packageFragment, packagePartType, file) - MemberCodegen.genClassOrObject(context, getOutermostClassOrObject(classOrObject), state, null) - state.factory.done() - } - - return diagnostics.takeIf { bindingContext.get(BindingContext.CLASS, classOrObject) != null } ?: Diagnostics.EMPTY + return LightClassGenerationSupport.getInstance(classOrObject.project).cast() + .createDataHolderForClass(classOrObject) { constructionContext -> + buildLightClass( + packageFqName, + listOf(file), + ClassFilterForClassOrObject(classOrObject), + constructionContext + ) { state, files -> + val packageCodegen = state.factory.forPackage(packageFqName, files) + val packagePartType = Type.getObjectType(JvmFileClassUtil.getFileClassInternalName(file)) + val context = state.rootContext.intoPackagePart(packageCodegen.packageFragment, packagePartType, file) + MemberCodegen.genClassOrObject(context, getOutermostClassOrObject(classOrObject), state, null) + state.factory.done() + } + } } - override fun compute(): CachedValueProvider.Result { + override fun compute(): CachedValueProvider.Result { val trackerService = KotlinModificationTrackerService.getInstance(classOrObject.project) return CachedValueProvider.Result.create( computeLightClassData(), diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassBuilder.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassBuilder.kt index 125f68b5c64..8ff6e8dac0b 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassBuilder.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassBuilder.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.cli.jvm.compiler.builder import com.intellij.openapi.diagnostic.Logger import com.intellij.openapi.progress.ProcessCanceledException import com.intellij.openapi.util.SystemInfo +import com.intellij.openapi.util.registry.Registry import com.intellij.openapi.vfs.VirtualFile import com.intellij.psi.impl.compiled.ClsFileImpl import com.intellij.psi.impl.java.stubs.PsiJavaFileStub @@ -22,18 +23,22 @@ import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics -data class CodeGenerationResult(val stub: PsiJavaFileStub, val bindingContext: BindingContext, val diagnostics: Diagnostics) +data class LightClassBuilderResult(val stub: PsiJavaFileStub, val bindingContext: BindingContext, val diagnostics: Diagnostics) -fun extraJvmDiagnosticsFromBackend( +fun buildLightClass( packageFqName: FqName, files: Collection, generateClassFilter: GenerationState.GenerateClassFilter, context: LightClassConstructionContext, - generate: (state: GenerationState, files: Collection) -> Unit, -): CodeGenerationResult { + generate: (state: GenerationState, files: Collection) -> Unit +): LightClassBuilderResult { val project = files.first().project try { + if (Registry.`is`("kotlin.ultra.light.classes.error.on.old.backend", false)) { + error("Access to backend detected") + } + val classBuilderFactory = KotlinLightClassBuilderFactory(createJavaFileStub(packageFqName, files)) val state = GenerationState.Builder( project, @@ -46,7 +51,8 @@ fun extraJvmDiagnosticsFromBackend( put(JVMConfigurationKeys.JVM_TARGET, context.jvmTarget) isReadOnly = true } - } ?: CompilerConfiguration.EMPTY, + } ?: CompilerConfiguration.EMPTY + ).generateDeclaredClassFilter(generateClassFilter).wantsDiagnostics(false).build() state.beforeCompile() state.oldBEInitTrace(files) @@ -54,7 +60,7 @@ fun extraJvmDiagnosticsFromBackend( generate(state, files) val javaFileStub = classBuilderFactory.result() - return CodeGenerationResult(javaFileStub, context.bindingContext, state.collectedExtraJvmDiagnostics) + return LightClassBuilderResult(javaFileStub, context.bindingContext, state.collectedExtraJvmDiagnostics) } catch (e: ProcessCanceledException) { throw e } catch (e: RuntimeException) { @@ -69,9 +75,14 @@ private fun createJavaFileStub(packageFqName: FqName, files: Collection) val fakeFile = object : ClsFileImpl(files.first().viewProvider) { override fun getStub() = javaFileStub + override fun getPackageName() = packageFqName.asString() + override fun isPhysical() = false - override fun getText(): String = files.singleOrNull()?.text ?: super.getText() + + override fun getText(): String { + return files.singleOrNull()?.text ?: super.getText() + } } javaFileStub.psi = fakeFile @@ -87,4 +98,4 @@ private fun logErrorWithOSInfo(cause: Throwable?, fqName: FqName, virtualFile: V ) } -private val LOG = Logger.getInstance(CodeGenerationResult::class.java) \ No newline at end of file +private val LOG = Logger.getInstance(LightClassBuilderResult::class.java) \ No newline at end of file diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassDataHolder.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassDataHolder.kt new file mode 100644 index 00000000000..eeef28470ad --- /dev/null +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassDataHolder.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.cli.jvm.compiler.builder + +import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics + +interface LightClassDataHolder { + val extraDiagnostics: Diagnostics + + interface ForClass : LightClassDataHolder + interface ForFacade : LightClassDataHolder + interface ForScript : ForClass +} + +object InvalidLightClassDataHolder : LightClassDataHolder.ForClass { + override val extraDiagnostics: Diagnostics get() = shouldNotBeCalled() + + private fun shouldNotBeCalled(): Nothing = throw UnsupportedOperationException("Should not be called") +} + +class LightClassDataHolderImpl( + override val extraDiagnostics: Diagnostics +) : LightClassDataHolder.ForClass, LightClassDataHolder.ForFacade, LightClassDataHolder.ForScript diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/duplicateJvmSignatureUtil.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/duplicateJvmSignatureUtil.kt index 78eae32ecc2..cd45b9cd875 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/duplicateJvmSignatureUtil.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/duplicateJvmSignatureUtil.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.cli.jvm.compiler import com.intellij.psi.PsiElement +import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject import org.jetbrains.kotlin.asJava.classes.safeIsScript import org.jetbrains.kotlin.diagnostics.Diagnostic @@ -18,7 +19,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.* import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.* import org.jetbrains.kotlin.utils.addToStdlib.safeAs -fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostics): Diagnostics? { +fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostics, moduleScope: GlobalSearchScope): Diagnostics? { fun getDiagnosticsForClass(ktClassOrObject: KtClassOrObject): Diagnostics { val outermostClass = getOutermostClassOrObject(ktClassOrObject) return CliExtraDiagnosticsProvider.forClassOrObject(outermostClass) @@ -44,7 +45,7 @@ fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostic when (parent) { is KtFile -> { - return CliExtraDiagnosticsProvider.forFacade(parent) + return CliExtraDiagnosticsProvider.forFacade(parent, moduleScope) } is KtClassBody -> { diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt index 25d97a8db49..d011a19a3e0 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.test.frontend.classic.handlers +import com.intellij.psi.search.GlobalSearchScope import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.kotlin.checkers.diagnostics.SyntaxErrorDiagnostic import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil @@ -76,6 +77,7 @@ class ClassicDiagnosticsHandler(testServices: TestServices) : ClassicFrontendAna if (testServices.moduleStructure.modules.any { !it.targetPlatform.isJvm() }) return emptySet() if (REPORT_JVM_DIAGNOSTICS_ON_FRONTEND !in testServices.moduleStructure.allDirectives) return emptySet() val bindingContext = info.analysisResult.bindingContext + val project = info.project val jvmSignatureDiagnostics = HashSet() for (ktFile in info.ktFiles.values) { val declarations = PsiTreeUtil.findChildrenOfType(ktFile, KtDeclaration::class.java) @@ -83,8 +85,8 @@ class ClassicDiagnosticsHandler(testServices: TestServices) : ClassicFrontendAna val diagnostics = getJvmSignatureDiagnostics( declaration, bindingContext.diagnostics, + GlobalSearchScope.allScope(project) ) ?: continue - jvmSignatureDiagnostics.addAll(diagnostics.forElement(declaration)) } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt index 4200b841cce..2f8e5e5f8da 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt @@ -9,6 +9,7 @@ import com.intellij.openapi.project.Project import com.intellij.openapi.util.Condition import com.intellij.openapi.util.Conditions import com.intellij.openapi.util.TextRange +import com.intellij.psi.search.GlobalSearchScope import com.intellij.psi.util.PsiTreeUtil import com.intellij.util.containers.ContainerUtil import org.jetbrains.kotlin.checkers.BaseDiagnosticsTest.TestFile @@ -329,12 +330,10 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava condition = Conditions.or(condition, newCondition) "-" -> condition = Conditions.and(condition, Conditions.not(newCondition)) }