) {
        ServiceRegistryBuilder builder = ServiceRegistryBuilder.builder()
            .scopeStrictly(Scope.Global.class)
            .displayName("Global services")
            .provider(new GlobalScopeServices(longLiving, agentStatus, additionalModuleClassPath))
            .provider(new BuildProcessScopeServices());
        for (ServiceRegistry parent : parents) {
            builder.parent(parent);
        }

template <typename OpT>
OpT AddOperandAndRewriteAs(Operation* op, Value operand, NamedAttrList attr,
                           OpBuilder* builder) {
  builder->setInsertionPoint(op);
  auto operands = llvm::to_vector<4>(op->getOperands());
  operands.push_back(operand);
  auto new_op = builder->create<OpT>(op->getLoc(), op->getResultTypes(),
                                     operands, attr.getAttrs());

    private val builder: KaSymbolByFirBuilder,
) : KaClassErrorType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token

    override val qualifiers: List<KaClassTypeQualifier> by cached {
        when (coneDiagnostic) {
            is ConeUnresolvedError ->
                ErrorClassTypeQualifierBuilder.createQualifiersForUnresolvedType(coneDiagnostic, builder)

    override val coneType: ConeFlexibleType,
    private val builder: KaSymbolByFirBuilder,
) : KaFlexibleType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token

    override val lowerBound: KaType get() = withValidityAssertion { builder.typeBuilder.buildKtType(coneType.lowerBound) }
    override val upperBound: KaType get() = withValidityAssertion { builder.typeBuilder.buildKtType(coneType.upperBound) }

    override val coneType: ConeClassLikeTypeImpl,
    private val builder: KaSymbolByFirBuilder,
) : KaUsualClassType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token

    override val classId: ClassId get() = withValidityAssertion { coneType.lookupTag.classId }

    override val symbol: KaClassLikeSymbol
        get() = withValidityAssertion {

    protected final ModelMapping modelMapping;
    private final InternalCancellableConnection builder;
    protected final CancellationExceptionTransformer exceptionTransformer;

    public CancellableModelBuilderBackedModelProducer(ProtocolToModelAdapter adapter, VersionDetails versionDetails, ModelMapping modelMapping, InternalCancellableConnection builder, CancellationExceptionTransformer exceptionTransformer) {
        this.adapter = adapter;

            ImmutableSet.Builder<Problem> builder = ImmutableSet.builder();
            getProblems(buildFailure, builder);
            return builder.build();
        }

        private void getProblems(@Nullable Throwable buildFailure, ImmutableSet.Builder<Problem> builder) {
            while (buildFailure != null) {

    private final CacheFactory cacheFactory = Mock()
    private final PersistentCache cache = Mock()
    private final DefaultCacheBuilder builder = new DefaultCacheBuilder(cacheFactory, sharedCacheDir)

    void createsGlobalDirectoryBackedCache() {
        when:
        def result = builder.open()

        then:
        result == cache
        1 * cacheFactory.open(sharedCacheDir, null, [:], mode(Shared), _, NO_CLEANUP) >> cache

// opposed to being extracted into a separate tfl.pad).
StringAttr GetAvgPoolOpPadAttr(Builder& builder, mhlo::CompositeOp op);

// Get dense attr for a matrix that corrects the over counting of divisors when
// casting an average pool with ceil mode on in terms of average pool with it
// off.
DenseFPElementsAttr GetCorrectionMatrix(Builder& builder, mhlo::CompositeOp op);

}  // namespace odml
}  // namespace mlir

    override val returnType: KaType get() = withValidityAssertion { firSymbol.returnType(builder) }
    override val receiverParameter: KaReceiverParameterSymbol? get() = withValidityAssertion { firSymbol.receiver(builder) }

    override val contextReceivers: List<KaContextReceiver> by cached { firSymbol.createContextReceivers(builder) }

    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }