ResolverFunc is a simple function type that implements Resolver.

This file contains a streaming lexer. The lexer in the parser package loads the entire file into memory. But this lexer is much more memory efficient

Token represents a single lexed token.

Item represents an item lexed from source. It represents either a Token or a Comment.

Node is the interface implemented by all nodes in the AST. It provides information about the span of this AST node in terms of location in the source

SourceInfoMode indicates how source code info is generated by a Compiler.

Identifier is a possibly-qualified name. This is used to distinguish ValueNode values that are references/identifiers vs. those that are string litera

Resolver is used by the compiler to resolve a proto source file name into some unit that is usable by the compiler. The result could be source for a p

CompositeResolver is a slice of resolvers, which are consulted in order until one can supply a result. If none of the constituent resolvers can supply

EnumValueDeclNode is a placeholder interface for AST nodes that represent enum values. This allows NoSourceNode to be used in place of *EnumValueNode

FieldDeclNode is a node in the AST that defines a field. This includes normal message fields as well as extensions. There are multiple types of AST no

FileDeclNode is a placeholder interface for AST nodes that represent files. This allows NoSourceNode to be used in place of *FileNode for some usages.

MessageDeclNode is a node in the AST that defines a message type. This includes normal message fields as well as implicit messages: - *MessageNode - *

OneofDeclNode is a node in the AST that defines a oneof. There are multiple types of AST nodes that declare oneofs: - *OneofNode - *SyntheticOneof Th

RPCDeclNode is a placeholder interface for AST nodes that represent RPC declarations. This allows NoSourceNode to be used in place of *RPCNode for som

SyntaxError is returned from Scan when one or more syntax errors are observed. Scan does not fully parse the source, so there are many kinds of syntax

terminalNode contains bookkeeping shared by all TerminalNode implementations. It is embedded in all such node types in this package. It provides the i

AncestorTracker is used to track the path of nodes during a walk operation. By passing AsWalkOptions to a call to Walk, a visitor can inspect the path

ArrayLiteralNode represents an array literal, which is only allowed inside of a MessageLiteralNode, to indicate values for a repeated field. Example:

ArrayLiteralSourceInfo represents source info paths for the child elements of an [*ast.ArrayLiteralNode]. This value is only useful for non-empty arra

Comment represents a single comment in a source file. It indicates the position of the comment and its contents. A single comment means one line-style

Comments represents a range of sequential comments in a source file (e.g. no interleaving items or AST nodes).

CompactOptionsNode represents a compact options declaration, as used with fields, enum values, and extension ranges. Example: [deprecated = true, js

Compiler handles compilation tasks, to turn protobuf source files, or other intermediate representations, into fully linked descriptors. The compilat

CompositeNode represents any non-terminal node in the tree. These are interior or root nodes and have child nodes.

CompoundIdentNode represents a qualified identifier. A qualified identifier has at least one dot and possibly multiple identifier names (all separated

CompoundStringLiteralNode represents a compound string literal, which is the concatenaton of adjacent string literals. Example: "this " "is" " al

DescriptorProtoWrapper is a protoreflect.Descriptor that wraps an underlying descriptor proto. It provides the same interface as Descriptor but with o

EditionNode represents an edition declaration, which if present must be the first non-comment content. Example: edition = "2023"; Files may include

EmptyDeclNode represents an empty declaration in protobuf source. These amount to extra semicolons, with no actual content preceding the semicolon.

EnumElement is an interface implemented by all AST nodes that can appear in the body of an enum declaration.

EnumNode represents an enum declaration. Example: enum Foo { BAR = 0; BAZ = 1 }

EnumValueNode represents an enum declaration. Example: UNSET = 0 [deprecated = true];

ErrorReporter is responsible for reporting the given error. If the reporter returns a non-nil error, parsing/linking will abort with that error. If th

ErrorUnusedImport may be passed to a warning reporter when an unused import is detected. The error the reporter receives will be wrapped with source p

ErrorWithPos is an error about a proto source file that adds information about the location in the file that caused the error.

ExtendElement is an interface implemented by all AST nodes that can appear in the body of an extends declaration.

ExtendNode represents a declaration of extension fields. Example: extend google.protobuf.FieldOptions { bool redacted = 33333; }

ExtensionRangeNode represents an extension range declaration in an extendable message. Example: extensions 100 to max;

FieldLabel represents the label of a field, which indicates its cardinality (i.e. whether it is optional, required, or repeated).

FieldNode represents a normal field declaration (not groups or maps). It can represent extension fields as well as non-extension fields (both inside o

FieldReferenceNode is a reference to a field name. It can indicate a regular field (simple unqualified name), an extension field (possibly-qualified n

File is like a super-powered protoreflect.FileDescriptor. It includes helpful methods for looking up elements in the descriptor and can be used to cre

FileElement is an interface implemented by all AST nodes that are allowed as top-level declarations in the file.

FileInfo contains information about the contents of a source file, including details about comments and items. A lexer accumulates these details as it

FileNode is the root of the AST hierarchy. It represents an entire protobuf source file.

Files represents a set of protobuf files. It is a slice of File values, but also provides a method for easily looking up files by path and name.

FloatLiteralNode represents a floating point numeric literal.

FloatValueNode is an AST node that represents a numeric literal with a floating point, in scientific notation, or too large to fit in an int64 or uint

GenerateOption represents an option for how source code info is generated.

GroupNode represents a group declaration, which doubles as a field and inline message declaration. It can represent extension fields as well as non-ex

Handler is used by protocompile operations for handling errors and warnings. This type is thread-safe. It uses a mutex to serialize calls to its repor

HasEdition should be implemented by values that implement [protoreflect.FileDescriptor], to provide access to the file's edition when its syntax is [p

HasFeatures is implemented by all options messages and provides a nil-receiver-safe way of accessing the features explicitly configured in those optio

IdentNode represents a simple, unqualified identifier. These are used to name elements declared in a protobuf file or to refer to elements. Example:

IdentValueNode is an AST node that represents an identifier.

Import represents an import in a Protobuf source file.

ImportNode represents an import statement. Example: import "google/protobuf/empty.proto";

IntValueNode is an AST node that represents an integer literal. If an integer literal is too large for an int64 (or uint64 for positive literals), it

InterpreterOption is an option that can be passed to InterpretOptions and its variants.

ItemInfo provides details about an item's location in the source file and its contents.

KeywordNode is an AST node that represents a keyword. Keywords are like identifiers, but they have special meaning in particular contexts. Example:

MapFieldNode represents a map field declaration. Example: map<string,string> replacements = 3 [deprecated = true];

MapTypeNode represents the type declaration for a map field. It defines both the key and value types for the map. Example: map<string, Values>

MessageBody represents the body of a message. It is used by both MessageNodes and GroupNodes.

MessageContext provides information about the location in a descriptor hierarchy, for adding context to warnings and error messages.

MessageElement is an interface implemented by all AST nodes that can appear in a message body.

MessageFieldNode represents a single field (name and value) inside of a message literal. Example: foo:"bar"

MessageLiteralNode represents a message literal, which is compatible with the protobuf text format and can be used for custom options with message typ

MessageLiteralSourceInfo represents source info paths for the child elements of an [*ast.MessageLiteralNode].

MessageNode represents a message declaration. Example: message Foo { string name = 1; repeated string labels = 2; bytes extra = 3; }

NegativeIntLiteralNode represents an integer literal with a negative (-) sign.

NoOpVisitor is a visitor implementation that does nothing. All methods unconditionally return nil. This can be embedded into a struct to make that str

NoSourceNode is a placeholder AST node that implements numerous interfaces in this package. It can be used to represent an AST element for a file whos

NodeInfo represents the details for a node or token in the source file's AST. It provides access to information about the node's location in the sourc

NodeWithOptions represents a node in the AST that contains option statements.

OneofElement is an interface implemented by all AST nodes that can appear in the body of a oneof declaration.

OneofNode represents a one-of declaration. Example: oneof query { string by_name = 2; Type by_type = 3; Address by_address = 4; Labels b

OptionChildrenSourceInfo represents source info paths for child elements of an option value.

OptionDeclNode is a placeholder interface for AST nodes that represent options. This allows NoSourceNode to be used in place of *OptionNode for some u

OptionIndex is a mapping of AST nodes that define options to corresponding paths into the containing file descriptor. The path is a sequence of field

OptionNameNode represents an option name or even a traversal through message types to name a nested option field. Example: (foo.bar).baz.(bob)

OptionNode represents the declaration of a single option for an element. It is used both for normal option declarations (start with "option" keyword a

OptionSourceInfo describes the source info path for an option value and contains information about the value's descendants in the AST.

PackageNode represents a package declaration. Example: package foobar.com;

PanicError is an error value that represents a recovered panic. It includes the value returned by recover() as well as the stack trace. This should g

ParsedFile wraps an optional AST and required FileDescriptorProto. This is used so types like parser.Result can be passed to this internal package avo

RPCElement is an interface implemented by all AST nodes that can appear in the body of an rpc declaration (aka method).

RPCNode represents an RPC declaration. Example: rpc Foo (Bar) returns (Baz);

RPCTypeNode represents the declaration of a request or response type for an RPC. Example: (stream foo.Bar)

RangeDeclNode is a placeholder interface for AST nodes that represent numeric values. This allows NoSourceNode to be used in place of *RangeNode for s

RangeNode represents a range expression, used in both extension ranges and reserved ranges. Example: 1000 to max

Reporter is a type that handles reporting both errors and warnings. A reporter does not need to be thread-safe. Safe concurrent access is managed by a