*         else -> {}
     *     }
     * }
     *
     * Note that this function returns the same missing cases regardless of the existence of the else branch.
     * If you have to assume that it does not have the missing cases when it has an else branch,
     * you need a separate check whether it has an else branch or not.
     */
    public fun KtWhenExpression.getMissingCases(): List<WhenMissingCase> =

* `idea-full` is a full blown IntelliJ IDEA Community Edition to be used in the plugin module.

These dependencies are quite large, so depending on the quality of your internet connection 
you might face timeouts getting them. In this case, you can increase timeout by specifying the following 
command line parameters on the first run: 
    
    ./gradlew -Dhttp.socketTimeout=60000 -Dhttp.connectionTimeout=60000

## Important gradle tasks

    /**
     * This property can be used to optimize some argument processing logic.
     * For example, if you have [KaAnnotationApplicationInfo] from [KaAnnotated.annotationInfos] and [hasArguments] is **false**,
     * then you can avoid [KaAnnotated.annotationsByClassId] call,
     * because effectively you already have all necessary information in [KaAnnotationApplicationInfo]
     */
    public val hasArguments: Boolean

    /**
     * @param searchScope A scope in which the created [KotlinAnnotationsResolver] will operate. Make sure that this scope contains all
     * the annotations that you might want to resolve.
     */
    public fun createAnnotationResolver(searchScope: GlobalSearchScope): KotlinAnnotationsResolver

    public companion object {

import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty

internal object FirReferenceResolveHelper {
    fun FirResolvedTypeRef.toTargetSymbol(session: FirSession, symbolBuilder: KaSymbolByFirBuilder): KaSymbol? {
        // When you call a method from Java with type arguments, in FIR they are currently represented as flexible types.
        // TODO Consider handling other non-ConeLookupTagBasedType types here (see KT-66418)

     * provided, an empty map is returned defensively so that [toTypeArgumentsMapping] doesn't conjure any error types. If you want to map
     * too few type arguments meaningfully, please provide filler types explicitly.
     */
    private fun toTypeArgumentsMapping(
        typeArguments: List<FirTypeProjection>,

 * only if the real resolution was unsuccessful. You can use this EP by creating a class implementing this interface.
 * For example, let's assume that you want to return symbol `fun foo() = 3` for the following KDoc resolution:
 *
 * ```
 *   package com.example
 *   fun foo() = 3
 *   /**
 *    * [this.is.not.com.example.fo<caret>o] is not the above `com.example.foo`, but you want to resolve it to the above `com.example.foo`.
 *    */

 *
 * [KaResolveExtension] implements the [Disposable] interface. The resolve extension can then act as a parent disposable, e.g. for a message
 * bus connection.
 *
 * You *must not* implement [KaResolveExtension]s as module-level services, due to the following reasons:
 *
 * 1. The IntelliJ platform SDK [discourages](https://plugins.jetbrains.com/docs/intellij/plugin-services.html#types) the use of

expression: 4294967296u
constant: error("Type cannot be resolved. Please make sure you have the required dependencies for unsigned types in the classpath")

 *
 * #### Implementation Notes
 *
 * Analysis API platforms need to take care of publishing modification topics via the [analysisMessageBus]. In general, if your platform
 * works with static code and static module structure, you do not need to publish any events. However, keep in mind the contracts of the
 * various modification events. For example, if your platform can guarantee a static module structure but source code can still change,