import "example.com/other"

func F() {
	dep.G()
	other.H()
}
-- dep/go.mod --
module example.com/dep
-- dep/dep.go --
package dep

func G() {
}
-- other/go.mod --
module example.com/other
-- other/dep.go --
package other

func G() {
}
-- other2/go.mod --
module example.com/other
-- other2/dep.go --
package other

func G() {

        file("src/main/scala/Other.scala") << """class Other"""
        file("src/main/scala/Other2.scala") << """class Other2"""

        def person = scalaClassFile("Person.class")
        def house = scalaClassFile("House.class")
        def other = scalaClassFile("Other.class")
        // We need an additional file since if >50% of files is changed everything gets recompiled

        "/var/hello/other"      | 5      | "hello/world/some" | 0
        "/var/hello1/other"     | 5      | "hello/world"      | 1
        "/var/abc/other"        | 5      | "bbc/some"         | -1
        "/var/hello/other"      | 1      | "hello/world/some" | 1
        "/var/hello/other"      | 5      | "hello/world/some" | 0
    }

go work use -r foo
cmp go.work go.want_work_r

! go work use other
stderr '^go: error reading other'${/}'go.mod: missing module declaration'

go mod edit -C other -module=other
go work use other
cmp go.work go.want_work_other
-- go.work --
go 1.18

use (
	foo
	foo/bar // doesn't exist
)
-- go.want_work_r --
go 1.18

use (
	./foo
	./foo/bar/baz
)
-- go.want_work_other --
go 1.18

use (
	./foo

				Other:    "test",
				Value:    1,
			},
		},
		// registered types get defaulted by the into object kind
		{
			data:        []byte(`{"value":1,"Other":"test"}`),
			into:        &testDecodable{},
			typer:       &mockTyper{gvk: &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"}},
			expectedGVK: &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"},

    private final PatternSet other;

    public IntersectionPatternSet(PatternSet other) {
        super(other);
        this.other = other;
    }

    public PatternSet getOther() {
        return other;
    }

    @Override
    public Spec<FileTreeElement> getAsSpec() {
        return Specs.intersect(super.getAsSpec(), other.getAsSpec());
    }

    @Override

        schema.prefer(usage, "best")
        def other = Attribute.of('other', String)
        schema.attribute(other)
        schema.accept(other, "requested", "compatible")
        schema.accept(other, "requested", "best")
        schema.prefer(other, "best")

        def candidate1 = attributes(usage: "best", other: "compatible")
        def candidate2 = attributes(usage: "no match", other: "no match")

            thing.other = "[$thing.other]"
        }

        when:
        mutate {
            afterEach(action)
            create('a') { other = "a" }
            create('b') { other = "b" }
        }

        then:
        realizeChild("a").other == "[a]"
        realizeChild("b").other == "[b]"
    }

    static class MutableValue {

    override fun equals(other: Any?): Boolean {
        return this === other ||
                other is KaContractIsInstancePredicateExpression &&
                other.backingArgument == backingArgument &&
                other.backingType == backingType &&
                other.backingIsNegated == backingIsNegated
    }
}

VariableInfo::VariableInfo(VariableInfo&& other)
    : index_(other.index_),
      var_(other.var_),
      definition_stack_trace_(other.definition_stack_trace_),
      lock_held_(other.lock_held_) {
  other.index_ = -1;
  other.var_ = nullptr;
}

VariableInfo& VariableInfo::operator=(VariableInfo&& other) {
  index_ = other.index_;
  var_ = other.var_;
  lock_held_ = other.lock_held_;