)
        }
    }

    private
    fun WriteContext.isTaskReferencesAllowed(value: Task): Boolean {
        val owner = isolate.owner
        val delegate = owner.delegate

        val isTaskReferencesAllowed = owner is IsolateOwners.OwnerTask && owner.allowTaskReferences
        val isTaskFromSameProject = delegate is Task && delegate.project == value.project

            public TaskExecutionLock create(Path key, ResourceLockCoordinationService coordinationService, ResourceLockContainer owner) {
                return new TaskExecutionLock("task execution for " + projectIdentityPath.getPath(), projectLockRegistry.getProjectLock(buildIdentityPath, projectIdentityPath1), coordinationService, owner);
            }
        });
    }

  - cpanato # SIG Technical Lead / RelEng subproject owner / Release Manager
  - dims
  - jeremyrickard # SIG Technical Lead / RelEng subproject owner
  #- justaugustus # SIG Chair / RelEng subproject owner / Release Manager - approvals only
  - liggitt
  - palnabarun # Release Manager
  - puerco # SIG Technical Lead / RelEng subproject owner / Release Manager
  - saschagrunert # SIG Chair / RelEng subproject owner / Release Manager
  - spiffxp
  - thockin

        abstract void setup(AbstractIntegrationSpec owner)

        abstract void publishWithDifferentArtifactContent(AbstractIntegrationSpec owner)

        abstract void publishWithDifferentDependencies(AbstractIntegrationSpec owner)

        abstract void publishNewVersion(AbstractIntegrationSpec owner)
    }

    abstract class MavenRepoSetup extends FileRepoSetup {

		}
	}
	inodes[f] = ino

	var wait chan File
	l := locks[ino]
	if l.owner == f {
		// This file already owns the lock, but the call may change its lock type.
	} else if l.owner == nil {
		// No owner: it's ours now.
		l.owner = f
	} else {
		// Already owned: add a channel to wait on.
		wait = make(chan File)
		l.queue = append(l.queue, wait)
	}
	locks[ino] = l

        DomainObjectContext owner,
        CalculatedValueContainerFactory calculatedValueContainerFactory,
        FilteredResultFactory filteredResultFactory
    ) {
        this.configurationIdentity = configurationIdentity;
        this.rootComponentProvider = rootComponentProvider;
        this.owner = owner;
        this.filteredResultFactory = filteredResultFactory;

    }

    private class DefaultBuildTreeWorkGraphBuilder implements BuildTreeWorkGraph.Builder {
        private final DefaultBuildTreeWorkGraph owner;

        public DefaultBuildTreeWorkGraphBuilder(DefaultBuildTreeWorkGraph owner) {
            this.owner = owner;
        }

        @Override
        public void withWorkGraph(BuildState target, Consumer<? super BuildLifecycleController.WorkGraphBuilder> action) {

            @Override
            public AllProjectsLock create(Path key, ResourceLockCoordinationService coordinationService, ResourceLockContainer owner) {
                String displayName = "All projects of " + buildIdentityPath;
                return new AllProjectsLock(displayName, coordinationService, owner);
            }
        });
    }

    public ProjectLock getProjectLock(Path buildIdentityPath, Path projectIdentityPath) {

func (gc *GarbageCollector) removeFinalizer(logger klog.Logger, owner *node, targetFinalizer string) error {
	err := retry.RetryOnConflict(retry.DefaultBackoff, func() error {
		ownerObject, err := gc.getObject(owner.identity)
		if errors.IsNotFound(err) {
			return nil
		}
		if err != nil {
			return fmt.Errorf("cannot finalize owner %s, because cannot get it: %v. The garbage collector will retry later", owner.identity, err)
		}

        annotation: KaAnnotation,
        owner: KaAnnotated,
        annotationRenderer: KaAnnotationRenderer,
        printer: PrettyPrinter,
    )

    public object WITHOUT_USE_SITE : KaAnnotationUseSiteTargetRenderer {
        override fun renderUseSiteTarget(
            analysisSession: KaSession,
            annotation: KaAnnotation,
            owner: KaAnnotated,
            annotationRenderer: KaAnnotationRenderer,