From 36d1eef6fec6561ccf6861acfd6a4c304ee2feaf Mon Sep 17 00:00:00 2001 From: Dmitry Gridin Date: Mon, 27 Jun 2022 14:55:59 +0200 Subject: [PATCH] [light classes] drop old light classes and backend: iteration #12 drop LightClassDataHolder ^KT-48773 --- .../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, 97 insertions(+), 170 deletions(-) delete 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 e9ea6c66ffe..2d19617a810 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,24 +8,21 @@ 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.InvalidLightClassDataHolder -import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassDataHolder -import org.jetbrains.kotlin.cli.jvm.compiler.builder.buildLightClass +import org.jetbrains.kotlin.cli.jvm.compiler.builder.extraJvmDiagnosticsFromBackend 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_LOCK = Key.create("JAVA_API_STUB_LOCK") - -private val javaApiStubInitIsRunning: ThreadLocal = ThreadLocal.withInitial { false } +private val JAVA_API_STUB = Key.create>("JAVA_API_STUB") object CliExtraDiagnosticsProvider { fun forClassOrObject(kclass: KtClassOrObject): Diagnostics { @@ -33,82 +30,65 @@ object CliExtraDiagnosticsProvider { return Diagnostics.EMPTY } - val lightClassDataHolder = getLightClassCachedValue(kclass).value - return if (lightClassDataHolder is InvalidLightClassDataHolder) { - Diagnostics.EMPTY - } else { - lightClassDataHolder.extraDiagnostics - } + return getLightClassCachedValue(kclass).value } - fun forFacade(file: KtFile, moduleScope: GlobalSearchScope): Diagnostics { + fun forFacade(file: KtFile): Diagnostics = CachedValuesManager.getCachedValue(file) { + CachedValueProvider.Result.create( + calculateForFacade(file), + KotlinModificationTrackerService.getInstance(file.project).outOfBlockModificationTracker, + ) + } + + private fun calculateForFacade(file: KtFile): Diagnostics { val project = file.project val facadeFqName = JvmFileClassUtil.getFileClassInfoNoResolve(file).facadeClassFqName - val files = KotlinAsJavaSupport.getInstance(project) - .findFilesForFacade(facadeFqName, moduleScope) + val facadeCollection = KotlinAsJavaSupport.getInstance(project) + .findFilesForFacade(facadeFqName, GlobalSearchScope.allScope(project)) .ifEmpty { return Diagnostics.EMPTY } - 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 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 + } - val codegen = state.factory.forMultifileClass(facadeFqName, files) - codegen.generate() - state.factory.done() - } - }.extraDiagnostics + val codegen = state.factory.forMultifileClass(facadeFqName, files) + codegen.generate() + state.factory.done() + } + + return diagnostics } } -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 - // 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 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) } 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 8ad494ca9da..aa4e8c89530 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.* +import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassConstructionContext import org.jetbrains.kotlin.codegen.ClassBuilderMode import org.jetbrains.kotlin.codegen.JvmCodegenUtil import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper @@ -89,30 +89,12 @@ class CliLightClassGenerationSupport( return ultraLightSupport } - 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 + internal val context: LightClassConstructionContext + get() = LightClassConstructionContext( + traceHolder.bindingContext, + traceHolder.module, + traceHolder.languageVersionSettings, + traceHolder.jvmTarget, ) override fun resolveToDescriptor(declaration: KtDeclaration): DeclarationDescriptor? { @@ -125,5 +107,3 @@ 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 226853627e1..c083f481331 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,40 +12,45 @@ 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.LightClassDataHolder -import org.jetbrains.kotlin.cli.jvm.compiler.builder.buildLightClass +import org.jetbrains.kotlin.cli.jvm.compiler.builder.extraJvmDiagnosticsFromBackend 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(): LightClassDataHolder.ForClass { +) : CachedValueProvider { + private fun computeLightClassData(): Diagnostics { val file = classOrObject.containingKtFile val packageFqName = file.packageFqName - 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() - } - } + 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 } - 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 8ff6e8dac0b..125f68b5c64 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,7 +8,6 @@ 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 @@ -23,22 +22,18 @@ import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics -data class LightClassBuilderResult(val stub: PsiJavaFileStub, val bindingContext: BindingContext, val diagnostics: Diagnostics) +data class CodeGenerationResult(val stub: PsiJavaFileStub, val bindingContext: BindingContext, val diagnostics: Diagnostics) -fun buildLightClass( +fun extraJvmDiagnosticsFromBackend( packageFqName: FqName, files: Collection, generateClassFilter: GenerationState.GenerateClassFilter, context: LightClassConstructionContext, - generate: (state: GenerationState, files: Collection) -> Unit -): LightClassBuilderResult { + generate: (state: GenerationState, files: Collection) -> Unit, +): CodeGenerationResult { 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, @@ -51,8 +46,7 @@ fun buildLightClass( put(JVMConfigurationKeys.JVM_TARGET, context.jvmTarget) isReadOnly = true } - } ?: CompilerConfiguration.EMPTY - + } ?: CompilerConfiguration.EMPTY, ).generateDeclaredClassFilter(generateClassFilter).wantsDiagnostics(false).build() state.beforeCompile() state.oldBEInitTrace(files) @@ -60,7 +54,7 @@ fun buildLightClass( generate(state, files) val javaFileStub = classBuilderFactory.result() - return LightClassBuilderResult(javaFileStub, context.bindingContext, state.collectedExtraJvmDiagnostics) + return CodeGenerationResult(javaFileStub, context.bindingContext, state.collectedExtraJvmDiagnostics) } catch (e: ProcessCanceledException) { throw e } catch (e: RuntimeException) { @@ -75,14 +69,9 @@ 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 { - return files.singleOrNull()?.text ?: super.getText() - } + override fun getText(): String = files.singleOrNull()?.text ?: super.getText() } javaFileStub.psi = fakeFile @@ -98,4 +87,4 @@ private fun logErrorWithOSInfo(cause: Throwable?, fqName: FqName, virtualFile: V ) } -private val LOG = Logger.getInstance(LightClassBuilderResult::class.java) \ No newline at end of file +private val LOG = Logger.getInstance(CodeGenerationResult::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 deleted file mode 100644 index eeef28470ad..00000000000 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassDataHolder.kt +++ /dev/null @@ -1,26 +0,0 @@ -/* - * 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 cd45b9cd875..78eae32ecc2 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,7 +6,6 @@ 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 @@ -19,7 +18,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, moduleScope: GlobalSearchScope): Diagnostics? { +fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostics): Diagnostics? { fun getDiagnosticsForClass(ktClassOrObject: KtClassOrObject): Diagnostics { val outermostClass = getOutermostClassOrObject(ktClassOrObject) return CliExtraDiagnosticsProvider.forClassOrObject(outermostClass) @@ -45,7 +44,7 @@ fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostic when (parent) { is KtFile -> { - return CliExtraDiagnosticsProvider.forFacade(parent, moduleScope) + return CliExtraDiagnosticsProvider.forFacade(parent) } 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 d011a19a3e0..25d97a8db49 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,7 +5,6 @@ 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 @@ -77,7 +76,6 @@ 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) @@ -85,8 +83,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 2f8e5e5f8da..4200b841cce 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt @@ -9,7 +9,6 @@ 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 @@ -330,10 +329,12 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava condition = Conditions.or(condition, newCondition) "-" -> condition = Conditions.and(condition, Conditions.not(newCondition)) }