facade = this,
            handler.resolveSession.orThrowResolutionNotPerformedError(),
            handler.deprecationResolver.orThrowResolutionNotPerformedError(),
            handler.callResolver.orThrowResolutionNotPerformedError(),
            handler.kotlinToResolvedCallTransformer.orThrowResolutionNotPerformedError(),
            handler.overloadingConflictResolver.orThrowResolutionNotPerformedError(),

~~ specific language governing permissions and limitations
~~ under the License.

 ---
 Legacy Artifact Handlers Reference
 ---
 Hervé Boutemy
 ---
 2013-08-02
 ---

Legacy Artifact Handlers Reference

  Maven 3 artifact handlers (see {{{../maven-artifact/apidocs/org/apache/maven/artifact/handler/ArtifactHandler.html} API}})

            // e.g., "/path/to/jdk/home!/modules/java.base". (JDK home path + JAR separator + actual file path)
            // To work with that JRT handler, a hacky workaround here is to add "modules" before the module name so that it can
            // find the actual file path.

 *
 * Although this can be viewed as a flexible type (kotlin.Nothing..kotlin.Any?), a platform may assign special meaning to the
 * values of dynamic type, and handle differently from the regular flexible type.
 */
public abstract class KaDynamicType : KaType

  access to their required artifacts and other classpath elements. In the case
  of required artifacts and other classpath elements, this is assumed by the
  mojo API to be in a correct state, and will be handled by the Wagon
  modifications.


* Implementation Notes

** Accessibility of offline status

  Offline status should be indicated in the MavenSettings instance, since it

    override val token: KaLifetimeToken,
) : KaSmartCastProvider(), KaFirSessionComponent {

    private val KtExpression.isExplicitSmartCastInfoTarget: Boolean
        get() {
            // we want to handle only most top-level parenthesised expressions
            if (parent is KtParenthesizedExpression) return false

            // expressions like `|foo.bar()|` or `|foo?.baz()|` are ignored

- [`KT-67021`](https://youtrack.jetbrains.com/issue/KT-67021) K2: Cannot find cached type parameter by FIR symbol: E of the owner: FirRegularClassSymbol Function
- [`KT-67014`](https://youtrack.jetbrains.com/issue/KT-67014) K1/K2 handle when expression as annotation target differently
- [`KT-67254`](https://youtrack.jetbrains.com/issue/KT-67254) K1/K2 both allow annotations on loops, assignments, array sets

     * When resolving the calleeExpression of a `KtCallExpression`, we resolve the entire `KtCallExpression` instead. This way, the
     * corresponding FIR element is the `FirFunctionCall`, etc. Implicit invoke is then specially handled after obtaining the
     * `FirImplicitInvokeCall`.
     *
     * Note that, if the calleeExpression is already a KtCallExpression, then we don't do this because such a callExpression can be properly

        expression: KtSimpleNameExpression,
        analysisSession: KaFirSession,
        session: FirSession,
        symbolBuilder: KaSymbolByFirBuilder,
    ): List<KaSymbol> {
        // 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

        val constructorSymbol = annotation.calleeReference.toResolvedConstructorSymbol()
        if (constructorSymbol != null) {
            return constructorSymbol
        }
    }

    // Handle unresolved annotation calls gracefully
    @OptIn(UnresolvedExpressionTypeAccess::class)
    val annotationClass = annotation.coneTypeOrNull?.toClassSymbol(session)?.fir ?: return null