(or put it into `$GRADLE_USER_HOME/gradle.properties`).

On Windows you might need to add long paths setting to the repo:

    git config core.longpaths true 

## Building

The project is built with Gradle. Run Gradle to build the project and to run the tests 
using the following command on Unix/macOS:

    ./gradlew <tasks-and-options>
    
or the following command on Windows:

## Supported Versions

Security updates are applied to the latest feature release (1.x) of the compiler, standard library, and build plugins.

A fix will be shipped with the next incremental (1.x.y) or bug fix release (1.x.yz).

All fixes are also applied to the master branch to be included in all upcoming releases.

## Reporting a Vulnerability

        symbolBuilder: KtSymbolByFirBuilder
    ): List<KtSymbol> {
        // Handle situation when we're in the middle/beginning of qualifier
        // <caret>A.B.C.foo() or A.<caret>B.C.foo()
        // NB: in this case we get some parent FIR, like FirBlock, FirProperty, FirFunction or the like
        var parent = expression.parent as? KtDotQualifiedExpression
        var unresolvedCounter = 1
        while (parent != null) {

        is KtFirPsiJavaClassSymbol -> firSymbol.fir
        is KtFirAnonymousObjectSymbol -> firSymbol.fir
        else -> error(
            "`${this::class.qualifiedName}` needs to be specially handled by the scope provider or is an unknown" +
                    " ${KtSymbolWithDeclarations::class.simpleName} implementation."
        )
    }

    override fun getMemberScope(classSymbol: KtSymbolWithMembers): KtScope {

     * is somehow changed, then we want to keep the wrapper.
     *
     * Such substitute overrides happen because of inheritance.
     *
     * If the declaration references only its own type parameters, or parameters from the outer declarations, then
     * we consider that it's signature will not be changed by the SUBSTITUTION_OVERRIDE, so the wrapper can be unwrapped.
     *

         * getter/setter) then this method is not used at all. Instead
         * [org.jetbrains.kotlin.backend.jvm.lower.ReflectiveAccessLowering.visitGetField] (or visitSetField) generates the access without
         * asking.
         */
        override fun isAccessorWithExplicitImplementation(accessor: IrSimpleFunction): Boolean {

            Errors.NAMED_PARAMETER_NOT_FOUND,
            Errors.NAMED_ARGUMENTS_NOT_ALLOWED,
            Errors.VARARG_OUTSIDE_PARENTHESES,
            Errors.SPREAD_OF_NULLABLE,
            Errors.SPREAD_OF_LAMBDA_OR_CALLABLE_REFERENCE,
            Errors.MANY_LAMBDA_EXPRESSION_ARGUMENTS,
            Errors.UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE,
            Errors.TOO_MANY_ARGUMENTS,

}

/**
 * Returns whether the function uses its body as an expression (i.e., the function uses the result value of the expression) or not.
 *
 * Named functions do not consider their bodies used if
 *  - the function body is a block e.g., `fun foo(): Int { return bar }` or
 *  - the function itself returns Unit
 */
private fun doesNamedFunctionUseBody(namedFunction: KtNamedFunction, body: PsiElement): Boolean = when {

                                    this += classFqName
                                }
                            } else if (fqName != qualifiedNameAsFqName) {
                                // or some kind of top level declaration with potential receiver
                                this += fqName
                                val receiverClassType = symbol.receiverParameter?.type as? KtNonErrorClassType

            data1 = JvmProtoBufUtil.writeData(message, stringTable),
            data2 = stringTable.strings.toTypedArray(),
            extraInt = JvmBackendExtension.Default.generateMetadataExtraFlags(JvmAbiStability.STABLE) or
                    generateLanguageVersionSettingsBasedMetadataFlags(firSession.languageVersionSettings)
        )
}

private fun getAsmMethodSignatureWithCorrection(method: PsiMethod): String = buildString {