if (aType == null) {
                        errors.add("'${a.text}' has no type at ${a.positionString}")
                        super.visitCallExpression(expression)
                        return
                    }
                    val b = valueArguments[1]
                    val bType = b.getArgumentExpression()?.getKaType()
                    if (bType == null) {

                        val ktType = if (parent != null && deparenthesize(parent.receiverExpression) == deparenthesize(base)) {
                            parent.receiverExpression.getKaType()
                        } else {
                            expression.getKaType()
                        }
                        val actualHasDenotableType = ktType?.isDenotable ?: error("${base.text} does not have a type.")

     * - `Unit` type for statements;
     */
    public fun KtExpression.getKaType(): KaType? =
        withValidityAssertion { analysisSession.expressionTypeProvider.getKtExpressionType(this) }

    public fun KtExpression.getKtType(): KaType? = getKaType()

    /**
     * Returns the return type of the given [KtDeclaration] as [KaType].
     *

                    analyze(declaration) {
                        val initializer = declaration.initializer ?: return@analyze
                        initializer.getKaType()
                    }
                }
            })
        }
        // After running AA, run CodeGen.
        super.doTestByMainFile(mainFile, mainModule, testServices)
    }

        } ?: error("expect an expression but got ${selected.text}, ${selected::class}")
        val type = executeOnPooledThreadInReadAction {
            analyseForTest(expression) {
                var ktType = expression.getKaType()
                if (Directives.APPROXIMATE_TYPE in mainModule.testModule.directives) {
                    ktType = ktType?.approximateToSuperPublicDenotableOrSelf(true)
                }

            ?: error("Can't find psi context for $containingDeclaration")

        val actual = analyze(mainFile) {
            val returnType = declarationAtCaret.getKaType()
            if (returnType != null) {
                prettyPrint {
                    appendLine("${KaType::class.simpleName}: ${AnalysisApiPsiTypeProviderTestUtils.render(analysisSession, returnType)}")

        return when (element) {
            is KtProperty -> element.getVariableSymbol().returnType
            is KtExpression -> element.getKaType() ?: error("Expected the selected expression to have a type.")
            else -> error("Expected a property or an expression.")
        }
    }
}

        val expression = testServices.expressionMarkerProvider.getSelectedElementOfType<KtExpression>(mainFile)
        analyseForTest(expression) {
            val type = expression.getKaType()
                ?: error("expression $expression is not typable")
            val typeScope = type.getTypeScope()
            val declaredScopeByTypeScope = typeScope?.getDeclarationScope()

     *
     * Inside the `LIST_KT_ELEMENT.getKaType().getTypeScope()` would contain the `get(i: Int): String` method with substituted type `T = String`
     *
     * @return type scope for the given type if given `KaType` is not error type, `null` otherwise.
     * Returned [KaTypeScope] includes synthetic Java properties.
     *
     * @see KaTypeScope
     * @see KaTypeProviderMixIn.getKaType
     */

     *
     * This may raise an exception if the resolution ends up with an unexpected kind.
     */
    public fun KtTypeReference.getKaType(): KaType =
        withValidityAssertion { analysisSession.typeProvider.getKtType(this) }

    public fun KtTypeReference.getKtType(): KaType = getKaType()

    /**
     * Resolve [KtDoubleColonExpression] and return [KaType] of its receiver.
     *