}

                override fun visitComment(comment: PsiComment) {
                    // Skip such comments so that test become idempotent
                    if (comment.text.matches(commentRegex)) return
                    super.visitComment(comment)
                }
            })
        }
        if (actual != original) {

            override fun visitElement(element: PsiElement) {
                if (element !is KtLightElement<*, *>) return
                // NB: intentionally visit members first so that `self` can be found first if matched
                if (element is PsiClass) {
                    element.fields.forEach { it.accept(this) }
                    element.methods.forEach { it.accept(this) }

    override fun getPackageSymbols(nameFilter: KaScopeNameFilter): Sequence<KaPackageSymbol> = withValidityAssertion {
        sequence {
            // Only emit package symbols for top-level packages (subpackages of root). This matches the behavior
            // of the root-level KtFirPackageScope.
            val seenTopLevelPackages = mutableSetOf<Name>()
            for (tool in tools) {

 * compiler depends on the IJ platform, but this dependency is not represented as JARs in the monorepo, but rather by certain monorepo
 * source modules, which are made visible to the Kotlin compiler library sources as dependencies via an anchor module.
 */
public interface KotlinAnchorModuleProvider : KotlinOptionalPlatformComponent {

*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+
| <<<test-jar>>>        | <<<tests>>>   | <<<jar>>>  | java      | classes, patch module |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+

            yieldAll(getClassifierSymbols())
            yieldAll(getConstructors())
        }
    }

    /**
     * Return a sequence of [KaCallableSymbol] which current scope contain if declaration name matches [nameFilter].
     *
     * This function needs to retrieve a set of all possible names before processing the scope.
     * The overload with `names: Collection<Name>` should be used when the candidate name set is known.
     */

 * @see KaCallableSignature
 */
public interface KaTypeScope : KaScopeLike {

    /**
     * Return a sequence of [KaCallableSignature] which current scope contain if declaration name matches [nameFilter].
     */
    public fun getCallableSignatures(nameFilter: KaScopeNameFilter = { true }): Sequence<KaCallableSignature<*>>

    /**

            // library modules might still be valid. This is not a problem, though, because analysis session caching is not required for
            // correctness, but rather a performance optimization.
            analysisSessionProvider.clearCaches()
        }
    }
}

private fun KClass<out KaLifetimeToken>.flushPendingChanges(project: Project) {