ModelRegistry registry = context.getRegistry();
        switch (ruleApplicationScope) {
            case SELF:
                registry.configure(role, action);
                break;
            case DESCENDANTS:
                registry.configureMatching(new NonReferenceDescendantsSpec(context.getScope()), role, action);
                break;
            default:
                throw new AssertionError();
        }
    }

Laura Kassovic <******@****.***> 1701107622 -0800

        run "app:${language.compileTaskName}", "-x", "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
        app.recompiledClasses("C")
    }

    def "deletion of jar without dependents does not recompile any classes"() {
        source api: ["class A {}"], impl: ["class SomeImpl {}"]
        impl.snapshot { run language.compileTaskName }

        when:
        clearImplProjectDependencies()

	if err := syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
		return os.NewSyscallError("setsockopt", err)
	}
	// Allow reuse of recently-used ports.
	// This option is supported only in descendants of 4.4BSD,
	// to make an effective multicast application that requires
	// quick draw possible.
	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEPORT, 1))

        }

        then:
        events.assertIsABuild()

        def buildSrc = events.operation("Build buildSrc")
        def groovyPlugin = buildSrc.descendant("Apply plugin org.gradle.api.plugins.GroovyPlugin to project ':buildSrc'")

        buildSrc.descendant("Apply plugin org.gradle.api.plugins.JavaLibraryPlugin to project ':buildSrc'")

        then: "The filtered tree uses the cached state"
        relativePaths as Set == ["d1", "d1/f1", "f1"] as Set
    }

    def "reuses cached descendant tree on read"() {
        given:
        def parentDir = temporaryFolder.createDir("parent")
        def childDir = parentDir.createDir("child")
        childDir.file("file.txt").createFile()

  mlir::tf_device::ClusterOp cluster;
  std::string device = "/job:localhost/replica:0/task:0/device:CPU:0";
  module->walk(
      [&](mlir::tf_device::ClusterOp descendant) { cluster = descendant; });
  mlir::OpBuilder builder(&context);
  auto loc = cluster->getLoc();

  // Wrap the cluster op into a Launch op
  auto launch_op = tensorflow::WrapOpInLaunch(&builder, loc, cluster, device);

					UID: types.UID("bravo"),
				},
			},
			dependents: map[*node]struct{}{
				alphaNode(): {},
			},
		}
	}
	charlieNode = func() *node {
		return &node{
			identity: objectReference{
				OwnerReference: metav1.OwnerReference{
					UID: types.UID("charlie"),
				},
			},
			dependents: map[*node]struct{}{
				alphaNode(): {},
			},
		}
	}
	deltaNode = func() *node {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

@NonNullApi
package org.gradle.api.reporting.dependents.internal;

    /**
     * Returns the path of this project. This is a unique identifier for this project within the build.
     *
     * @return The path.
     */
    String getPath();

    /**
     * Searches all descendants (children, grand-children, etc.), including self, by given path.
     *
     * @return Gradle project with matching path or {@code null} if not found.
     */
    @Nullable
    GradleProject findByPath(String path);