*/

package org.jetbrains.kotlin.analysis.api.symbols

import org.jetbrains.kotlin.analysis.api.symbols.pointers.KaSymbolPointer
import org.jetbrains.kotlin.name.FqName

public abstract class KaPackageSymbol : KaSymbol {
    public abstract val fqName: FqName

    abstract override fun createPointer(): KaSymbolPointer<KaPackageSymbol>
}

        callInCommon.assertIsCallOf(CallableId(FqName("some.example"), FqName("Person"), Name.identifier("greet")))

        val ktFileInJvm = session.modulesWithFiles.getValue(sourceModule).single() as KtFile
        val callInJvm = ktFileInJvm.findDescendantOfType<KtCallExpression>()!!
        callInJvm.assertIsCallOf(CallableId(FqName("common"), Name.identifier("greetEachOther")))
    }

    @Test

        externalObjects: Map<FqName, KClass<*>> = emptyMap(),
        defaultImports: List<FqName> = emptyList(),
    ): AnalysisSchema {
        val preIndex = createPreIndex(types)

        val dataTypes = preIndex.types.map { createDataType(it, preIndex) }

        val extFunctions = externalFunctions.mapNotNull { functionExtractor.topLevelFunction(it, preIndex) }.associateBy { it.fqName }

    val imports: Map<String, FqName>
    val currentScopes: List<AnalysisScopeView>
    val assignments: List<AssignmentRecord>
}


class SchemaTypeRefContext(val schema: AnalysisSchema) : TypeRefContext {
    override fun resolveRef(dataTypeRef: DataTypeRef): DataType = when (dataTypeRef) {
        is DataTypeRef.Name -> schema.dataClassesByFqName.getValue(dataTypeRef.fqName)
        is DataTypeRef.Type -> dataTypeRef.dataType

import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtFile

public abstract class KaImportOptimizer : KaLifetimeOwner {
    public abstract fun analyseImports(file: KtFile): KaImportOptimizerResult

    public abstract fun getImportableName(symbol: KaSymbol): FqName?
}

public typealias KtImportOptimizer = KaImportOptimizer

interface AnalysisSchema : Serializable {
    val topLevelReceiverType: DataClass
    val dataClassesByFqName: Map<FqName, DataClass>
    val externalFunctionsByFqName: Map<FqName, DataTopLevelFunction>
    val externalObjectsByFqName: Map<FqName, ExternalObjectProviderKey>
    val defaultImports: Set<FqName>

data class ResolutionError(
    val element: LanguageTreeElement,
    val errorReason: ErrorReason
)


sealed interface ErrorReason {
    data class AmbiguousImport(val fqName: FqName) : ErrorReason
    data class UnresolvedReference(val reference: Expr) : ErrorReason
    data class NonReadableProperty(val property: DataProperty) : ErrorReason

}

class KaResolveExtensionForTest(
    private val files: List<KaResolveExtensionFile>,
    private val packages: Set<FqName>,
    private val shadowedScope: GlobalSearchScope,
) : KaResolveExtension() {
    override fun getKtFiles(): List<KaResolveExtensionFile> = files
    override fun getContainedPackages(): Set<FqName> = packages
    override fun getShadowedScope(): GlobalSearchScope = shadowedScope
}

 * limitations under the License.
 */

package org.gradle.declarative.dsl.schema


interface DataClass : DataType {
    val name: FqName
    val supertypes: Set<FqName>
    val properties: List<DataProperty>
    val memberFunctions: List<SchemaMemberFunction>
    val constructors: List<DataConstructor>

            }
        }

        return null
    }
}

private fun FqName.dropFakeRootPrefixIfPresent(): FqName =
    tail(FqName(ROOT_PREFIX_FOR_IDE_RESOLUTION_MODE))

private data class AdditionalImports(val simpleImports: Set<FqName>, val starImports: Set<FqName>)

private inline fun <reified T : KtElement> KtFile.findSmallestElementOfTypeContainingSelection(selection: TextRange): T? =