%0 = "tfr.cast"(%arg0) : (tensor<f32>) -> !tfr.tensor
  %1 = "tfr.cast"(%arg1) : (tensor<f32>) -> !tfr.tensor
  %2 = "tfr.cast"(%arg2) : (tensor<f32>) -> !tfr.tensor
  %3 = "tfr.build_list"(%0, %1, %2) : (!tfr.tensor, !tfr.tensor, !tfr.tensor) -> !tfr.tensor_list
  %concat = tfr.call @tf__risc_concat(%3) : (!tfr.tensor_list) -> !tfr.tensor
  %4 = "tfr.cast"(%concat) : (!tfr.tensor) -> tensor<3xf32>

Austin Clements <******@****.***> 1695243700 -0400

    ) {
        analyseForTest(callableDeclaration) {
            val typesToCheckOn = buildList {
                add(builtinTypes.int)
                add(buildClassType(StandardClassIds.List) { argument(builtinTypes.long) })
            }

            val symbol = callableDeclaration.getSymbol() as KaCallableSymbol
            val typeParameters = buildList {
                addAll(symbol.typeParameters)

            val assignments = buildList {
                softwareType.conventions.filterIsInstance<AssignmentRecordConvention>().forEach { it.apply(::add) }
            }
            val additions = buildList {
                softwareType.conventions.filterIsInstance<AdditionRecordConvention>().forEach { it.apply(::add) }
            }
            val nestedObjectAccess = buildList {

        List<TaskSegment> taskSegments = lifecycleTaskSegmentCalculator.calculateTaskSegments(session);

        final ProjectBuildList buildList = buildListCalculator.calculateProjectBuilds(session, taskSegments);
        final ProjectBuildList segments = buildList.getByTaskSegment(taskSegments.get(0));
        assertEquals(3, taskSegments.size(), "Stub data contains 3 segments");

            buildList {
                add(project.createDeclarationProvider(useSiteAnalysisScope, useSiteModule))
                extensionTools.mapTo(this) { it.declarationProvider }
            }
        )

        useSitePackageProvider = KotlinCompositePackageProvider.create(
            buildList {
                add(project.createPackageProvider(useSiteAnalysisScope))

public class KotlinByModulesResolutionScopeProvider : KotlinResolutionScopeProvider() {
    override fun getResolutionScope(module: KtModule): GlobalSearchScope {
        val allModules = topologicalSort(listOf(module)) {
            buildList {
                addAll(directDependsOnDependencies)
                addAll(directFriendDependencies)
                addAll(directRegularDependencies)
            }
        }

    override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): Iterable<CollectedPropertyInformation> = buildList {
        val nameSet = mutableSetOf<String>()
        val predicateWithNamesFiltered: (String) -> Boolean = { propertyNamePredicate(it) && it !in nameSet }
        extractors.forEach { extractor ->

    private val ignoredAnnotations: Set<ClassId> = emptySet()
) : AbstractList<KaAnnotation>(), KaAnnotationList {
    private val backingAnnotations: List<KaAnnotation> by lazy {
        buildList {
            fe10Annotations.forEachIndexed { index, annotationDescriptor ->
                if (annotationDescriptor.classIdForAnnotation !in ignoredAnnotations) {

    val ktFiles = Files.walk(kLibSourcesRoot).asSequence().filter { it.extension == "kt" }.toList()
    val testKlib = KtTestUtil.tmpDir("testLibrary").resolve("library.klib").toPath()

    val arguments = buildList {
        ktFiles.mapTo(this) { it.absolutePathString() }
        addAll(listOf("-produce", "library"))
        addAll(listOf("-output", testKlib.absolutePathString()))
    }