this += ShortenStrategy.entries.associate { option ->
                        val shorteningsForOption = collectPossibleReferenceShorteningsInElement(
                            element,
                            shortenOptions = ShortenOptions.ALL_ENABLED,
                            classShortenStrategy = { option },
                            callableShortenStrategy = { option }
                        )

                is FirAbstractSimpleImportingScope -> EXPLICIT
                else -> LOCAL
            }
        }

        fun fromShortenOption(option: ShortenStrategy): ImportKind? = when (option) {
            ShortenStrategy.SHORTEN_AND_IMPORT -> EXPLICIT
            ShortenStrategy.SHORTEN_AND_STAR_IMPORT -> STAR
            else -> null
        }
    }
}

                    this += ShortenStrategy.entries.associateWith { option ->
                        val shorteningsForOption = collectPossibleReferenceShortenings(
                            mainFile,
                            mainFile.textRange,
                            classShortenStrategy = { option },
                            callableShortenStrategy = { option }
                        )

        }
        return symbolEquals(other)
    }

    /**
     * All kinds of non-local named class or object symbols must have the same kind of hash code. The class ID is the best option, as the
     * same class/object may be represented by multiple different symbols.
     */
    override fun hashCode(): Int = classId?.hashCode() ?: symbolHashCode()

(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:

 */
@OptIn(KtModuleStructureInternals::class)
public inline fun <R> analyzeCopy(
    useSiteKtElement: KtElement,
    resolutionMode: DanglingFileResolutionMode,
    crossinline action: KaSession.() -> R,
): R {
    val containingFile = useSiteKtElement.containingKtFile
    return withDanglingFileResolutionMode(containingFile, resolutionMode) {
        analyze(containingFile, action)
    }

    public abstract fun resolveCall(psi: KtElement): KaCallInfo?
    public abstract fun collectCallCandidates(psi: KtElement): List<KaCallCandidateInfo>
}

@OptIn(KaAnalysisApiInternals::class)
public typealias KtCallResolver = KaResolver

@OptIn(KaAnalysisApiInternals::class)
public interface KaResolverMixIn : KaSessionMixIn {
    @Deprecated(

expression: ANNOTATED_EXPRESSION
text: @OptIn(Deprecated::class) args

fun main(args: Array<String>) {
    (@OptIn(Deprecated::class) <expr>args</expr>)

    private val builtinsModule: KtBuiltinsModule by lazy {
        @OptIn(LLFirInternals::class)
        LLFirBuiltinsSessionFactory.getInstance(project).getBuiltinsSession(platform).ktModule as KtBuiltinsModule
    }

    override fun getNotUnderContentRootModule(project: Project): KtNotUnderContentRootModule {
        return ktNotUnderContentRootModuleWithoutPsiFile
    }

    @OptIn(KtModuleStructureInternals::class)