}];
}

def TFR_BuildListOp : TFR_Op<"build_list", [Pure]> {
  let description = [{
   The `build_list` operation builds a tensor list from a list of tensors, or
   an tfr.attr from a list of scalars.

    Example:

    ```mlir
    %3 = tfr.build_list(%2, %1, %0) :
      (tfr.tensor, tfr.tensor, tfr.tensor) -> tfr.tensor_list
    %3 = tfr.build_list(%2, %1, %0) : (i32, i32, i32) -> tfr.attr
    ```
  }];

                                 derived_attrs))) {
        return failure();
      }
      continue;
    }

    // 2. The preceding op is a tfr.build_list op, which collects multiple
    // values with tensor types via the tfr.cast ops. These ops will be fused
    // to the current op as well, so all the tfr.cast op inputs will be inputs
    // to the result op.

    // Create the new operands. This is mapping the operands from the target
    // TF ops to the TFR function arguments. If the TFR function argument is
    // a tensor_list, a "tfr.build_list" op is used to concat the available
    // TF op operands. If the TFR function argument isn't a tensor/tensor_list,
    // a constant is created by using the attribute stored in the TF op or the

		mg.buildList = slices.Clip(mg.g.BuildList())
	})
	return mg.buildList
}

func (mg *ModuleGraph) findError() error {
	errStack := mg.g.FindPath(func(m module.Version) bool {
		_, err := mg.loadCache.Get(m)
		return err != nil && err != par.ErrCacheEntryNotFound
	})
	if len(errStack) > 0 {
		_, err := mg.loadCache.Get(errStack[len(errStack)-1])
		var noUpgrade func(from, to module.Version) bool

    ) {
        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 {

            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) {