allProjects.includedBuildIdeaProjects.keySet().collect { it.buildIdentifier.rootDir.name } == ['module-a', 'module-b']
    }

    def "IDEA can handle indirect cycles between included builds"() {
        given:
        compositeWithIndirectIncludeCycle()

        when:
        def allProjects = withConnection {c -> c.action(new IdeaProjectUtil.GetAllIdeaProjectsAction()).run() }

		field.ValueOf = func(ctx context.Context, value reflect.Value) (interface{}, bool) {
			fieldValue := reflect.Indirect(value).Field(fieldIndex)
			return fieldValue.Interface(), fieldValue.IsZero()
		}
	default:
		field.ValueOf = func(ctx context.Context, v reflect.Value) (interface{}, bool) {
			v = reflect.Indirect(v)
			for _, fieldIdx := range field.StructField.Index {
				if fieldIdx >= 0 {
					v = v.Field(fieldIdx)

module m

go 1.16
-- go.mod.latest --
module m

go 1.16

replace rsc.io/quote => ./quote

require rsc.io/quote v1.5.2 // indirect
-- go.mod.specific --
module m

go 1.16

replace rsc.io/quote v1.0.0-doesnotexist => ./quote

require rsc.io/quote v1.0.0-doesnotexist // indirect
-- use.go --
package use

import _ "rsc.io/quote"
-- quote/go.mod --
module rsc.io/quote

go 1.16
-- quote/quote.go --

					distinctElems := reflect.MakeSlice(reflect.SliceOf(fieldType), 0, 10)
					identityMap := map[string]bool{}
					for i := 0; i < rValLen; i++ {
						obj := db.Statement.ReflectValue.Index(i)
						if reflect.Indirect(obj).Kind() != reflect.Struct {
							break
						}
						if _, zero := rel.Field.ValueOf(db.Statement.Context, obj); !zero { // check belongs to relation value

package prop.`in`.`companion`.indirect.twice

class Test {
    fun test() {
        val x = <expr>oneMore</expr>
    }
    companion object {
        // effectively constant
        val someField = "something"
        val indirectPointer = someField
        val oneMore = indirectPointer
    }

			}
			if got, want := sel.Index(), m.index; !sameSlice(got, want) {
				t.Errorf("%s [method %d]: got index = %v, want %v", src, i, got, want)
			}
			if got, want := sel.Indirect(), m.indirect; got != want {
				t.Errorf("%s [method %d]: got indirect = %v, want %v", src, i, got, want)
			}
		}
	}

	for src, methods := range tests {
		check(src, methods, false)
	}

	for src, methods := range tParamTests {

	len.Println /* ERROR "cannot select on len" */
	len.Println /* ERROR "cannot select on len" */ ()
	_ = len.Println /* ERROR "cannot select on len" */
	_ = len /* ERROR "cannot index len" */ [0]
	_ = *len /* ERROR "cannot indirect len" */

# golang.org/issue/36580

env GO111MODULE=on

go mod vendor
cmp go1.14-modules.txt vendor/modules.txt

-- go.mod --
module example.com/m
go 1.14

require example.com v1.0.0 // indirect
-- go.sum --
example.com v1.0.0/go.mod h1:WRiieAqDBb1hVdDXLLdxNtCDWNfehn7FWyPC5Oz2vB4=
-- go1.14-modules.txt --
# example.com v1.0.0

// The inliner would erroneously scan the caller function's body for
// reassignments *before* substituting the inlined function call body,
// which could cause false positives in deciding when it's safe to
// transitively inline indirect function calls.

package main

func main() {
	bug1()
	bug2(fail)
}

func bug1() {
	fn := fail
	fn = pass
	fn()
}

func bug2(fn func()) {
	fn = pass
	fn()
}

	}

	realPkgPath := unmassage(pkg.PkgPath)

	direct, indirect := transitiveImports(pkg)
	isDirect := map[string]bool{}
	for _, imp := range direct {
		isDirect[imp] = true
	}
	relate := func(imp string) string {
		if isDirect[imp] {
			return "->"
		}
		return "-->"
	}

	var errs []error
	for _, imp := range uniq(direct, indirect) {
		if unmassage(imp) == realPkgPath {