}

  @Test
  @TestMetadata("list_listOf.kt")
  public void testList_listOf() {
    runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/list_listOf.kt");
  }

  @Test
  @TestMetadata("list_mutableListOf.kt")
  public void testList_mutableListOf() {
    runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/list_mutableListOf.kt");
  }

  @Test

        !leftIsArray && !rightIsArray -> left == right
        else -> false
    }
}


internal fun List<ConstantValue<*>>.expandArrayAnnotationValue(
    containingArrayType: KotlinType,
    analysisContext: Fe10AnalysisContext,
): List<KtAnnotationValue> = flatMap { constantValue: ConstantValue<*> ->
    val constantType = constantValue.getType(analysisContext.resolveSession.moduleDescriptor)

# OWNER_LIST: "Kotlin IDE Analysis Core"
# OWNER_LIST: "Kotlin Release"
# OWNER_LIST: "Kotlin Apple Ecosystem"
# OWNER_LIST: "Kotlin Language Evolution"
# OWNER_LIST: "Kotlin in Fleet"
# OWNER_LIST: Compose
# OWNER_LIST: Mikhail.Glukhikh Dmitriy.Novozhilov Kirill.Rakhman
# OWNER_LIST: Yan.Zhulanow
# OWNER_LIST: Dmitry.Gridin
# OWNER_LIST: Alexander.Udalov
# OWNER_LIST: Zalim.Bashorov
# OWNER_LIST: Ilya.Goncharov Artem.Kobzar

        fir: FirTypeParameter
    ): List<KtSymbol> {
        return listOf(symbolBuilder.buildSymbol(fir.symbol))
    }

    private fun getSymbolsByResolvedReifiedTypeParameterReference(
        symbolBuilder: KtSymbolByFirBuilder,
        fir: FirResolvedReifiedParameterReference
    ): List<KtSymbol> {
        return listOf(symbolBuilder.buildSymbol(fir.symbol))
    }

    }

    override fun getDirectSuperTypes(type: KtType, shouldApproximate: Boolean): List<KtType> {
        require(type is KtFe10Type)
        return TypeUtils.getImmediateSupertypes(type.fe10Type).map { it.toKtType(analysisContext) }
    }

    override fun getAllSuperTypes(type: KtType, shouldApproximate: Boolean): List<KtType> {
        require(type is KtFe10Type)

            importsToAdd = listOf(
                "org.jetbrains.kotlin.psi.KtExpression",
                "org.jetbrains.kotlin.psi"
            )
        ),
        KtSourceElement::class to HLFunctionCallConversion(
            "({0} as? KtPsiSourceElement)?.psi",
            PsiElement::class.createType(nullable = true),
            importsToAdd = listOf(
                "org.jetbrains.kotlin.psi",

        }
    }

    private fun computeTargetModules(module: KtModule): List<KtModule> {
        return when (module) {
            is KtDanglingFileModule -> listOf(module.contextModule, module)
            else -> listOf(module)
        }
    }

    private fun runFir2Ir(
        session: LLFirSession,
        firFiles: List<FirFile>,
        fir2IrExtensions: Fir2IrExtensions,

    }

    private fun createScopesWithKind(firScopes: Iterable<IndexedValue<FirScope>>): List<KtScopeWithKind> {
        return firScopes.map { (index, firScope) ->
            KtScopeWithKind(convertToKtScope(firScope), getScopeKind(firScope, index), token)
        }
    }

    private fun flattenFirScope(firScope: FirScope): List<FirScope> = when (firScope) {

                type
            }.withNullability(nullability, session.typeContext)
        }
    }

    override fun getAllSuperTypes(type: KtType, shouldApproximate: Boolean): List<KtType> {
        require(type is KtFirType)
        return listOf(type.coneType)
            .bfs { it.getDirectSuperTypes(shouldApproximate).iterator() }
            .drop(1)
            .mapTo(mutableListOf()) { it.asKtType() }
    }

            } else {
                resolvedCall.variableCall.toPropertyRead(context)
            }?.let { createCallInfo(context, element, it, listOf(resolvedCall), diagnostics) }
        } else {
            resolvedCall.toFunctionKtCall(context)?.let { createCallInfo(context, element, it, listOf(resolvedCall), diagnostics) }
        }
    }

    private fun handleAsPropertyRead(context: BindingContext, element: KtElement): KtCallInfo? {