"io"
)

func defaultImporter() types2.Importer {
	return &gcimports{
		packages: make(map[string]*types2.Package),
	}
}

type gcimports struct {
	packages map[string]*types2.Package
	lookup   func(path string) (io.ReadCloser, error)
}

func (m *gcimports) Import(path string) (*types2.Package, error) {
	return m.ImportFrom(path, "" /* no vendoring */, 0)
}

		pkg := mustTypecheck(test.src, nil, nil)

		t.Run(pkg.Name(), func(t *testing.T) {
			ctxt := NewContext()

			T1 := pkg.Scope().Lookup(test.name1).Type()
			res1, err := Instantiate(ctxt, T1, test.targs1, false)
			if err != nil {
				t.Fatal(err)
			}

			T2 := pkg.Scope().Lookup(test.name2).Type()
			res2, err := Instantiate(ctxt, T2, test.targs2, false)
			if err != nil {
				t.Fatal(err)
			}

# non-existent directory should not prompt lookups
! go build -mod=readonly example.com/nonexist
stderr 'import lookup disabled'

! go build -mod=readonly ./nonexist
! stderr 'import lookup disabled'
stderr '^stat '$GOPATH'[/\\]src[/\\]x[/\\]nonexist: directory not found'

! go build -mod=readonly ./go.mod
! stderr 'import lookup disabled'
stderr 'main module \(m\) does not contain package m/go.mod'

        return Iterators.concat(initialDirectives, visible.values().iterator());
    }

    public void appendTo(CollectingMacroLookup lookup) {
        collectAll();
        if (visible != null) {
            for (Map.Entry<File, IncludeDirectives> entry : visible.entrySet()) {
                lookup.append(entry.getKey(), entry.getValue());
            }
        }
    }

    private void collectAll() {

        original.set(originalValue)

        given:
        1 * managedFactoryRegistry.lookup(ManagedFactories.PropertyManagedFactory.FACTORY_ID) >> new ManagedFactories.PropertyManagedFactory(TestUtil.propertyFactory())
        1 * managedFactoryRegistry.lookup(ManagedFactories.ProviderManagedFactory.FACTORY_ID) >> new ManagedFactories.ProviderManagedFactory()

        expect:

	// instantiated with identical type arguments.
	if got := ctxt.lookup("", unaryP, []Type{Typ[Int]}); got != nil {
		t.Error("bad")
	}

	// nullaryQ is identical to nullaryP, so we *should* get inst when
	// instantiated with identical type arguments.
	if got := ctxt.lookup("", nullaryQ, []Type{Typ[Int]}); got != inst {
		t.Error("bad")
	}

	timeout       time.Duration // wait before giving up on a query, including retries
	attempts      int           // lost packets before giving up on server
	rotate        bool          // round robin among servers
	unknownOpt    bool          // anything unknown was encountered
	lookup        []string      // OpenBSD top-level database "lookup" order

        dep.exclusions.contains(exclusion)
    }

    MavenDependency expectDependency(String key, Map<String, MavenDependency> lookup = dependencies) {
        final dependency = lookup[key]
        if (dependency == null) {
            throw new AssertionError("Could not find expected dependency $key. Actual: ${lookup.values()}")
        }
        return dependency
    }

    MavenDependency expectDependencyManagement(String key) {

MutableComponentLook { private MutablePlexusContain container; public void DefaultComponentLook(); public Object lookup(String) throws component.repository.exception.ComponentLookupExcep; public Object lookup(String, classworlds.realm.ClassRealm) throws component.repository.exception.ComponentLookupExcep; public Object lookup(Class) throws component.repository.exception.ComponentLookupExcep; public Object lookup(Class, classworlds.realm.ClassRealm) throws component.repository.exception.ComponentLookupExcep; public...

func (s *Scope) Child(i int) *Scope { return s.children[i] }

// Lookup returns the object in scope s with the given name if such an
// object exists; otherwise the result is nil.
func (s *Scope) Lookup(name string) Object {
	obj := resolve(name, s.elems[name])
	// Hijack Lookup for "any": with gotypesalias=1, we want the Universe to
	// return an Alias for "any", and with gotypesalias=0 we want to return