}

    fun afterLeavingAnalysis(session: KtAnalysisSession) {
        val stack = lifetimeOwnersStack.get()
        val last = stack.last()
        check(last == session.token)
        lifetimeOwnersStack.set(stack.removeAt(stack.lastIndex))
    }

    companion object {
        fun getInstance(project: Project): KaBaseLifetimeTracker =

    public void enter() {
        LinkedList<ScopeState> stack = values.get();
        if (stack == null) {
            stack = new LinkedList<>();
            values.set(stack);
        }
        stack.addFirst(new ScopeState());
    }

    private ScopeState getScopeState() {
        LinkedList<ScopeState> stack = values.get();
        if (stack == null || stack.isEmpty()) {
            throw new IllegalStateException();

     * @param error the error that caused this log
     */
    void debug(CharSequence content, Throwable error);

    /**
     * Sends an exception to the user in the <b>debug</b> error level.
     * The stack trace for this exception will be output when this error level is enabled.
     *
     * @param error the error that caused this log
     */
    void debug(Throwable error);

    void debug(Supplier<String> content);

                stack += superType to superClassSymbol
                if (superClassSymbol == superSymbol) {
                    result = stack.toList()
                    check(stack.removeLast().second == superClassSymbol)
                    break
                }
                dfs(superClassSymbol)
                check(stack.removeLast().second == superClassSymbol)
            }
        }

        } else {
            logger.warn("The metadata {} {}{}", metadata, errorType, msg);
        }
    }

    @Override
    public void artifactDescriptorInvalid(RepositoryEvent event) {
        // The exception stack trace is not really interesting here
        logger.warn(
                "The POM for {} is invalid, transitive dependencies (if any) will not be available: {}",
                event.getArtifact(),

            }

            return true
        }

        private inline fun withElement(element: FirElement, block: () -> Unit) {
            stack.addLast(element)
            try {
                block()
            } finally {
                stack.removeLast()
            }
        }
    }

    private inner class FirElementCollector : FirDefaultVisitorVoid() {
        val hasJumps: Boolean

    override val typeParameters: List<KaTypeParameterSymbol> by cached {
        // The parent Java class might contribute type parameters to the Java type parameter stack, but for this KtSymbol, parent type 
        // parameters aren't relevant.
        psi.typeParameters.mapIndexed { index, psiTypeParameter ->
            KaFirPsiJavaTypeParameterSymbol(psiTypeParameter, analysisSession, origin) {

        }
        else -> arguments.any { typeProjection ->
            // A star projection type (lazily) built by type parameter will be yet another type with a star projection,
            // resulting in stack overflow if we keep checking allowed type parameter descriptors
            !typeProjection.isStarProjection &&
                    typeProjection.type.hasReferenceOtherThan(allowedTypeParameterDescriptors)
        }
    }

- [`KT-59480`](https://youtrack.jetbrains.com/issue/KT-59480) K2: build moko-resources
- [`KT-65771`](https://youtrack.jetbrains.com/issue/KT-65771) K2: "IndexOutOfBoundsException: Cannot pop operand off an empty stack" when calling method imported using typealias as callable qualifier
- [`KT-67502`](https://youtrack.jetbrains.com/issue/KT-67502) K2: "property must be initialized or be abstract" with try-finally in secondary constructor