protoparse

type AggregateField ¶

type AggregateField struct {
	Pos   Position
	Name  OptionName
	Value Literal
}

AggregateField represents a field: value or field { ... } entry inside an aggregate (message) literal value.

type Comment ¶

type Comment struct {
	Pos      Position
	Text     string
	Trailing bool
}

Comment holds a single comment from the source text. Text includes the delimiters (// or /* */). Trailing is true when the comment appears on the same line after a declaration.

type Decl ¶

type Decl interface {
	// contains filtered or unexported methods
}

Decl is a sealed interface representing a top-level declaration in a .proto file. It is implemented by *MessageDecl, *EnumDecl, *ServiceDecl, and *ExtendDecl.

type EditionDecl ¶

type EditionDecl struct {
	Pos      Position
	Value    string
	Comments []Comment
}

EditionDecl represents an edition declaration (e.g., edition = "2023";). Value holds the string literal value without quotes.

type EnumDecl ¶

type EnumDecl struct {
	Pos      Position
	Name     string
	Values   []*EnumValueDecl
	Options  []*OptionDecl
	Reserved []*ReservedDecl
	Comments []Comment
}

EnumDecl represents an enum declaration. It implements both Decl and MessageElement because enums can appear at the top level and nested inside messages.

type EnumValueDecl ¶

type EnumValueDecl struct {
	Pos      Position
	Name     string
	Number   int32
	Options  []*FieldOption
	Comments []Comment
}

EnumValueDecl represents a single value within an enum declaration.

fieldalignment: fields ordered to match .proto source declaration order

type ErrorList ¶

type ErrorList []error

ErrorList collects multiple parse errors encountered during a single parse operation. It implements the error interface; its Error method joins all contained messages with newlines. The Unwrap method returns the underlying slice for use with errors.As and errors.Is.

func (e ErrorList) Error() string

func (e ErrorList) Unwrap() []error

type ExtendDecl ¶

type ExtendDecl struct {
	Pos      Position
	TypeName TypeName
	Fields   []*FieldDecl
	Groups   []*GroupDecl
	Comments []Comment
}

ExtendDecl represents an extend block. It implements both Decl and MessageElement because extend blocks can appear at the top level and inside messages.

type ExtensionsDecl ¶

type ExtensionsDecl struct {
	Pos      Position
	Ranges   []Range
	Options  []*FieldOption
	Comments []Comment
}

ExtensionsDecl represents an extensions range declaration within a message. It implements MessageElement.

type FieldDecl ¶

type FieldDecl struct {
	Pos      Position
	Label    string
	TypeName TypeName
	Name     string
	Number   int32
	Options  []*FieldOption
	Comments []Comment
}

FieldDecl represents a field declaration within a message or oneof. Label is one of "optional", "required", "repeated", or "" for label-less proto3 fields.

fieldalignment: fields ordered to match .proto source declaration order

type FieldOption ¶

type FieldOption struct {
	Pos   Position
	Name  OptionName
	Value Literal
}

FieldOption represents a single option within the inline option list of a field declaration (the [...] after the field number).

type File ¶

type File struct {
	Pos      Position
	Syntax   *SyntaxDecl
	Edition  *EditionDecl
	Package  *PackageDecl
	Imports  []*ImportDecl
	Options  []*OptionDecl
	Decls    []Decl
	Comments []Comment
}

File is the root AST node representing a parsed .proto file. Exactly one of Syntax or Edition may be non-nil; both nil means the file had no syntax/edition declaration.

func Parse(filename string, input []byte) (*File, error)

func ParseTokens(filename string, lexer *protolex.Lexer) (*File, error)

type GroupDecl ¶

type GroupDecl struct {
	Pos      Position
	Label    string
	Name     string
	Number   int32
	Body     []MessageElement
	Comments []Comment
}

GroupDecl represents a proto2 legacy group declaration.

fieldalignment: fields ordered to match .proto source declaration order

type ImportDecl ¶

type ImportDecl struct {
	Pos      Position
	Path     string
	Modifier ImportModifier
	Comments []Comment
}

ImportDecl represents an import declaration. Path holds the import path without quotes. Modifier indicates whether the import is weak or public.

fieldalignment: fields ordered for semantic clarity, not padding

type ImportModifier ¶

type ImportModifier int8

ImportModifier represents the modifier on an import declaration. The zero value ImportNone means no modifier. ImportWeak and ImportPublic correspond to the weak and public keywords respectively.

const (
	// ImportNone indicates a plain import with no modifier.
	ImportNone ImportModifier = 0

	// ImportWeak indicates a weak import.
	ImportWeak ImportModifier = iota // 1

	// ImportPublic indicates a public import.
	ImportPublic // 2
)

func (m ImportModifier) String() string

func (m ImportModifier) Valid() bool

type Literal ¶

type Literal struct {
	Pos       Position
	Kind      LiteralKind
	Value     string
	Aggregate []*AggregateField
	Sign      string
}

Literal holds a parsed literal value. Kind indicates the type of the literal. Value holds the raw text for scalar literals. Aggregate holds the fields for aggregate literals. Sign holds "-" or "+" if a sign preceded the literal.

type LiteralKind ¶

type LiteralKind int8

LiteralKind represents the type of a literal value in the AST. The zero value is intentionally invalid.

const (
	// LitString represents a string literal value.
	LitString LiteralKind = iota + 1 // 1

	// LitInt represents an integer literal value.
	LitInt // 2

	// LitFloat represents a floating-point literal value.
	LitFloat // 3

	// LitBool represents a boolean literal value (true or false).
	LitBool // 4

	// LitIdentifier represents an identifier literal (e.g., inf, nan, or enum
	// value names).
	LitIdentifier // 5

	// LitAggregate represents an aggregate (message) literal value enclosed
	// in braces.
	LitAggregate // 6
)

func (k LiteralKind) String() string

func (k LiteralKind) Valid() bool

type MapFieldDecl ¶

type MapFieldDecl struct {
	Pos       Position
	KeyType   string
	ValueType TypeName
	Name      string
	Number    int32
	Options   []*FieldOption
	Comments  []Comment
}

MapFieldDecl represents a map field declaration (e.g., map<string, int32> name = 1;). KeyType holds the map key type keyword.

fieldalignment: fields ordered to match .proto source declaration order

type MessageDecl ¶

type MessageDecl struct {
	Pos      Position
	Name     string
	Body     []MessageElement
	Comments []Comment
}

MessageDecl represents a message declaration. Body holds all nested elements in source order. It implements both Decl and MessageElement because messages can appear at the top level and nested inside other messages.

type MessageElement ¶

type MessageElement interface {
	// contains filtered or unexported methods
}

MessageElement is a sealed interface representing an element that can appear inside a message body. It is implemented by *FieldDecl, *MapFieldDecl, *OneofDecl, *EnumDecl, *MessageDecl, *ExtendDecl, *ExtensionsDecl, *ReservedDecl, *OptionDecl, and *GroupDecl.

type MethodDecl ¶

type MethodDecl struct {
	Pos             Position
	Name            string
	InputType       TypeName
	OutputType      TypeName
	ClientStreaming bool
	ServerStreaming bool
	Options         []*OptionDecl
	Comments        []Comment
}

MethodDecl represents an RPC method declaration within a service. ClientStreaming and ServerStreaming indicate whether the stream keyword appeared before the input or output type respectively.

fieldalignment: fields ordered to match .proto source declaration order

type OneofDecl ¶

type OneofDecl struct {
	Pos      Position
	Name     string
	Fields   []*FieldDecl
	Options  []*OptionDecl
	Comments []Comment
}

OneofDecl represents a oneof declaration. Fields inside a oneof do not carry a label.

type OptionDecl ¶

type OptionDecl struct {
	Pos      Position
	Name     OptionName
	Value    Literal
	Comments []Comment
}

OptionDecl represents an option declaration. It implements both Decl and MessageElement because options can appear at the top level and inside message bodies.

type OptionName ¶

type OptionName struct {
	Parts []OptionNamePart
}

OptionName represents the full path of an option name, such as (com.example.my_option).field.subfield, as a sequence of parts.

type OptionNamePart ¶

type OptionNamePart struct {
	Name        string
	IsExtension bool
}

OptionNamePart represents a single component of an option name path. When IsExtension is true, the part was parenthesized in the source (e.g., (com.example.my_option)).

type PackageDecl ¶

type PackageDecl struct {
	Pos      Position
	Name     string
	Comments []Comment
}

PackageDecl represents a package declaration. Name holds the full dotted package name (e.g., "foo.bar.baz").

type ParseError ¶

type ParseError struct {
	// Pos is the source location where the error occurred.
	Pos Position
	// Detail is a human-readable description of the failure.
	Detail string
	// Cause is the underlying error, if any.
	Cause error
}

ParseError is a typed error returned when proto file parsing encounters a syntax or semantic error at a known source location. It includes file, line, and column context and wraps an optional underlying cause.

func (e *ParseError) Error() string

func (e *ParseError) Unwrap() error

type Position ¶

type Position struct {
	Filename string
	Line     int
	Column   int
}

Position records the source location of a token or AST node within a .proto file. Line and Column are 1-based.

type Range ¶

type Range struct {
	Start int32
	End   int32
	Max   bool
}

Range represents a numeric range used in extensions and reserved declarations. For single-value ranges Start equals End and Max is false. Max is true when the range endpoint was the keyword max.

type ReservedDecl ¶

type ReservedDecl struct {
	Pos      Position
	Ranges   []Range
	Names    []string
	Comments []Comment
}

ReservedDecl represents a reserved declaration within a message or enum. A single reserved statement contains either ranges or names, never both. It implements MessageElement.

type ServiceDecl ¶

type ServiceDecl struct {
	Pos      Position
	Name     string
	Methods  []*MethodDecl
	Options  []*OptionDecl
	Comments []Comment
}

ServiceDecl represents a service declaration. It implements Decl because services are top-level declarations.

type SyntaxDecl ¶

type SyntaxDecl struct {
	Pos      Position
	Value    string
	Comments []Comment
}

SyntaxDecl represents a syntax declaration (e.g., syntax = "proto3";). Value holds the string literal value without quotes.

type TypeName ¶

type TypeName struct {
	Parts    []string
	Absolute bool
}

TypeName represents a protobuf type reference. Parts holds the dot-separated components (e.g., ["foo", "bar", "Baz"]). Absolute is true when the name had a leading dot in the source.