Method nextInline

parse/inline.go:137–179

(ref *gen.Elem, root string, params gen.GenericTypeParams)

`

func (fs *FileSet) nextInline(ref *gen.Elem, root string, params gen.GenericTypeParams) {
	switch el := (*ref).(type) {
	case *gen.BaseElem:
		// ensure that we're not inlining
		// a type into itself
		typ := el.TypeName()
		if el.Value == gen.IDENT && typ != root {
			if node, ok := fs.Identities[typ]; ok && node.Complexity() < maxComplex {
				infof("inlining %s\n", typ)

				// This should never happen; it will cause
				// infinite recursion.
				if node == *ref {
					panic(fatalloop)
				}

				*ref = node.Copy()
				fs.nextInline(ref, node.TypeName(), params)
			} else if !ok && !el.Resolved() {
				if params.ToPointerMap[typ] == "" && (!strings.Contains(typ, "[") || !strings.Contains(typ, "]")) {
					// this is the point at which we're sure that
					// we've got a type that isn't a primitive,
					// a library builtin, or a processed type
					warnf("unresolved identifier: %s\n", typ)
				}
			}
		}
	case *gen.Struct:
		for i := range el.Fields {
			fs.nextInline(&el.Fields[i].FieldElem, root, el.TypeParams())
		}
	case *gen.Array:
		fs.nextInline(&el.Els, root, params)
	case *gen.Slice:
		fs.nextInline(&el.Els, root, params)
	case *gen.Map:
		fs.nextInline(&el.Value, root, params)
	case *gen.Ptr:
		fs.nextInline(&el.Value, root, params)
	default:
		panic("bad elem type")
	}
}