/libraries/tools/dukat/ "Kotlin Wasm"
/libraries/tools/ide-plugin-dependencies-validator "Kotlin IDE Analysis Core"
/libraries/kotlin-dom-api-compat/ Ilya.Goncharov Stanislav.Erokhin
/libraries/tools/kotlin-build-tools-enum-compat/ "Kotlin Build Tools"
/libraries/tools/gradle/ "Kotlin Build Tools"
/libraries/tools/jdk-api-validator/ "Kotlin Libraries"
/libraries/tools/kotlin-allopen/ "Kotlin Build Tools"

    fun analyze(element: KtElement, mode: AnalysisMode = AnalysisMode.FULL): BindingContext {
        return analyze(listOf(element), mode)
    }

    fun getOrigin(file: VirtualFile): KtSymbolOrigin

    enum class AnalysisMode {
        ALL_COMPILER_CHECKS,
        FULL,
        PARTIAL_WITH_DIAGNOSTICS,
        PARTIAL
    }
}

class Fe10AnalysisContext(
    facade: Fe10AnalysisFacade,

        get() = withValidityAssertion {
            val containingDescriptor = descriptor?.containingDeclaration
            if (containingDescriptor is ClassDescriptor && containingDescriptor.kind == ClassKind.ENUM_CLASS) {
                return containingDescriptor.defaultType.toKtType(analysisContext)
            } else {
                createErrorType()
            }
        }

    override val name: Name

  public void testDynamic() {
    runTest("analysis/analysis-api/testData/symbols/symbolByPsi/dynamic.kt");
  }

  @Test
  @TestMetadata("enum.kt")
  public void testEnum() {
    runTest("analysis/analysis-api/testData/symbols/symbolByPsi/enum.kt");
  }

  @Test
  @TestMetadata("enumEntryFunctions.kt")
  public void testEnumEntryFunctions() {

                        if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitComparisonOfIncompatibleEnums)) {
                            isCompatible = isCompatible && typeParameterOwner.classId != StandardClassIds.Enum
                        }
                        if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitComparisonOfIncompatibleClasses)) {

        fun buildAnonymousObjectSymbol(symbol: FirAnonymousObjectSymbol): KtAnonymousObjectSymbol {
            return symbolsCache.cache(symbol) {
                when (symbol.classKind) {
                    ClassKind.ENUM_ENTRY -> KtFirEnumEntryInitializerSymbol(symbol, analysisSession)
                    else -> KtFirAnonymousObjectSymbol(symbol, analysisSession)
                }
            }
        }

    override fun getCombinedDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtScope =
        getDeclaredMemberScope(classSymbol, DeclaredMemberScopeKind.COMBINED)

    private enum class DeclaredMemberScopeKind {
        NON_STATIC,

        STATIC,

        /**

                    else -> KtClassKind.OBJECT
                }
                is KtClass -> when {
                    psi.isInterface() -> KtClassKind.INTERFACE
                    psi.isEnum() -> KtClassKind.ENUM_CLASS
                    psi.isAnnotation() -> KtClassKind.ANNOTATION_CLASS
                    else -> KtClassKind.CLASS
                }
                else -> error("Unexpected class instance")
            }

        )
}

private fun getAsmMethodSignatureWithCorrection(method: PsiMethod): String = buildString {
    append("(")
    if (method.containingClass?.isEnum == true && method.isConstructor) {
        // Enum constructors are represented without name/ordinal in light classes, which seems fine because they don't have name/ordinal

                    withPsiEntry("parent", parent)
                }
            /**
             * EXPRESSIONS
             */
            // Enum entries, type parameters, lamda expressions and script
            // initializers never use any child expressions.
            is KtEnumEntry ->
                false
            is KtTypeParameter ->