Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

parser

package

Go to main page

Versions in this module

v0

v0.0.3

Jul 7, 2026

v0.0.2

Jul 7, 2026

Changes in this version

+ var TemplateStrDelimiter = MixedDelimiter

+ func RemoveAllSpaces(t PToken) bool

type File

+ func ParseTemplateString(tmpl string, pos source.Pos) (f *File, err error)

+ func (n *File) BuildCode(opt ...node.CodeOption) string

+ type PToken struct

+ InsertSemi bool

+ Prev []PToken

+ func (t *PToken) LiteralRemoveLinePrefix(prefix string)

+ func (t PToken) IsSemi() bool

+ func (t PToken) IsSpace() bool

+ func (t PToken) String() string

type Parser

+ func (p *Parser) AtCommaOrNewLine(context string, follow token.Token) bool

+ func (p *Parser) ErrorExpectToken(got PToken, expected ...token.Token) (tok PToken)

+ func (p *Parser) Failed() bool

+ func (p *Parser) ParseBoolLit() *node.BoolLit

+ func (p *Parser) ParseBytesLit(prefix node.BytesLitPrefix) node.Expr

+ func (p *Parser) ParseClassExpr() node.Expr

+ func (p *Parser) ParseClassStmt() node.Stmt

+ func (p *Parser) ParseCodeStrLit() (t *node.CodeStrLit)

+ func (p *Parser) ParseComputedExpr() *node.ComputedExpr

+ func (p *Parser) ParseCurlyDestructureStmt() node.Stmt

+ func (p *Parser) ParseCurlyPattern() *node.KeyValueArrayLit

+ func (p *Parser) ParseDateTimeLit(suffix rune) node.Expr

+ func (p *Parser) ParseDecimalLit() *node.DecimalLit

+ func (p *Parser) ParseDeferStmt() node.Stmt

+ func (p *Parser) ParseDurationLit() node.Expr

+ func (p *Parser) ParseEnumExpr() node.Expr

+ func (p *Parser) ParseEnumStmt() node.Stmt

+ func (p *Parser) ParseExportStmt() (stmt *node.ExportStmt)

+ func (p *Parser) ParseFlagLit() *node.FlagLit

+ func (p *Parser) ParseFloatLit() *node.FloatLit

+ func (p *Parser) ParseFuncDefLit(colon token.Token) *node.FuncDefLit

+ func (p *Parser) ParseFuncExprT(tok PToken) (e node.Expr)

+ func (p *Parser) ParseFuncHeaderExpr() node.Expr

+ func (p *Parser) ParseFuncReturnTypes() (types []*node.TypedIdentExpr)

+ func (p *Parser) ParseFuncStmt() (stmt node.Stmt)

+ func (p *Parser) ParseHeredocLit() (t *node.HeredocLit)

+ func (p *Parser) ParseIndexExpr(x node.Expr) *node.IndexExpr

+ func (p *Parser) ParseIntLit() *node.IntLit

+ func (p *Parser) ParseInterfaceExpr() node.Expr

+ func (p *Parser) ParseInterfaceStmt() node.Stmt

+ func (p *Parser) ParseLiteral() node.Expr

+ func (p *Parser) ParseMatchExpr() node.Expr

+ func (p *Parser) ParseMethodInterfaceExpr() node.Expr

+ func (p *Parser) ParseMethodInterfaceExprT(tok PToken) (e node.Expr)

+ func (p *Parser) ParseMethodInterfaceStmt() node.Stmt

+ func (p *Parser) ParseParenOrClosure(lparenToken, rparenToken token.Token) node.Expr

+ func (p *Parser) ParsePropExpr() (e node.Expr)

+ func (p *Parser) ParsePropExprT(tok PToken) (e node.Expr)

+ func (p *Parser) ParsePropStmt() (stmt node.Stmt)

+ func (p *Parser) ParseRawStrLit() (t *node.RawStrLit)

+ func (p *Parser) ParseSimpleSelector(x node.Expr) (sel *node.SelectorExpr)

+ func (p *Parser) ParseSimpleSelectorExpr(x node.Expr) node.Expr

+ func (p *Parser) ParseSimpleSelectorNode(x node.Expr) (expr, sel node.Expr)

+ func (p *Parser) ParseSingleParemExpr(lparen, rparen token.Token) node.Expr

+ func (p *Parser) ParseStrLit() *node.StrLit

+ func (p *Parser) ParseSymbolLit() *node.SymbolLit

+ func (p *Parser) ParseTestStmt() node.Stmt

+ func (p *Parser) ParseTypes() (types []*node.TypeExpr)

+ func (p *Parser) ParseUintLit() *node.UintLit

+ func (p *Parser) ParseWithExpr() node.Expr

+ func (p *Parser) ParseWithStmt() node.Stmt

+ func (p *Parser) Peek() PToken

+ func (p *Parser) PeekC(count int) (t []PToken)

+ func (p *Parser) PeekCb(on func(t PToken) (more bool))

+ func (p *Parser) PeekNoSpace() (r PToken)

v0.0.1

Dec 15, 2025

Changes in this version

+ const MainName

+ var DefaultMixedDelimiter = MixedDelimiter

+ func RemoveSpaces(t Token) bool

+ func StripCR(b []byte, comment bool) []byte

+ func TrimSpace(left, right bool, s string) string

+ func Unquote(s string) (string, error)

+ type BlockEnd struct

+ Next bool

+ Token token.Token

+ type BlockWrap struct

+ Ends []BlockEnd

+ Start token.Token

+ type Error struct

+ Msg string

+ Pos source.FilePos

+ func (e *Error) Error() string

+ func (e *Error) Format(f fmt.State, verb rune)

+ type ErrorList []*Error

+ func (p *ErrorList) Add(pos source.FilePos, msg string)

+ func (p ErrorList) Err() error

+ func (p ErrorList) Error() string

+ func (p ErrorList) Format(f fmt.State, verb rune)

+ func (p ErrorList) Len() int

+ func (p ErrorList) Less(i, j int) bool

+ func (p ErrorList) Sort()

+ func (p ErrorList) Swap(i, j int)

+ type File struct

+ Comments []*ast.CommentGroup

+ InputFile *source.File

+ Stmts node.Stmts

+ func Parse(input, fileName string, opts *ParserOptions, scannerOpts *ScannerOptions) (*File, error)

+ func ParseFile(pth string, opts *ParserOptions, scannerOpts *ScannerOptions) (file *File, err error)

+ func (n *File) End() source.Pos

+ func (n *File) Pos() source.Pos

+ func (n *File) String() string

+ func (n *File) WriteCode(ctx *node.CodeWriteContext)

+ type Handlers struct

+ ScanHandler func(ch rune) (t Token, insertSemi, ok bool)

+ TokenHandlers TokenHandlers

+ func (s *Handlers) CallTokenHandlers(t *Token)

+ func (s *Handlers) TokenHandler(f func(t *Token))

+ type MixedDelimiter = source.StartEndDelimiter

+ type Mode int

+ const ParseCharAsString

+ const ParseComments

+ const ParseConfigDisabled

+ const ParseFloatAsDecimal

+ const ParseMixed

+ const ParseMixedExprAsValue

+ func (b *Mode) Clear(flag Mode) *Mode

+ func (b *Mode) Set(flag Mode) *Mode

+ func (b *Mode) Toggle(flag Mode) *Mode

+ func (b Mode) Has(flag Mode) bool

+ type ParseListHandler func(start token.Token, ends ...BlockWrap) (list []node.Stmt, end *BlockEnd)

+ type Parser struct

+ BlockEnd token.Token

+ BlockStart token.Token

+ Errors ErrorList

+ ExprLevel int

+ File *source.File

+ InCode bool

+ ParseStmtHandler func() node.Stmt

+ PrevToken Token

+ ScanFunc func() Token

+ Scanner ScannerInterface

+ Token Token

+ Trace bool

+ TraceOut io.Writer

+ func NewParser(file *source.File, trace io.Writer) *Parser

+ func NewParserWithOptions(file *source.File, opts *ParserOptions, scannerOptions *ScannerOptions) *Parser

+ func NewParserWithScanner(scanner ScannerInterface, opts *ParserOptions) *Parser

+ func NewSingleParser(input, fileName string, opts *ParserOptions, scannerOpts *ScannerOptions) *Parser

+ func (p *Parser) AtComma(context string, follow token.Token) bool

+ func (p *Parser) CallArgsOf(lparen, rparen source.Pos, exprs ...node.Expr) (params *node.CallArgs)

+ func (p *Parser) DefaultParseStmt() (stmt node.Stmt)

+ func (p *Parser) Error(pos source.Pos, msg string)

+ func (p *Parser) ErrorExpected(pos source.Pos, msg string)

+ func (p *Parser) ErrorExpectedExpr(expected, got node.Expr)

+ func (p *Parser) Expect(token token.Token) source.Pos

+ func (p *Parser) ExpectLit(token token.Token) ast.Literal

+ func (p *Parser) ExpectLits(toks ...token.Token) ast.Literal

+ func (p *Parser) ExpectSemi()

+ func (p *Parser) ExpectToken(token token.Token) (tok Token)

+ func (p *Parser) IsToken(toks ...token.Token) bool

+ func (p *Parser) MakeExpr(s node.Stmt, want string) node.Expr

+ func (p *Parser) Next() *Parser

+ func (p *Parser) ParseAllParemExpr(lparenToken, rparenToken token.Token) node.Expr

+ func (p *Parser) ParseArrayLitOrKeyValue() node.Expr

+ func (p *Parser) ParseBinaryExpr(prec1 int) node.Expr

+ func (p *Parser) ParseBlockStmt(ends ...token.Token) *node.BlockStmt

+ func (p *Parser) ParseBody() (b *node.BlockStmt, lambdaPos source.Pos, closure node.Expr)

+ func (p *Parser) ParseBranchStmt(tok token.Token) node.Stmt

+ func (p *Parser) ParseCall(x node.Expr) *node.CallExpr

+ func (p *Parser) ParseCallArgs(start, end token.Token) *node.CallArgs

+ func (p *Parser) ParseCatchStmt() *node.CatchStmt

+ func (p *Parser) ParseCharLit() node.Expr

+ func (p *Parser) ParseClosureExpr(lambdaToken token.Token, paren *node.MultiParenExpr) *node.ClosureExpr

+ func (p *Parser) ParseCondExpr(cond node.Expr) node.Expr

+ func (p *Parser) ParseConfigStmt() (c *node.ConfigStmt)

+ func (p *Parser) ParseDecl() node.Decl

+ func (p *Parser) ParseDictElementLit() *node.DictElementLit

+ func (p *Parser) ParseDictElementLitFunc() *node.DictElementFuncExpr

+ func (p *Parser) ParseDictLit() *node.DictExpr

+ func (p *Parser) ParseElse(ifs bool) node.Stmt

+ func (p *Parser) ParseEmbedExpr() node.Expr

+ func (p *Parser) ParseExpr() node.Expr

+ func (p *Parser) ParseExprList() (list []node.Expr)

+ func (p *Parser) ParseFile() (file *File, err error)

+ func (p *Parser) ParseFileH(listHandler ParseListHandler) (file *File, err error)

+ func (p *Parser) ParseFinallyStmt() *node.FinallyStmt

+ func (p *Parser) ParseForStmt() node.Stmt

+ func (p *Parser) ParseFuncExpr() node.Expr

+ func (p *Parser) ParseFuncType() *node.FuncType

+ func (p *Parser) ParseGenDecl(keyword token.Token, fn func(token.Token, bool, []node.Spec, int) node.Spec) *node.GenDecl

+ func (p *Parser) ParseIdent() *node.IdentExpr

+ func (p *Parser) ParseIfHeader() (init node.Stmt, cond node.Expr)

+ func (p *Parser) ParseIfStmt() node.Stmt

+ func (p *Parser) ParseImportExpr() node.Expr

+ func (p *Parser) ParseIndexOrSlice(x node.Expr) node.Expr

+ func (p *Parser) ParseKeyValueArrayLit(lbrace source.Pos) *node.KeyValueArrayLit

+ func (p *Parser) ParseKeyValueArrayLitAt(lbrace source.Pos, rbraceToken token.Token) *node.KeyValueArrayLit

+ func (p *Parser) ParseKeyValueLit() *node.KeyValueLit

+ func (p *Parser) ParseKeyValuePairLit(endToken token.Token) *node.KeyValuePairLit

+ func (p *Parser) ParseMixedTextStmt() (t *node.MixedTextStmt)

+ func (p *Parser) ParseMixedValue() (ett *node.MixedValueStmt)

+ func (p *Parser) ParseNullishSelector(x node.Expr) (sel node.Expr)

+ func (p *Parser) ParseOperand() node.Expr

+ func (p *Parser) ParseParamDecl() (d *node.GenDecl)

+ func (p *Parser) ParseParamSpec(keyword token.Token, multi bool, prev []node.Spec, i int) (spec node.Spec)

+ func (p *Parser) ParseParemExpr(lparenToken, rparenToken token.Token) node.ToMultiParenConverter

+ func (p *Parser) ParsePipe(x node.Expr) node.Expr

+ func (p *Parser) ParsePrimaryExpr() node.Expr

+ func (p *Parser) ParsePrimitiveOperand() node.Expr

+ func (p *Parser) ParseRawHeredocLit() (t *node.RawHeredocLit)

+ func (p *Parser) ParseRawStringLit() (t *node.RawStringLit)

+ func (p *Parser) ParseReturn() (ret node.Return)

+ func (p *Parser) ParseReturnExpr() node.Expr

+ func (p *Parser) ParseReturnStmt() node.Stmt

+ func (p *Parser) ParseScopedBlockStmt() *node.BlockStmt

+ func (p *Parser) ParseSelector(x node.Expr) (sel node.Expr)

+ func (p *Parser) ParseSelectorNode(x node.Expr) (expr, sel node.Expr)

+ func (p *Parser) ParseSimpleStmt(forIn bool) node.Stmt

+ func (p *Parser) ParseStmt() (stmt node.Stmt)

+ func (p *Parser) ParseStmtList(end ...token.Token) (list []node.Stmt)

+ func (p *Parser) ParseStringLit() *node.StringLit

+ func (p *Parser) ParseThrowExpr() *node.ThrowExpr

+ func (p *Parser) ParseThrowStmt() node.Stmt

+ func (p *Parser) ParseTryStmt() node.Stmt

+ func (p *Parser) ParseType() (idents []*node.IdentExpr)

+ func (p *Parser) ParseTypedIdent() *node.TypedIdentExpr

+ func (p *Parser) ParseUnaryExpr() node.Expr

+ func (p *Parser) ParseValueSpec(keyword token.Token, multi bool, _ []node.Spec, i int) node.Spec

+ func (p *Parser) PrintTrace(a ...any)

+ func (p *Parser) SkipSpace()

+ func (p *Parser) WrapPostScan(f func(in func(p *Parser)) func(p *Parser))

+ type ParserOptions struct

+ Mode Mode

+ Trace io.Writer

+ type ScanMode uint8

+ const DontInsertSemis

+ const ScanCharAsString

+ const ScanComments

+ const ScanConfigDisabled

+ const ScanFloatAsDecimal

+ const ScanMixed

+ const ScanMixedExprAsValue

+ func (b *ScanMode) Clear(flag ScanMode) *ScanMode

+ func (b *ScanMode) Set(flag ScanMode) *ScanMode

+ func (b *ScanMode) Toggle(flag ScanMode) *ScanMode

+ func (b ScanMode) Has(flag ScanMode) bool

+ type Scanner struct

+ BraceCount int

+ BreacksCount int

+ EOF *Token

+ HandleMixed func(textStart *int, rt func() *Token)

+ InCode bool

+ InsertSemi bool

+ MixedDelimiter MixedDelimiter

+ ParenCount int

+ SkipWhitespaceFunc func(s *Scanner)

+ ToText bool

+ TokenPool TokenPool

+ func NewScanner(file *source.File, opts *ScannerOptions) *Scanner

+ func (s *Scanner) AddNextToken(n ...Token) (r *Token)

+ func (s *Scanner) AddNextTokenPtr(n ...*Token) (r *Token)

+ func (s *Scanner) Clone() (c *Scanner)

+ func (s *Scanner) GetMixedDelimiter() *MixedDelimiter

+ func (s *Scanner) List() (ret []Token)

+ func (s *Scanner) MixedCodeEnds(offsetInc int) bool

+ func (s *Scanner) Mode() ScanMode

+ func (s *Scanner) ModeP() *ScanMode

+ func (s *Scanner) Scan() (t Token)

+ func (s *Scanner) ScanCodeBlock(leftText *Token) (code Token)

+ func (s *Scanner) ScanComment() string

+ func (s *Scanner) ScanIdentifier() string

+ func (s *Scanner) ScanNow() (t Token)

+ func (s *Scanner) ScanNumber(seenDecimalPoint bool) (tok token.Token, lit string)

+ func (s *Scanner) SetMode(m ScanMode)

+ func (s *Scanner) Switch2(tok0, tok1 token.Token) token.Token

+ func (s *Scanner) Switch3(tok0, tok1 token.Token, ch2 rune, tok2 token.Token) token.Token

+ func (s *Scanner) Switch4(tok0, tok1 token.Token, ch2 rune, tok2, tok3 token.Token) token.Token

+ func (s Scanner) PeekScan() (t Token)

+ type ScannerInterface interface

+ ErrorHandler func(h ...source.ScannerErrorHandler)

+ GetMixedDelimiter func() *MixedDelimiter

+ Mode func() ScanMode

+ Scan func() (t Token)

+ SetMode func(m ScanMode)

+ Source func() []byte

+ SourceFile func() *source.File

+ type ScannerOptions struct

+ MixedDelimiter MixedDelimiter

+ Mode ScanMode

+ type TextFlag uint8

+ const TrimLeft

+ const TrimRight

+ func (b *TextFlag) Clear(flag TextFlag) *TextFlag

+ func (b *TextFlag) Set(flag TextFlag) *TextFlag

+ func (b *TextFlag) Toggle(flag TextFlag) *TextFlag

+ func (b TextFlag) Has(flag TextFlag) bool

+ func (b TextFlag) String() (s string)

+ type Token struct

+ InsertSemi bool

+ Literal string

+ Pos source.Pos

+ Prev []Token

+ Token token.Token

+ func (t *Token) LiteralRemoveLinePrefix(prefix string)

+ func (t Token) String() string

+ type TokenHandler func(t *Token)

+ type TokenHandlers []TokenHandler

+ func (th *TokenHandlers) Remove(h TokenHandler)

+ type TokenPool []*Token

+ func (p *TokenPool) Add(t ...*Token)

+ func (p *TokenPool) Semi()

+ func (p *TokenPool) Shift() (t *Token)

+ func (p TokenPool) Empty() bool

+ func (p TokenPool) Last() (t *Token)