Method needMethods

types/methods.go:153–238

Precondition: T is not a method signature (*Signature with Recv()!=nil). Recursive case: skip => don't create methods for T. EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)

(T Type, skip bool)

// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
//
func (prog *Program) needMethods(T Type, skip bool) {
	// Each package maintains its own set of types it has visited.
	if prevSkip, ok := prog.runtimeTypes.At(T).(bool); ok {
		// needMethods(T) was previously called
		if !prevSkip || skip {
			return // already seen, with same or false 'skip' value
		}
	}
	prog.runtimeTypes.Set(T, skip)

	tmset := prog.MethodSets.MethodSet(T)

	if !skip && !isInterface(T) && tmset.Len() > 0 {
		// Create methods of T.
		mset := prog.createMethodSet(T)
		if !mset.complete {
			mset.complete = true
			n := tmset.Len()
			for i := 0; i < n; i++ {
				prog.addMethod(mset, tmset.At(i))
			}
		}
	}

	// Recursion over signatures of each method.
	for i := 0; i < tmset.Len(); i++ {
		sig := tmset.At(i).Type().(*Signature)
		prog.needMethods(sig.Params(), false)
		prog.needMethods(sig.Results(), false)
	}

	switch t := T.(type) {
	case *Basic:
		// nop

	case *Interface, *TypeParam:
		// nop---handled by recursion over method set.

	case *Pointer:
		prog.needMethods(t.Elem(), false)

	case *Slice:
		prog.needMethods(t.Elem(), false)

	case *Chan:
		prog.needMethods(t.Elem(), false)

	case *Map:
		prog.needMethods(t.Key(), false)
		prog.needMethods(t.Elem(), false)

	case *Signature:
		if t.Recv() != nil {
			panic(fmt.Sprintf("Signature %s has Recv %s", t, t.Recv()))
		}
		prog.needMethods(t.Params(), false)
		prog.needMethods(t.Results(), false)