// Similarly so for return values: ret, ret1, ret2, ...
				name := "arg"
				if isret {
					name = "ret"
				}
				if argnum > 0 {
					name += strconv.Itoa(argnum)
				}
				names = []*ast.Ident{ast.NewIdent(name)}
			}
			argnum += len(names)

			// Create variable for each name.
			for _, id := range names {
				name := id.Name
				for _, c := range cc {
					outer := name + c.outer
					v := asmVar{

			// or the result type in a return statement. Create a pseudo-expression for that operand
			// that makes sense when reported in error messages from infer, below.
			expr := ast.NewIdent(T.desc)
			expr.NamePos = x.Pos() // correct position
			args = []*operand{{mode: value, expr: expr, typ: T.sig}}
			reverse = true
		}

		// Rename type parameters to avoid problems with recursive instantiations.

		for i := len(list) - 1; i >= 0; i-- {
			if par := &list[i]; par.typ != nil {
				typ = par.typ
				if par.name == nil {
					errPos = typ.Pos()
					n := ast.NewIdent("_")
					n.NamePos = errPos // correct position
					par.name = n
				}
			} else if typ != nil {
				par.typ = typ
			} else {
				// par.typ == nil && typ == nil => we only have a par.name

		{"MapType.Key", Field, 0},
		{"MapType.Map", Field, 0},
		{"MapType.Value", Field, 0},
		{"MergeMode", Type, 0},
		{"MergePackageFiles", Func, 0},
		{"NewCommentMap", Func, 1},
		{"NewIdent", Func, 0},
		{"NewObj", Func, 0},
		{"NewPackage", Func, 0},
		{"NewScope", Func, 0},
		{"Node", Type, 0},
		{"NotNilFilter", Func, 0},
		{"ObjKind", Type, 0},
		{"Object", Type, 0},