public class BuildOperationExecutorSupport {

    public static Builder builder(int numThreads) {
        return builder(new DefaultWorkerLimits(numThreads));
    }

    public static Builder builder(WorkerLimits workerLimits) {
        return new Builder(workerLimits);
    }

    public static class Builder {
        private final WorkerLimits workerLimits;

}

// Build build where clause
func (limit Limit) Build(builder Builder) {
	if limit.Limit != nil && *limit.Limit >= 0 {
		builder.WriteString("LIMIT ")
		builder.AddVar(builder, *limit.Limit)
	}
	if limit.Offset > 0 {
		if limit.Limit != nil && *limit.Limit >= 0 {
			builder.WriteByte(' ')
		}
		builder.WriteString("OFFSET ")
		builder.AddVar(builder, limit.Offset)
	}
}

// MergeClause merge order by clauses

            protected void defaultSpec(BuildExperimentSpec.Builder builder) {
                super.defaultSpec(builder)
                builder.workingDirectory = temporaryFolder.testDirectory
            }

            @Override
            protected void configureGradleSpec(GradleBuildExperimentSpec.GradleBuilder builder) {
                super.configureGradleSpec(builder)

    }

    public void format(StringBuilder builder, long size) {
        format(builder, size, null, false);
    }

    public void format(StringBuilder builder, long size, ScaleUnit unit) {
        format(builder, size, unit, false);
    }

    @SuppressWarnings("checkstyle:magicnumber")
    private void format(StringBuilder builder, long size, ScaleUnit unit, boolean omitSymbol) {
        if (size < 0L) {

    substitutor: ConeSubstitutor,
    builder: KaSymbolByFirBuilder,
) : AbstractKaFirSubstitutor<ConeSubstitutor>(substitutor, builder)

@OptIn(KaAnalysisApiInternals::class)
internal class KaFirMapBackedSubstitutor(
    substitutor: ConeSubstitutorByMap,
    builder: KaSymbolByFirBuilder,
) : AbstractKaFirSubstitutor<ConeSubstitutorByMap>(substitutor, builder,), KaMapBackedSubstitutor {

    /**
     * Creates a new factory for the given context. Returns a {@link Builder} for further configuration of the created instance. You must provide an Instantiator when creating the child factory from
     * the root one.
     */
    Builder forContext();

    /**
     * Builder to configure an instance of the new factory.
     */
    interface Builder {
        Builder withFileResolver(FileResolver fileResolver);

                getSymbolDescriptor(builder.symbol) as? ClassDescriptor
            }
        }

        if (descriptor == null) {
            val name = when (builder) {
                is KaClassTypeBuilder.ByClassId -> builder.classId.asString()
                is KaClassTypeBuilder.BySymbol ->
                    builder.symbol.classId?.asString()
                        ?: builder.symbol.name?.asString()

        }
        if (depth != null) {
            builder.field(DEPTH, depth);
        }
        if (lastModified != null) {
            builder.field(LAST_MODIFIED, lastModified);
        }
        if (createTime != null) {
            builder.field(CREATE_TIME, createTime);
        }
        builder.endObject();
        return builder;
    }

                   OpBuilder* builder) {
  llvm::SetVector<Value> live_ins;
  getUsedValuesDefinedAbove(launch_op.getBody(), launch_op.getBody(), live_ins);

  func::FuncOp outlined_func =
      BuildFunction(live_ins.getArrayRef(), launch_op, symbol_table, builder);
  launch_op->setAttr(
      builder->getStringAttr(kFuncAttr),
      mlir::SymbolRefAttr::get(builder->getContext(), outlined_func.getName()));

        StringBuilder builder = new StringBuilder();
        builder.append("Could not download ");
        builder.append(artifact.getDisplayName());
        if (GUtil.isTrue(message)) {
            builder.append(": ");
            builder.append(message);
        }
        return builder.toString();
    }