var dummy metaonly.MetadataOnlyObject
	var blockingRefs []metav1.OwnerReference
	falseVar := false
	for _, owner := range n.owners {
		if owner.BlockOwnerDeletion != nil && *owner.BlockOwnerDeletion {
			ref := owner
			ref.BlockOwnerDeletion = &falseVar
			blockingRefs = append(blockingRefs, ref)
		}
	}
	dummy.ObjectMeta.SetOwnerReferences(blockingRefs)

        val firSession = analysisSession.useSiteSession
        val scopeSession = analysisSession.getScopeSessionFor(firSession)
        return if (isStatic) {
            val firClass = owner.fir
            firClass.scopeProvider.getStaticCallableMemberScope(firClass, firSession, scopeSession)
        } else {
            owner.unsubstitutedScope(

                    import ${Closure.name};
                    public abstract class MyBaseClosure extends Closure<String> {
                        protected MyBaseClosure(Object owner) {
                            super(owner);
                        }

                        protected final void setDelegateBase(Object delegate) {
                            super.setDelegate(delegate);
                        }

    dynamicObjectFor(target).let { owner ->
        if (property.returnType.isMarkedNullable) NullableDynamicPropertyDelegate(dynamicLookupRoutine, owner, property.name)
        else NonNullDynamicPropertyDelegate(dynamicLookupRoutine, owner, property.name) { target.toString() }
    }


private
fun dynamicObjectFor(target: Any): DynamicObject =

 * also be implemented directly.
 */
public interface OwnerAware {
    /**
     * Notifies this object that it now has an owner associated with it.
     *
     * @param owner The owner object, if any.
     * @param displayName The display name for this object.
     */
    void attachOwner(@Nullable ModelObject owner, DisplayName displayName);

					// cluster-scoped owners can be referenced as an owner from any namespace or cluster-scoped object.
					logger.V(2).Info("item references an owner but does not match namespaces", "item", n.identity, "owner", ownerNode.identity)
					gb.reportInvalidNamespaceOwnerRef(n, owner.UID)
				}
				hasPotentiallyInvalidOwnerReference = true
			} else if !ownerReferenceMatchesCoordinates(owner, ownerNode.identity.OwnerReference) {

        boolean remove(Object source);

        ValueCollector setFrom(DefaultConfigurableFileCollection owner, PathToFileResolver resolver, Factory<PatternSet> patternSetFactory, TaskDependencyFactory taskDependencyFactory, PropertyHost propertyHost, Iterable<?> path);

        _ * task.toString() >> "<task>"
        _ * task.state >> state
        def owner = Stub(ModelObject)
        _ * owner.taskThatOwnsThisObject >> task
        def property = TestUtil.objectFactory().property(String)
        property.attachOwner(owner, Describables.of("<prop>"))
        property.attachProducer(owner)
        property.set("12")
        return property
    }

    private final DefaultResolvedArtifact publicView;

    public PreResolvedResolvableArtifact(@Nullable ModuleVersionIdentifier owner, IvyArtifactName artifact, ComponentArtifactIdentifier artifactId, File file, TaskDependencyContainer builtBy, CalculatedValueFactory calculatedValueFactory) {
        this.owner = owner;
        this.artifact = artifact;
        this.artifactId = artifactId;
        this.file = file;

    private final ModuleVersionIdentifier owner;
    private final IvyArtifactName artifactName;

    public DefaultResolvedArtifact(ComponentArtifactIdentifier id, CalculatedValue<File> fileSource, @Nullable ModuleVersionIdentifier owner, IvyArtifactName artifactName) {
        this.id = id;
        this.fileSource = fileSource;
        this.owner = owner;
        this.artifactName = artifactName;
    }