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

func compressOrig(v ID, ancestor, semi, label []ID) {
	if ancestor[ancestor[v]] != 0 {
		compressOrig(ancestor[v], ancestor, semi, label)
		if semi[label[ancestor[v]]] < semi[label[v]] {
			label[v] = label[ancestor[v]]
		}
		ancestor[v] = ancestor[ancestor[v]]
	}
}

// evalOrig is the "simple" eval function from LT paper.
func evalOrig(v ID, ancestor, semi, label []ID) ID {
	if ancestor[v] == 0 {

    previous_op = best;
    for (Value result : best->getResults()) {
      todo.push(result);
    }
    for (Operation* successor : ctrlSuccessors(best)) {
      if (ancestor.find(successor) != ancestor.end()) {
        successor = ancestor[successor];
        remaining_incoming_ctrl_edges[successor]--;
        if (remaining_incoming_ctrl_edges[successor] == 0 &&
            remaining_incoming_data_edges[successor] == 0) {

        assert file.exists() && file.file

        expect:
        normalize(file) == file
    }

    def "normalizes relative path"() {
        def ancestor = new File(tmpDir.testDirectory, "test")
        def baseDir = new File(ancestor, "base")
        def sibling = new File(ancestor, "sub")
        def child = createFile(new File(baseDir, "a/b/file.txt"))

        expect:
        normalize("a/b/file.txt", baseDir) == child

        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;
            }
        }
    }