tdp

type Accessor struct {
	Offset Offset

	// The Getter for extracting the field.
	Getter Getter
}

type Aux struct {
	Layout debug.Value[TypeLayout]

	Library          *Library
	Descriptor       protoreflect.MessageDescriptor
	Methods          protoiface.Methods
	FieldDescriptors []protoreflect.FieldDescriptor

	// Field indices that are required or contain required fields.
	// Negative numbers are the complement of a message field which
	// might contain required fields.
	Required []int32
}

type Field struct {

	// The Message type for this field, if there is one.
	Message *Type
	Accessor
	// contains filtered or unexported fields
}

type FieldLayout struct {
	Size, Align, Bits, Padding uint32

	Index  int // Which field is this in the MessageDescriptor?
	Offset Offset
}

type FieldParser struct {

	// The expected, partially decoded Tag value for the field.
	Tag Tag

	// Byte offset to the typeParser this fieldParser uses, if any.
	Message *TypeParser

	// Field Offset information for the field this parser parses. Duplicated
	// from [getter].
	Offset Offset

	// For non-singular fields, the default size to preallocate for this field.
	Preload uint32

	// The parser to jump to after this one, depending on whether the parse
	// succeeds or fails.
	NextOk, NextErr xunsafe.Addr[FieldParser]

	// The thunk to call for this field. The type of this thunk is stored in
	// the parser package.
	Parse uintptr
	// contains filtered or unexported fields
}

type Getter func(unsafe.Pointer, *Type, *Accessor) protoreflect.Value

type Int interface {
	~int8 | ~uint8 | ~int32 | ~int64 | ~uint32 | ~uint64
}

type Library struct {
	Base  *Type
	Types map[protoreflect.MessageDescriptor]*Type
	Bytes int

	// Used to store compilation metadata. Actually a []hyperpb.CompileOptions.
	Metadata any
}

type Number interface {
	Int | ~float32 | ~float64
}

type Offset struct {
	// First Bit index for bits allocated to this field.
	//
	// If this is a oneof field, this is instead an offset into the
	// oneof word table.
	Bit uint32

	// Byte offset within the containing message to the Data for this field.
	//
	// If negative, this is a cold field, and this is the negation of an offset
	// into the cold field area.
	Data int32

	// This field's Number. Only used by oneof fields; all other fields have
	// a zero here.
	Number uint32
}

type Scalar interface {
	int32 | int64 |
		uint32 | uint64 |
		float32 | float64 |
		protoreflect.EnumNumber | bool
}

type Tag uint64

type Type struct {
	*Aux

	// The number of bytes of memory that must be allocated for a *message of
	// this type. This includes the Size of the header. Alignment is implicitly
	// that of uint64.
	Size, ColdSize uint32

	// The "unspecialized" Parser for this type.
	Parser *TypeParser

	// Maps field Numbers to offsets in fields.
	Numbers *swiss.Table[int32, uint32]

	// The number of fields that follow this type, not including the special
	// padding field with number equal to zero.
	Count uint32
	// contains filtered or unexported fields
}

type TypeLayout struct {
	BitWords int           // Number of 32-bit words in the type.
	Fields   []FieldLayout // Sorted in offset order.
}

type TypeParser struct {

	// Maps offsets to field tags for the first 128 field tags. A value of
	// -1 means that if there is a parser at that position, it is farther away
	// than the first 256 fields.
	TagLUT [128]uint8

	TypeOffset     uint32 // The type that this parser parses.
	DiscardUnknown bool   // Should unknown fields be kept?

	// Maps field tags to offsets in fields.
	Tags *swiss.Table[int32, uint32]

	// If this is an ordinary parser, this is the parser for parsing this
	// message as a "map entry"; that is, it will have a single field with
	// number 2 that forwards to this parser.
	MapEntry *TypeParser

	Entrypoint FieldParser
	// contains filtered or unexported fields
}