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.")
        }
    }
}

private object SemanticSubtypingTestDirectives : SimpleDirectivesContainer() {
    val ARE_EQUAL by stringDirective(

                is KtParameter -> psi.destructuringDeclaration
                    ?: errorWithAttachment("Expected to find lambda ${KtParameter::class} with ${KtDestructuringDeclaration::class}") {
                        withPsiEntry("psi", psi)
                    }
                else -> errorWithAttachment("Expected to find ${KtDestructuringDeclaration::class} or ${KtParameter::class} but ${psi?.let { it::class }} found") {

    if (symbol.origin != KaSymbolOrigin.SOURCE) return
    val containingFileSymbol = symbol.getContainingFileSymbol()
    testServices.assertions.assertEquals(ktFileSymbol, containingFileSymbol) {
        "Invalid file for $symbol, expected $ktFileSymbol but $containingFileSymbol found"
    }
}

internal fun KaSession.checkContainingJvmClassName(
    ktFile: KtFile,
    ktClass: KtClassOrObject?,
    symbol: KaCallableSymbol,

        else
            substitutedType.asKtType()
    }

    /**
     * Expected type of the indexing parameter in array access, for example, in the following code:
     * ```
     * val map = mapOf<Int, String>()
     * map[k] = v
     * ```
     * `k` is indexing parameter and its expected type is `Int`.
     */
    private fun getExpectedTypeOfIndexingParameter(expression: PsiElement): KaType? {

            val targetOffset = testServices.expressionMarkerProvider.getCaretPositionOrNull(psiFile)
            if (targetOffset != null) {
                if (psiDeclaration != null) error("Only one target method is expected")
                psiDeclaration = psiFile.findElementAt(targetOffset)?.parentsWithSelf?.find { it is PsiMethod || it is PsiVariable }
            }

        val project = ktModule.project
        val correctedClassId = classIdMapping[classId] ?: return null
        require(ktModule is KtBuiltinsModule) {
            "Expected builtin module but found $ktModule"
        }
        return project.createDeclarationProvider(ProjectScope.getLibrariesScope(project), ktModule)
            .getAllClassesByClassId(correctedClassId)

        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

    private object Directives : SimpleDirectivesContainer() {
        val CLASS_ID by stringDirective("ClassId of expected annotation")
    }

        val callableSymbol = with(SymbolByFqName.getSymbolDataFromFile(testDataPath)) {
            with(analysisSession) {
                toSymbols(ktFile).singleOrNull() as? KaCallableSymbol ?: error("Expected a single callable declaration to be specified.")
            }
        }
        return callableSymbol.returnType
    }

    }

    companion object {
        fun getInstance(project: Project): KaBaseLifetimeTracker =
            KaLifetimeTracker.getInstance(project) as? KaBaseLifetimeTracker
                ?: error("Expected ${KaBaseLifetimeTracker::class.simpleName} to be registered for ${KaLifetimeTracker::class.simpleName}.")
    }

                    expectedSymbol.psi?.containingFile?.name + " : " + expectedSymbol.render(renderer)
                }
            }
        }

        val actual = buildString {
            appendLine("expected symbols:")
            appendLine(expectedSymbolText)
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }