umJSONEnum implements json.Unmarshaler only, so it exercises the JSON branch of the unmarshal-by-interface path. All types in this file are package-le

umLevelTextAndSetter is a non-struct type with a text form and a setter. Behind a pointer its setter is called from the pointer branch of setField, wh

SetterLevel is a non-struct type with a setter. The struct recursion never reaches it, so behind a pointer its only call is the one the pointer branch

benchJSON takes every tag and stores its length.

benchText takes every tag and stores its length.

umFailingJSON always fails, so Set has to fall back to parsing by kind.

umFailingText always fails, so Set has to fall back to parsing by kind.

Config implements defaults.Setter for ExampleSetter below.

Endpoint implements defaults.Setter for Example below.

OptOutSetter records whether its setter ran, so a test can tell whether `default:"-"` suppresses the setter along with the tags. It is package-level o

Setter is an interface for setting default values. Set calls SetDefaults on a struct once it has filled the struct's fields, and again for every othe

SetterCounter counts its own invocations. Its name is exported because it is embedded below, for the same reason as SetterInner's.

SetterInner is embedded by pointer below, which is why its name is exported: an embedded field takes the name of its type, and an unexported one would

UmTextAndSetter implements encoding.TextUnmarshaler and defaults.Setter, and appends to Via as each one runs, so a test can tell "only text ran" from

benchRejecting rejects every tag from both unmarshalers, so parsing by kind takes it. The rejection is an error that already exists, so it allocates n

benchRejectingStruct rejects every tag, and is a struct, so encoding/json is tried next.

benchSetterItem has a SetDefaults that does nothing, so Set leaves a filled one as it is.

cycleCounter counts its setter's calls, so a test can tell how many times the walk reached it. It is package-level only because it needs a method.

An empty tag still allocates a pointer, so it recurses like any other.

fieldTag is the `default` tag as it applies to one field: the field's name, for error messages, the tag's value, and whether the tag was present at al

indexEntry is an entry the path's index holds: its key, and the next entry in its bucket.

mapKeyHook runs hook when Set calls its setter, so a test can change the map holding it while Set walks that map. It is package-level only because it

methodEmbedsPointerField embeds a pointer, and takes the method through it.

methodEmbedsPointerReceiver embeds a value whose method has a pointer receiver, so the method is in the embedding pointer's set alone.

methodEmbedsTwice takes it from a field that took it from a field.

methodEmbedsValue takes it from a field, promoted.

methodPinger is embedded as an interface, so the method is promoted from a field that holds it.

methodPointer declares it on a pointer receiver, so only a pointer to it has the method.

methodShadows declares its own over the one it would take from its field, and calls through to it, as a type that means to add to an embedded method d

This test is in package defaults rather than defaults_test: isPromotedMethod is unexported, and Set reaches it only with a struct, a setter and a walk

optOutRoot is the documented way to give an opted-out field a dynamic default: the tag says "hands off", and the struct's own setter fills it in.

pathIndex is the index of a path too deep to scan: the entries at the top of the path, down to some depth, and a hash table of their keys. Entries joi

pathKey names an entry in the path's index by its address, its type and its length. They are held as uintptrs, not pointers: a pointer read off an ent

pendingDefault is a tag being applied to a zero value further up the current path, linked to the one being applied above it.