OsxFileWatcher watcher,
        FileWatcherProbeRegistry probeRegistry,
        WatchableHierarchies watchableHierarchies
    ) {
        return new HierarchicalFileWatcherUpdater(watcher, DarwinFileWatcherRegistryFactory::validateLocationToWatch, probeRegistry, watchableHierarchies, root -> Collections.emptyList());
    }

    /**
     * The macOS native watcher reports the canonical path for watched paths.

apiVersion: release-notes/v2
kind: bug-fix
area: security
issue:
  - 33293
releaseNotes:
  - |

         *
         * On Windows when watched directories are moved, the OS does not send a notification,
         * even though the VFS should be updated.
         *
         * On Linux, when you move the parent directory of a watched directory, then there isn't a notification.
         *
         * Our best bet here is to cull any moved watched directories from the VFS at the start of every build.
         */

    def setup() {
        updater = createUpdater(watcher, watchableHierarchies)
    }

    /**
     * Returns 1 for non-hierarchical watchers, and 0 for hierarchical watchers.
     *
     * For use in interaction tests, when an interaction only happens for non-hierarchical watchers.
     * E.g.:
     * ifNonHierarchical * watcher.startWatching(_)
     */
    abstract int getIfNonHierarchical()

    /**

	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"istio.io/istio/pkg/kube"
)

const (
	configMapNamespace string = "istio-system"
	configMapName      string = "watched"
)

func makeConfigMap(name, resourceVersion string) *v1.ConfigMap {
	return &v1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{
			Namespace:       configMapNamespace,
			Name:            name,

     *
     * Only locations within watchable hierarchies will be watched for changes.
     * This method is first called for the root directory of the root project.
     * It is also called for the root directories of included builds, and all other nested builds.
     */
    void registerWatchableHierarchy(File rootDirectoryForWatching);

    /**
     * Returns if anything is being watched.
     */
    boolean isWatchingAnyLocations();

    /**

        def symlink = linkdir.file("link")
        // Since we remove symlinks at the end of the build from the VFS, we
        // need an existing sibling of the symlink to ensure the parent directory of
        // the symlink is watched between builds.
        linkdir.file("existing").createFile()
        buildFile << """
    task echo {
        def symlink = file("${symlink.toURI()}")
        inputs.files symlink

	"os"
	"sync"

	"github.com/fsnotify/fsnotify"
)

type worker struct {
	mu sync.RWMutex

	// watcher is an fsnotify watcher that watches the parent
	// dir of watchedFiles.
	dirWatcher *fsnotify.Watcher

	// The worker maintains a map of channels keyed by watched file path.
	// The worker watches parent path of given path,
	// and filters out events of given path, then redirect
	// to the result channel.

)

// Event represents a single event to a watched resource.
// +k8s:deepcopy-gen=true
type Event struct {
	Type EventType

	// Object is:
	//  * If Type is Added or Modified: the new state of the object.
	//  * If Type is Deleted: the state of the object immediately before deletion.
	//  * If Type is Bookmark: the object (instance of a type being watched) where

        try {
            watcher.shutdown();
            if (!watcher.awaitTermination(5, TimeUnit.SECONDS)) {
                throw new RuntimeException("Watcher did not terminate within 5 seconds");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new InterruptedIOException("Awaiting termination of watcher was interrupted");
        } finally {