*/
    @Nullable
    public ModelPath getParent() {
        return null;
    }

    /**
     * Return the path of the scope of the nodes to select, or null if ancestor is not relevant.
     *
     * <p>A node will be selected if its path or one of its ancestor's path equals the specified path.</p>
     */
    @Nullable
    public ModelPath getAncestor() {
        return null;
    }

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

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

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

        private final ModelPath parent;
        private final ModelPath ancestor;
        private final Predicate<? super MutableModelNode> matcher;

        public BasicPredicate(ModelPath path, ModelPath parent, ModelPath ancestor, Predicate<? super MutableModelNode> matcher) {
            this.path = path;
            this.parent = parent;
            this.ancestor = ancestor;
            this.matcher = matcher;
        }

        @Nullable

  void runOnOperation() override;
};

// Get the ancestor of `descendant` that is a direct child of `ancestor`.
Operation* GetAncestorBelow(Operation* descendant, Operation* ancestor) {
  Operation* parent = descendant->getParentOp();
  if (!parent) return nullptr;
  if (parent == ancestor) return descendant;
  return GetAncestorBelow(parent, ancestor);
}

    public ModelPropertyExtractionContext(String propertyName) {
        this.propertyName = propertyName;
        this.accessors = Maps.newEnumMap(PropertyAccessorType.class);
    }

    public String getPropertyName() {
        return propertyName;
    }

    public boolean isReadable() {
        return hasGetter(accessors.keySet());
    }

        return new ArchCondition<JavaClass>("have accessors with symmetrical @Nullable annotations") {
            @Override
            public void check(JavaClass item, ConditionEvents events) {
                findMutableProperties(item).stream()
                    .filter(accessors -> !accessors.nullableIsSymmetric())
                    .map(accessor -> violated(item, String.format("Accessors for %s don't use symmetrical @Nullable", accessor)))

    def setup() {
        settingsFile << """
            rootProject.name = 'typesafe-project-accessors'
        """
    }

    def "generates type-safe project accessors for multi-project build"() {
        given:
        createDirs("one", "one/other", "two", "two/other")
        settingsFile << """
            include 'one'

                // TODO Can this happen on Windows when a SUBST'd drive is unregistered?
                throw new IllegalStateException("Couldn't find existing ancestor for " + path);
            }
            // TODO Use the VFS to find the ancestor instead
            if (candidate.isDirectory()) {
                return candidate;
            }
        }
    }