From 8db6e535b825e7d47c7134394ce48294359605c0 Mon Sep 17 00:00:00 2001 From: Roman Borodavkin Date: Thu, 13 Aug 2026 21:58:39 +0300 Subject: [PATCH 1/3] fix(completion): filter dictionary properties by term kind - Centralize term enumeration and Cocoa filtering in an internal dictionary catalog - Cover the real completion path with a same-name property and command collision Impact: Imported properties remain available unless Cocoa defines the same property --- .../AppleScriptDictionaryResolveProcessor.kt | 89 +++++-------- .../lang/sdef/DictionaryTermCatalog.kt | 30 +++++ .../test/sdef/DictionaryTermCatalogTest.kt | 117 ++++++++++++++++++ 3 files changed, 176 insertions(+), 60 deletions(-) create mode 100644 src/main/kotlin/com/intellij/plugin/applescript/lang/sdef/DictionaryTermCatalog.kt create mode 100644 src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt diff --git a/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt b/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt index cfaccd6f..7b4d986c 100644 --- a/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt +++ b/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt @@ -7,6 +7,7 @@ import com.intellij.openapi.util.KeyWithDefaultValue import com.intellij.plugin.applescript.lang.dictionary.project.AppleScriptProjectDictionaryService import com.intellij.plugin.applescript.lang.sdef.ApplicationDictionary import com.intellij.plugin.applescript.lang.sdef.DictionaryComponent +import com.intellij.plugin.applescript.lang.sdef.DictionaryTermCatalog import com.intellij.plugin.applescript.psi.AppleScriptBuiltInClassIdentifier import com.intellij.plugin.applescript.psi.AppleScriptDictionaryClassIdentifierPlural import com.intellij.plugin.applescript.psi.AppleScriptDictionaryClassName @@ -182,20 +183,20 @@ class AppleScriptDictionaryResolveProcessor : AppleScriptPsiScopeProcessor { fun getFilteredResult(): List { val result = ArrayList() - var filterStdCocoaTerminologyFlag = false // true once we've collected from a non-additions dictionary + var shouldFilterCocoa = false val dictionaryRegistry = myProject.getService(AppleScriptProjectDictionaryService::class.java) for (collectedDictionary in collectedDictionaries) { - collectAllComponentsFromDictionary(collectedDictionary, result, filterStdCocoaTerminologyFlag) - filterStdCocoaTerminologyFlag = filterStdCocoaTerminologyFlag || + collectTerms(collectedDictionary, result, shouldFilterCocoa) + shouldFilterCocoa = shouldFilterCocoa || collectedDictionary.getName() != ApplicationDictionary.SCRIPTING_ADDITIONS_LIBRARY } if (dictionaryRegistry != null) { - appendResultsIfNeeded( + appendFallbackTerms( result, myProject, mySortedUseStatements.isNotEmpty(), collectedDictionaries.contains(dictionaryRegistry.getScriptingAdditionsTerminology()), - filterStdCocoaTerminologyFlag, + shouldFilterCocoa, ) } return result @@ -211,81 +212,49 @@ class AppleScriptDictionaryResolveProcessor : AppleScriptPsiScopeProcessor { private val LOG: Logger = Logger.getInstance("#${AppleScriptDictionaryResolveProcessor::class.java.name}") - private fun appendResultsIfNeeded( + private fun appendFallbackTerms( result: MutableCollection, project: Project, - areThereUseStatements: Boolean, - filterStandardAdditions: Boolean, - filterCocoaStandard: Boolean, + hasUseStatements: Boolean, + shouldFilterAdditions: Boolean, + shouldFilterCocoa: Boolean, ) { val dictionaryRegistry = project.getService(AppleScriptProjectDictionaryService::class.java) ?: return - if (!filterStandardAdditions && !areThereUseStatements) { + if (!shouldFilterAdditions && !hasUseStatements) { val scriptAdditions = dictionaryRegistry.getScriptingAdditionsTerminology() - collectAllComponentsFromDictionary(scriptAdditions, result, false) + collectTerms(scriptAdditions, result, false) } - if (!filterCocoaStandard) { + if (!shouldFilterCocoa) { val cocoaStandardTerminology = dictionaryRegistry.getCocoaStandardTerminology() - collectAllComponentsFromDictionary(cocoaStandardTerminology, result, false) + collectTerms(cocoaStandardTerminology, result, false) } } /** - * Gather all term declarations from [importedDict]. + * Gather all term declarations from [dictionary]. * - * @param withCocoaStdLibFiltering if true, omit terms already present in the Standard Terminology + * @param shouldFilterCocoa if true, omit terms already present in the Standard Terminology */ - private fun collectAllComponentsFromDictionary( - importedDict: ApplicationDictionary?, + private fun collectTerms( + dictionary: ApplicationDictionary?, dictionaryComponents: MutableCollection, - withCocoaStdLibFiltering: Boolean, + shouldFilterCocoa: Boolean, ) { - if (importedDict == null) { - return - } - - if (withCocoaStdLibFiltering) { - collectComponentsMissingFromCocoa(importedDict, dictionaryComponents) + if (dictionary == null) return + + if (shouldFilterCocoa) { + val cocoaStandard = + dictionary.project + .getService(AppleScriptProjectDictionaryService::class.java) + ?.getCocoaStandardTerminology() + ?: return + dictionaryComponents.addAll(DictionaryTermCatalog.missingTerms(dictionary, cocoaStandard)) } else { - collectAllComponents(importedDict, dictionaryComponents) + dictionaryComponents.addAll(DictionaryTermCatalog.allTerms(dictionary)) } } - - private fun collectComponentsMissingFromCocoa( - importedDict: ApplicationDictionary, - dictionaryComponents: MutableCollection, - ) { - val cocoaStandard = - importedDict.project - .getService(AppleScriptProjectDictionaryService::class.java) - ?.getCocoaStandardTerminology() - - if (cocoaStandard != null) { - importedDict.dictionaryEnumeratorMap.values.filterTo(dictionaryComponents) { - cocoaStandard.findEnumerator(it.getName()) == null - } - importedDict.dictionaryClassMap.values.filterTo(dictionaryComponents) { - cocoaStandard.findClass(it.getName()) == null - } - importedDict.allCommands.filterTo(dictionaryComponents) { - cocoaStandard.findCommand(it.getName()) == null - } - importedDict.dictionaryPropertyMap.values.filterTo(dictionaryComponents) { - cocoaStandard.findCommand(it.getName()) == null - } - } - } - - private fun collectAllComponents( - importedDict: ApplicationDictionary, - dictionaryComponents: MutableCollection, - ) { - dictionaryComponents.addAll(importedDict.dictionaryEnumeratorMap.values) - dictionaryComponents.addAll(importedDict.dictionaryPropertyMap.values) - dictionaryComponents.addAll(importedDict.dictionaryClassMap.values) - dictionaryComponents.addAll(importedDict.allCommands) - } } } diff --git a/src/main/kotlin/com/intellij/plugin/applescript/lang/sdef/DictionaryTermCatalog.kt b/src/main/kotlin/com/intellij/plugin/applescript/lang/sdef/DictionaryTermCatalog.kt new file mode 100644 index 00000000..b146bbe8 --- /dev/null +++ b/src/main/kotlin/com/intellij/plugin/applescript/lang/sdef/DictionaryTermCatalog.kt @@ -0,0 +1,30 @@ +package com.intellij.plugin.applescript.lang.sdef + +internal object DictionaryTermCatalog { + fun allTerms(dictionary: ApplicationDictionary): List = + buildList { + addAll(dictionary.dictionaryEnumeratorMap.values) + addAll(dictionary.dictionaryPropertyMap.values) + addAll(dictionary.dictionaryClassMap.values) + addAll(dictionary.allCommands) + } + + fun missingTerms( + dictionary: ApplicationDictionary, + baseline: ApplicationDictionary, + ): List = + buildList { + dictionary.dictionaryEnumeratorMap.values.filterTo(this) { + baseline.findEnumerator(it.getName()) == null + } + dictionary.dictionaryClassMap.values.filterTo(this) { + baseline.findClass(it.getName()) == null + } + dictionary.allCommands.filterTo(this) { + baseline.findCommand(it.getName()) == null + } + dictionary.dictionaryPropertyMap.values.filterTo(this) { + baseline.findProperty(it.getName()) == null + } + } +} diff --git a/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt b/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt new file mode 100644 index 00000000..b472ed3c --- /dev/null +++ b/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt @@ -0,0 +1,117 @@ +package com.intellij.plugin.applescript.test.sdef + +import com.intellij.plugin.applescript.AppleScriptFileType +import com.intellij.plugin.applescript.lang.dictionary.project.AppleScriptProjectDictionaryService +import com.intellij.plugin.applescript.lang.sdef.AppleScriptPropertyDefinition +import com.intellij.plugin.applescript.lang.sdef.ApplicationDictionary +import com.intellij.plugin.applescript.lang.sdef.DictionaryTermCatalog +import com.intellij.testFramework.fixtures.BasePlatformTestCase + +class DictionaryTermCatalogTest : BasePlatformTestCase() { + fun testPropertyMatchesByKind() { + val imported = buildTestDictionary(project, IMPORTED_TERMS, "Calendar Plus", "calendar-plus.sdef") + val cocoa = buildTestDictionary(project, COCOA_TERMS, "Standard Terminology", "cocoa-standard.sdef") + + val propertyNames = + DictionaryTermCatalog + .missingTerms(imported, cocoa) + .filterIsInstance() + .map { property -> property.getName() } + + assertEquals(listOf("shared label"), propertyNames) + } + + fun testAllTermsKeepOrder() { + val dictionary = buildTestDictionary(project, ORDERED_TERMS, "Calendar Plus", "ordered-terms.sdef") + + val termNames = DictionaryTermCatalog.allTerms(dictionary).map { term -> term.getName() } + + assertEquals(listOf("accepted", "summary", "event", "create event"), termNames) + } + + fun testCompletionKeepsProperty() { + val projectDictionaries = project.getService(AppleScriptProjectDictionaryService::class.java) + projectDictionaries.clearCachedDictionariesForTests() + projectDictionaries.cacheDictionaryForTests( + "Calendar Primer", + buildTestDictionary(project, PRIMER_TERMS, "Calendar Primer", "calendar-primer.sdef"), + ) + projectDictionaries.cacheDictionaryForTests( + "Calendar Plus", + buildTestDictionary(project, IMPORTED_TERMS, "Calendar Plus", "calendar-plus.sdef"), + ) + projectDictionaries.cacheDictionaryForTests( + ApplicationDictionary.COCOA_STANDARD_LIBRARY, + buildTestDictionary(project, COCOA_TERMS, ApplicationDictionary.COCOA_STANDARD_LIBRARY, "cocoa.sdef"), + ) + + try { + myFixture.configureByText( + AppleScriptFileType, + """ + use application "Calendar Primer" + use application "Calendar Plus" + set selectedValue to + """.trimIndent(), + ) + + myFixture.completeBasic() + val lookupStrings = requireNotNull(myFixture.lookupElementStrings) + + assertTrue("Imported property must remain available", lookupStrings.contains("shared label")) + assertFalse("Cocoa property must be filtered", lookupStrings.contains("standard label")) + } finally { + projectDictionaries.clearCachedDictionariesForTests() + } + } + + companion object { + private val IMPORTED_TERMS = + """ + + + + + + + + + """.trimIndent() + + private val PRIMER_TERMS = + """ + + + + + + """.trimIndent() + + private val COCOA_TERMS = + """ + + + + + + + + + """.trimIndent() + + private val ORDERED_TERMS = + """ + + + + + + + + + + + + """.trimIndent() + } +} From 0d590ad56dff8896c07e15da63dd0496063c027b Mon Sep 17 00:00:00 2001 From: Roman Borodavkin Date: Thu, 13 Aug 2026 22:21:28 +0300 Subject: [PATCH 2/3] test(completion): lock dictionary fallback contracts - Cover filtered ordering, missing Cocoa terminology, and no-use fallbacks - Keep mutable dictionary and discovery state inside hermetic cleanup scopes - Remove an inaccurate private helper comment exposed by the new coverage Impact: Completion refactors now preserve fallback and ordering behavior under direct regression tests --- .../AppleScriptDictionaryResolveProcessor.kt | 5 - .../test/sdef/DictionaryTermCatalogTest.kt | 135 ++++++++++++++++-- 2 files changed, 121 insertions(+), 19 deletions(-) diff --git a/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt b/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt index 7b4d986c..9e420c80 100644 --- a/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt +++ b/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt @@ -232,11 +232,6 @@ class AppleScriptDictionaryResolveProcessor : AppleScriptPsiScopeProcessor { } } - /** - * Gather all term declarations from [dictionary]. - * - * @param shouldFilterCocoa if true, omit terms already present in the Standard Terminology - */ private fun collectTerms( dictionary: ApplicationDictionary?, dictionaryComponents: MutableCollection, diff --git a/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt b/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt index b472ed3c..e7069ebe 100644 --- a/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt +++ b/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt @@ -1,6 +1,7 @@ package com.intellij.plugin.applescript.test.sdef import com.intellij.plugin.applescript.AppleScriptFileType +import com.intellij.plugin.applescript.lang.dictionary.discovery.ApplicationDiscoveryService import com.intellij.plugin.applescript.lang.dictionary.project.AppleScriptProjectDictionaryService import com.intellij.plugin.applescript.lang.sdef.AppleScriptPropertyDefinition import com.intellij.plugin.applescript.lang.sdef.ApplicationDictionary @@ -29,23 +30,19 @@ class DictionaryTermCatalogTest : BasePlatformTestCase() { assertEquals(listOf("accepted", "summary", "event", "create event"), termNames) } + fun testFilteredOrder() { + val dictionary = buildTestDictionary(project, ORDERED_TERMS, "Calendar Plus", "ordered-terms.sdef") + val emptyBaseline = buildTestDictionary(project, EMPTY_TERMS, "Standard Terminology", "empty-cocoa.sdef") + + val termNames = DictionaryTermCatalog.missingTerms(dictionary, emptyBaseline).map { term -> term.getName() } + + assertEquals(listOf("accepted", "event", "create event", "summary"), termNames) + } + fun testCompletionKeepsProperty() { val projectDictionaries = project.getService(AppleScriptProjectDictionaryService::class.java) - projectDictionaries.clearCachedDictionariesForTests() - projectDictionaries.cacheDictionaryForTests( - "Calendar Primer", - buildTestDictionary(project, PRIMER_TERMS, "Calendar Primer", "calendar-primer.sdef"), - ) - projectDictionaries.cacheDictionaryForTests( - "Calendar Plus", - buildTestDictionary(project, IMPORTED_TERMS, "Calendar Plus", "calendar-plus.sdef"), - ) - projectDictionaries.cacheDictionaryForTests( - ApplicationDictionary.COCOA_STANDARD_LIBRARY, - buildTestDictionary(project, COCOA_TERMS, ApplicationDictionary.COCOA_STANDARD_LIBRARY, "cocoa.sdef"), - ) - try { + cacheCompletionDictionaries(projectDictionaries) myFixture.configureByText( AppleScriptFileType, """ @@ -65,6 +62,100 @@ class DictionaryTermCatalogTest : BasePlatformTestCase() { } } + fun testCocoaRequired() { + val projectDictionaries = project.getService(AppleScriptProjectDictionaryService::class.java) + val discovery = ApplicationDiscoveryService.getInstance() + val cocoaName = ApplicationDictionary.COCOA_STANDARD_LIBRARY + val isCocoaMissing = discovery.isInNotFoundList(cocoaName) + + try { + projectDictionaries.clearCachedDictionariesForTests() + discovery.addToNotFoundList(cocoaName) + projectDictionaries.cacheDictionaryForTests( + "Calendar Primer", + buildTestDictionary(project, PRIMER_TERMS, "Calendar Primer", "calendar-primer.sdef"), + ) + projectDictionaries.cacheDictionaryForTests( + "Calendar Plus", + buildTestDictionary(project, IMPORTED_TERMS, "Calendar Plus", "calendar-plus.sdef"), + ) + myFixture.configureByText( + AppleScriptFileType, + """ + use application "Calendar Primer" + use application "Calendar Plus" + set selectedValue to + """.trimIndent(), + ) + + myFixture.completeBasic() + val lookupStrings = requireNotNull(myFixture.lookupElementStrings) + + assertTrue("The unfiltered dictionary must remain available", lookupStrings.contains("calendar source")) + assertFalse("Filtered terms require a Cocoa baseline", lookupStrings.contains("shared label")) + } finally { + projectDictionaries.clearCachedDictionariesForTests() + if (!isCocoaMissing) discovery.removeFromNotFoundList(cocoaName) + } + } + + fun testNoUseFallbacks() { + val projectDictionaries = project.getService(AppleScriptProjectDictionaryService::class.java) + + try { + projectDictionaries.clearCachedDictionariesForTests() + projectDictionaries.cacheDictionaryForTests( + ApplicationDictionary.SCRIPTING_ADDITIONS_LIBRARY, + buildTestDictionary( + project, + ADDITIONS_TERMS, + ApplicationDictionary.SCRIPTING_ADDITIONS_LIBRARY, + "additions.sdef", + ), + ) + projectDictionaries.cacheDictionaryForTests( + ApplicationDictionary.COCOA_STANDARD_LIBRARY, + buildTestDictionary( + project, + COCOA_TERMS, + ApplicationDictionary.COCOA_STANDARD_LIBRARY, + "cocoa.sdef", + ), + ) + myFixture.configureByText(AppleScriptFileType, "set selectedValue to ") + + myFixture.completeBasic() + val lookupStrings = requireNotNull(myFixture.lookupElementStrings) + + assertTrue( + "No-use completion must include Scripting Additions", + lookupStrings.contains("addition fallback"), + ) + assertTrue( + "No-use completion must include Cocoa terms", + lookupStrings.contains("standard label"), + ) + } finally { + projectDictionaries.clearCachedDictionariesForTests() + } + } + + private fun cacheCompletionDictionaries(projectDictionaries: AppleScriptProjectDictionaryService) { + projectDictionaries.clearCachedDictionariesForTests() + projectDictionaries.cacheDictionaryForTests( + "Calendar Primer", + buildTestDictionary(project, PRIMER_TERMS, "Calendar Primer", "calendar-primer.sdef"), + ) + projectDictionaries.cacheDictionaryForTests( + "Calendar Plus", + buildTestDictionary(project, IMPORTED_TERMS, "Calendar Plus", "calendar-plus.sdef"), + ) + projectDictionaries.cacheDictionaryForTests( + ApplicationDictionary.COCOA_STANDARD_LIBRARY, + buildTestDictionary(project, COCOA_TERMS, ApplicationDictionary.COCOA_STANDARD_LIBRARY, "cocoa.sdef"), + ) + } + companion object { private val IMPORTED_TERMS = """ @@ -113,5 +204,21 @@ class DictionaryTermCatalogTest : BasePlatformTestCase() { """.trimIndent() + + private val EMPTY_TERMS = + """ + + + + """.trimIndent() + + private val ADDITIONS_TERMS = + """ + + + + + + """.trimIndent() } } From f5a144ce200157b0cba1171845f8139c56b9e42e Mon Sep 17 00:00:00 2001 From: Roman Borodavkin Date: Thu, 13 Aug 2026 22:43:15 +0300 Subject: [PATCH 3/3] test(completion): isolate missing Cocoa baseline - Model an unavailable Cocoa dictionary at the internal catalog boundary - Replace process-global discovery mutation with a direct null-contract regression - Preserve the resolver's fail-closed completion behavior without startup races Impact: Dictionary completion tests are deterministic on clean macOS runners --- .../AppleScriptDictionaryResolveProcessor.kt | 1 - .../lang/sdef/DictionaryTermCatalog.kt | 16 +++++---- .../test/sdef/DictionaryTermCatalogTest.kt | 36 ++----------------- 3 files changed, 12 insertions(+), 41 deletions(-) diff --git a/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt b/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt index 9e420c80..08be0b45 100644 --- a/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt +++ b/src/main/kotlin/com/intellij/plugin/applescript/lang/resolve/AppleScriptDictionaryResolveProcessor.kt @@ -244,7 +244,6 @@ class AppleScriptDictionaryResolveProcessor : AppleScriptPsiScopeProcessor { dictionary.project .getService(AppleScriptProjectDictionaryService::class.java) ?.getCocoaStandardTerminology() - ?: return dictionaryComponents.addAll(DictionaryTermCatalog.missingTerms(dictionary, cocoaStandard)) } else { dictionaryComponents.addAll(DictionaryTermCatalog.allTerms(dictionary)) diff --git a/src/main/kotlin/com/intellij/plugin/applescript/lang/sdef/DictionaryTermCatalog.kt b/src/main/kotlin/com/intellij/plugin/applescript/lang/sdef/DictionaryTermCatalog.kt index b146bbe8..0208dfc4 100644 --- a/src/main/kotlin/com/intellij/plugin/applescript/lang/sdef/DictionaryTermCatalog.kt +++ b/src/main/kotlin/com/intellij/plugin/applescript/lang/sdef/DictionaryTermCatalog.kt @@ -11,20 +11,22 @@ internal object DictionaryTermCatalog { fun missingTerms( dictionary: ApplicationDictionary, - baseline: ApplicationDictionary, - ): List = - buildList { + baseline: ApplicationDictionary?, + ): List { + val availableBaseline = baseline ?: return emptyList() + return buildList { dictionary.dictionaryEnumeratorMap.values.filterTo(this) { - baseline.findEnumerator(it.getName()) == null + availableBaseline.findEnumerator(it.getName()) == null } dictionary.dictionaryClassMap.values.filterTo(this) { - baseline.findClass(it.getName()) == null + availableBaseline.findClass(it.getName()) == null } dictionary.allCommands.filterTo(this) { - baseline.findCommand(it.getName()) == null + availableBaseline.findCommand(it.getName()) == null } dictionary.dictionaryPropertyMap.values.filterTo(this) { - baseline.findProperty(it.getName()) == null + availableBaseline.findProperty(it.getName()) == null } } + } } diff --git a/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt b/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt index e7069ebe..36304aee 100644 --- a/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt +++ b/src/test/kotlin/com/intellij/plugin/applescript/test/sdef/DictionaryTermCatalogTest.kt @@ -1,7 +1,6 @@ package com.intellij.plugin.applescript.test.sdef import com.intellij.plugin.applescript.AppleScriptFileType -import com.intellij.plugin.applescript.lang.dictionary.discovery.ApplicationDiscoveryService import com.intellij.plugin.applescript.lang.dictionary.project.AppleScriptProjectDictionaryService import com.intellij.plugin.applescript.lang.sdef.AppleScriptPropertyDefinition import com.intellij.plugin.applescript.lang.sdef.ApplicationDictionary @@ -63,40 +62,11 @@ class DictionaryTermCatalogTest : BasePlatformTestCase() { } fun testCocoaRequired() { - val projectDictionaries = project.getService(AppleScriptProjectDictionaryService::class.java) - val discovery = ApplicationDiscoveryService.getInstance() - val cocoaName = ApplicationDictionary.COCOA_STANDARD_LIBRARY - val isCocoaMissing = discovery.isInNotFoundList(cocoaName) + val dictionary = buildTestDictionary(project, IMPORTED_TERMS, "Calendar Plus", "calendar-plus.sdef") - try { - projectDictionaries.clearCachedDictionariesForTests() - discovery.addToNotFoundList(cocoaName) - projectDictionaries.cacheDictionaryForTests( - "Calendar Primer", - buildTestDictionary(project, PRIMER_TERMS, "Calendar Primer", "calendar-primer.sdef"), - ) - projectDictionaries.cacheDictionaryForTests( - "Calendar Plus", - buildTestDictionary(project, IMPORTED_TERMS, "Calendar Plus", "calendar-plus.sdef"), - ) - myFixture.configureByText( - AppleScriptFileType, - """ - use application "Calendar Primer" - use application "Calendar Plus" - set selectedValue to - """.trimIndent(), - ) - - myFixture.completeBasic() - val lookupStrings = requireNotNull(myFixture.lookupElementStrings) + val terms = DictionaryTermCatalog.missingTerms(dictionary, null) - assertTrue("The unfiltered dictionary must remain available", lookupStrings.contains("calendar source")) - assertFalse("Filtered terms require a Cocoa baseline", lookupStrings.contains("shared label")) - } finally { - projectDictionaries.clearCachedDictionariesForTests() - if (!isCocoaMissing) discovery.removeFromNotFoundList(cocoaName) - } + assertEmpty("Filtered terms require a Cocoa baseline", terms) } fun testNoUseFallbacks() {