parser

package

Go to main page

Versions in this module

v0

v0.5.0

Nov 10, 2023

Changes in this version

+ const NitroLexerEXEC_HOME

+ const NitroLexerEXEC_WS

+ const NitroParserEXEC_HOME

+ const NitroParserEXEC_WS

type Array_elemContext

+ func (s *Array_elemContext) EXPAND() antlr.TerminalNode

type Exec_expr_argContext

+ func (s *Exec_expr_argContext) EXEC_HOME() antlr.TerminalNode

+ func (s *Exec_expr_argContext) EXEC_WS() antlr.TerminalNode

+ func (s *Exec_expr_argContext) EXPAND() antlr.TerminalNode

v0.4.0

Nov 4, 2022

v0.3.0

Aug 22, 2022

Changes in this version

+ const NitroLexerDQUOTE_

+ const NitroLexerEXEC

+ const NitroLexerEXEC_DQUOTE

+ const NitroLexerEXEC_DQUOTE_LITERAL

+ const NitroLexerEXEC_EXPR

+ const NitroLexerEXEC_EXPR_WS_

+ const NitroLexerEXEC_LITERAL

+ const NitroLexerEXEC_PREFIX

+ const NitroLexerEXEC_SQUOTE

+ const NitroLexerEXEC_SQUOTE_

+ const NitroLexerEXEC_SQUOTE_LITERAL

+ const NitroLexerEXEC_SUFFIX

+ const NitroLexerEXEC_WS_

+ const NitroParserDQUOTE_

+ const NitroParserEXEC_DQUOTE_LITERAL

+ const NitroParserEXEC_EXPR_WS_

+ const NitroParserEXEC_LITERAL

+ const NitroParserEXEC_PREFIX

+ const NitroParserEXEC_SQUOTE_

+ const NitroParserEXEC_SQUOTE_LITERAL

+ const NitroParserEXEC_SUFFIX

+ const NitroParserEXEC_WS_

+ const NitroParserRULE_exec_expr

+ const NitroParserRULE_exec_expr_arg

+ const NitroParserRULE_prologue

+ func NitroLexerInit()

+ func NitroParserInit()

type BaseNitroParserListener

+ func (s *BaseNitroParserListener) EnterExec_expr(ctx *Exec_exprContext)

+ func (s *BaseNitroParserListener) EnterExec_expr_arg(ctx *Exec_expr_argContext)

+ func (s *BaseNitroParserListener) EnterPrimary_exec_expr(ctx *Primary_exec_exprContext)

+ func (s *BaseNitroParserListener) EnterPrologue(ctx *PrologueContext)

+ func (s *BaseNitroParserListener) ExitExec_expr(ctx *Exec_exprContext)

+ func (s *BaseNitroParserListener) ExitExec_expr_arg(ctx *Exec_expr_argContext)

+ func (s *BaseNitroParserListener) ExitPrimary_exec_expr(ctx *Primary_exec_exprContext)

+ func (s *BaseNitroParserListener) ExitPrologue(ctx *PrologueContext)

type Binary_exprContext

+ func (s *Binary_exprContext) PIPE() antlr.TerminalNode

+ type Exec_exprContext struct

+ func NewEmptyExec_exprContext() *Exec_exprContext

+ func NewExec_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exec_exprContext

+ func (*Exec_exprContext) IsExec_exprContext()

+ func (s *Exec_exprContext) AllExec_expr_arg() []IExec_expr_argContext

+ func (s *Exec_exprContext) EXEC_PREFIX() antlr.TerminalNode

+ func (s *Exec_exprContext) EXEC_SUFFIX() antlr.TerminalNode

+ func (s *Exec_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Exec_exprContext) Exec_expr_arg(i int) IExec_expr_argContext

+ func (s *Exec_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Exec_exprContext) GetParser() antlr.Parser

+ func (s *Exec_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Exec_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Exec_expr_argContext struct

+ func NewEmptyExec_expr_argContext() *Exec_expr_argContext

+ func NewExec_expr_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exec_expr_argContext

+ func (*Exec_expr_argContext) IsExec_expr_argContext()

+ func (s *Exec_expr_argContext) CCURLY() antlr.TerminalNode

+ func (s *Exec_expr_argContext) EXEC_DQUOTE_LITERAL() antlr.TerminalNode

+ func (s *Exec_expr_argContext) EXEC_LITERAL() antlr.TerminalNode

+ func (s *Exec_expr_argContext) EXEC_SQUOTE_LITERAL() antlr.TerminalNode

+ func (s *Exec_expr_argContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Exec_expr_argContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Exec_expr_argContext) Expr() IExprContext

+ func (s *Exec_expr_argContext) GetParser() antlr.Parser

+ func (s *Exec_expr_argContext) GetRuleContext() antlr.RuleContext

+ func (s *Exec_expr_argContext) OCURLY() antlr.TerminalNode

+ func (s *Exec_expr_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExprContext

+ func (s *ExprContext) Expr3() IExpr3Context

+ func (s *ExprContext) Short_lambda_expr() IShort_lambda_exprContext

+ type IExec_exprContext interface

+ GetParser func() antlr.Parser

+ IsExec_exprContext func()

+ type IExec_expr_argContext interface

+ GetParser func() antlr.Parser

+ IsExec_expr_argContext func()

+ type IPrologueContext interface

+ GetParser func() antlr.Parser

+ IsPrologueContext func()

type NitroParser

+ func (p *NitroParser) Exec_expr() (localctx IExec_exprContext)

+ func (p *NitroParser) Exec_expr_arg() (localctx IExec_expr_argContext)

+ func (p *NitroParser) Prologue() (localctx IPrologueContext)

type NitroParserListener

+ EnterExec_expr func(c *Exec_exprContext)

+ EnterExec_expr_arg func(c *Exec_expr_argContext)

+ EnterPrimary_exec_expr func(c *Primary_exec_exprContext)

+ EnterPrologue func(c *PrologueContext)

+ ExitExec_expr func(c *Exec_exprContext)

+ ExitExec_expr_arg func(c *Exec_expr_argContext)

+ ExitPrimary_exec_expr func(c *Primary_exec_exprContext)

+ ExitPrologue func(c *PrologueContext)

+ type Primary_exec_exprContext struct

+ func NewPrimary_exec_exprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_exec_exprContext

+ func (s *Primary_exec_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_exec_exprContext) Exec_expr() IExec_exprContext

+ func (s *Primary_exec_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_exec_exprContext) GetRuleContext() antlr.RuleContext

+ type PrologueContext struct

+ func NewEmptyPrologueContext() *PrologueContext

+ func NewPrologueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrologueContext

+ func (*PrologueContext) IsPrologueContext()

+ func (s *PrologueContext) AllImport_stmt() []IImport_stmtContext

+ func (s *PrologueContext) AllMeta_directive() []IMeta_directiveContext

+ func (s *PrologueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PrologueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PrologueContext) GetParser() antlr.Parser

+ func (s *PrologueContext) GetRuleContext() antlr.RuleContext

+ func (s *PrologueContext) Import_stmt(i int) IImport_stmtContext

+ func (s *PrologueContext) Meta_directive(i int) IMeta_directiveContext

+ func (s *PrologueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type UnitContext

+ func (s *UnitContext) Prologue() IPrologueContext

v0.2.0

May 21, 2022

Changes in this version

+ const NitroLexerASSIGN_ADD

+ const NitroLexerASSIGN_DIV

+ const NitroLexerASSIGN_MOD

+ const NitroLexerASSIGN_MUL

+ const NitroLexerASSIGN_SUB

+ const NitroLexerDEC

+ const NitroLexerINC

+ const NitroParserASSIGN_ADD

+ const NitroParserASSIGN_DIV

+ const NitroParserASSIGN_MOD

+ const NitroParserASSIGN_MUL

+ const NitroParserASSIGN_SUB

+ const NitroParserDEC

+ const NitroParserINC

+ const NitroParserRULE_assignment_op_stmt

+ const NitroParserRULE_inc_dec_stmt

+ const NitroParserRULE_unit

+ type Assignment_op_stmtContext struct

+ func NewAssignment_op_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignment_op_stmtContext

+ func NewEmptyAssignment_op_stmtContext() *Assignment_op_stmtContext

+ func (*Assignment_op_stmtContext) IsAssignment_op_stmtContext()

+ func (s *Assignment_op_stmtContext) ASSIGN_ADD() antlr.TerminalNode

+ func (s *Assignment_op_stmtContext) ASSIGN_DIV() antlr.TerminalNode

+ func (s *Assignment_op_stmtContext) ASSIGN_MOD() antlr.TerminalNode

+ func (s *Assignment_op_stmtContext) ASSIGN_MUL() antlr.TerminalNode

+ func (s *Assignment_op_stmtContext) ASSIGN_SUB() antlr.TerminalNode

+ func (s *Assignment_op_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Assignment_op_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Assignment_op_stmtContext) Expr() IExprContext

+ func (s *Assignment_op_stmtContext) GetOp() antlr.Token

+ func (s *Assignment_op_stmtContext) GetParser() antlr.Parser

+ func (s *Assignment_op_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Assignment_op_stmtContext) Lvalue_expr() ILvalue_exprContext

+ func (s *Assignment_op_stmtContext) SetOp(v antlr.Token)

+ func (s *Assignment_op_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type BaseNitroParserListener

+ func (s *BaseNitroParserListener) EnterAssignment_op_stmt(ctx *Assignment_op_stmtContext)

+ func (s *BaseNitroParserListener) EnterInc_dec_stmt(ctx *Inc_dec_stmtContext)

+ func (s *BaseNitroParserListener) EnterStmt_inc_dec(ctx *Stmt_inc_decContext)

+ func (s *BaseNitroParserListener) EnterStmt_op_assign(ctx *Stmt_op_assignContext)

+ func (s *BaseNitroParserListener) EnterUnit(ctx *UnitContext)

+ func (s *BaseNitroParserListener) ExitAssignment_op_stmt(ctx *Assignment_op_stmtContext)

+ func (s *BaseNitroParserListener) ExitInc_dec_stmt(ctx *Inc_dec_stmtContext)

+ func (s *BaseNitroParserListener) ExitStmt_inc_dec(ctx *Stmt_inc_decContext)

+ func (s *BaseNitroParserListener) ExitStmt_op_assign(ctx *Stmt_op_assignContext)

+ func (s *BaseNitroParserListener) ExitUnit(ctx *UnitContext)

+ type IAssignment_op_stmtContext interface

+ GetOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsAssignment_op_stmtContext func()

+ SetOp func(antlr.Token)

+ type IInc_dec_stmtContext interface

+ GetOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsInc_dec_stmtContext func()

+ SetOp func(antlr.Token)

+ type IUnitContext interface

+ GetParser func() antlr.Parser

+ IsUnitContext func()

+ type Inc_dec_stmtContext struct

+ func NewEmptyInc_dec_stmtContext() *Inc_dec_stmtContext

+ func NewInc_dec_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inc_dec_stmtContext

+ func (*Inc_dec_stmtContext) IsInc_dec_stmtContext()

+ func (s *Inc_dec_stmtContext) DEC() antlr.TerminalNode

+ func (s *Inc_dec_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Inc_dec_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Inc_dec_stmtContext) GetOp() antlr.Token

+ func (s *Inc_dec_stmtContext) GetParser() antlr.Parser

+ func (s *Inc_dec_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Inc_dec_stmtContext) INC() antlr.TerminalNode

+ func (s *Inc_dec_stmtContext) Lvalue_expr() ILvalue_exprContext

+ func (s *Inc_dec_stmtContext) SetOp(v antlr.Token)

+ func (s *Inc_dec_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NitroParser

+ func (p *NitroParser) Assignment_op_stmt() (localctx IAssignment_op_stmtContext)

+ func (p *NitroParser) Inc_dec_stmt() (localctx IInc_dec_stmtContext)

+ func (p *NitroParser) Unit() (localctx IUnitContext)

type NitroParserListener

+ EnterAssignment_op_stmt func(c *Assignment_op_stmtContext)

+ EnterInc_dec_stmt func(c *Inc_dec_stmtContext)

+ EnterStmt_inc_dec func(c *Stmt_inc_decContext)

+ EnterStmt_op_assign func(c *Stmt_op_assignContext)

+ EnterUnit func(c *UnitContext)

+ ExitAssignment_op_stmt func(c *Assignment_op_stmtContext)

+ ExitInc_dec_stmt func(c *Inc_dec_stmtContext)

+ ExitStmt_inc_dec func(c *Stmt_inc_decContext)

+ ExitStmt_op_assign func(c *Stmt_op_assignContext)

+ ExitUnit func(c *UnitContext)

type StartContext

+ func (s *StartContext) Unit() IUnitContext

+ type Stmt_inc_decContext struct

+ func NewStmt_inc_decContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_inc_decContext

+ func (s *Stmt_inc_decContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_inc_decContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_inc_decContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_inc_decContext) Inc_dec_stmt() IInc_dec_stmtContext

+ type Stmt_op_assignContext struct

+ func NewStmt_op_assignContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_op_assignContext

+ func (s *Stmt_op_assignContext) Assignment_op_stmt() IAssignment_op_stmtContext

+ func (s *Stmt_op_assignContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_op_assignContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_op_assignContext) GetRuleContext() antlr.RuleContext

+ type UnitContext struct

+ func NewEmptyUnitContext() *UnitContext

+ func NewUnitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnitContext

+ func (*UnitContext) IsUnitContext()

+ func (s *UnitContext) AllImport_stmt() []IImport_stmtContext

+ func (s *UnitContext) AllMeta_directive() []IMeta_directiveContext

+ func (s *UnitContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *UnitContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *UnitContext) GetParser() antlr.Parser

+ func (s *UnitContext) GetRuleContext() antlr.RuleContext

+ func (s *UnitContext) Import_stmt(i int) IImport_stmtContext

+ func (s *UnitContext) Meta_directive(i int) IMeta_directiveContext

+ func (s *UnitContext) Stmts() IStmtsContext

+ func (s *UnitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

v0.1.0

Oct 29, 2021

Changes in this version

+ const NitroLexerADD

+ const NitroLexerAND

+ const NitroLexerARROW

+ const NitroLexerASSIGN

+ const NitroLexerBREAK

+ const NitroLexerCATCH

+ const NitroLexerCBRACKET

+ const NitroLexerCCURLY

+ const NitroLexerCHAR

+ const NitroLexerCOLON

+ const NitroLexerCOMMA

+ const NitroLexerCOMMENT

+ const NitroLexerCONTINUE

+ const NitroLexerCPAREN

+ const NitroLexerDEFER

+ const NitroLexerDIV

+ const NitroLexerELSE

+ const NitroLexerEQ

+ const NitroLexerEXPAND

+ const NitroLexerFALSE

+ const NitroLexerFOR

+ const NitroLexerFUNC

+ const NitroLexerGE

+ const NitroLexerGT

+ const NitroLexerID

+ const NitroLexerIF

+ const NitroLexerIMPORT

+ const NitroLexerLAMBDA

+ const NitroLexerLDQUOTE

+ const NitroLexerLE

+ const NitroLexerLT

+ const NitroLexerMOD

+ const NitroLexerMUL

+ const NitroLexerM_FLAG

+ const NitroLexerM_INFO

+ const NitroLexerM_PARAM

+ const NitroLexerNE

+ const NitroLexerNEWLINE

+ const NitroLexerNIL

+ const NitroLexerNOT

+ const NitroLexerNUMBER

+ const NitroLexerOBRACKET

+ const NitroLexerOCURLY

+ const NitroLexerOPAREN

+ const NitroLexerOR

+ const NitroLexerPERIOD

+ const NitroLexerPIPE

+ const NitroLexerQSTR

+ const NitroLexerQUESTION_MARK

+ const NitroLexerREGEX

+ const NitroLexerRETURN

+ const NitroLexerSEMICOLON

+ const NitroLexerSTRING

+ const NitroLexerSUB

+ const NitroLexerTHROW

+ const NitroLexerTRUE

+ const NitroLexerTRY

+ const NitroLexerVAR

+ const NitroLexerWHILE

+ const NitroLexerWS

+ const NitroLexerYIELD

+ const NitroParserADD

+ const NitroParserAND

+ const NitroParserARROW

+ const NitroParserASSIGN

+ const NitroParserBREAK

+ const NitroParserCATCH

+ const NitroParserCBRACKET

+ const NitroParserCCURLY

+ const NitroParserCHAR

+ const NitroParserCOLON

+ const NitroParserCOMMA

+ const NitroParserCOMMENT

+ const NitroParserCONTINUE

+ const NitroParserCPAREN

+ const NitroParserDEFER

+ const NitroParserDIV

+ const NitroParserELSE

+ const NitroParserEOF

+ const NitroParserEQ

+ const NitroParserEXPAND

+ const NitroParserFALSE

+ const NitroParserFOR

+ const NitroParserFUNC

+ const NitroParserGE

+ const NitroParserGT

+ const NitroParserID

+ const NitroParserIF

+ const NitroParserIMPORT

+ const NitroParserLAMBDA

+ const NitroParserLDQUOTE

+ const NitroParserLE

+ const NitroParserLT

+ const NitroParserMOD

+ const NitroParserMUL

+ const NitroParserM_FLAG

+ const NitroParserM_INFO

+ const NitroParserM_PARAM

+ const NitroParserNE

+ const NitroParserNEWLINE

+ const NitroParserNIL

+ const NitroParserNOT

+ const NitroParserNUMBER

+ const NitroParserOBRACKET

+ const NitroParserOCURLY

+ const NitroParserOPAREN

+ const NitroParserOR

+ const NitroParserPERIOD

+ const NitroParserPIPE

+ const NitroParserQUESTION_MARK

+ const NitroParserREGEX

+ const NitroParserRETURN

+ const NitroParserRULE_arg_list

+ const NitroParserRULE_array_elem

+ const NitroParserRULE_array_elems

+ const NitroParserRULE_array_elif

+ const NitroParserRULE_array_else

+ const NitroParserRULE_array_for

+ const NitroParserRULE_array_if

+ const NitroParserRULE_array_literal

+ const NitroParserRULE_assignment_lvalues

+ const NitroParserRULE_assignment_stmt

+ const NitroParserRULE_binary_expr

+ const NitroParserRULE_break_stmt

+ const NitroParserRULE_continue_stmt

+ const NitroParserRULE_defer_stmt

+ const NitroParserRULE_expr

+ const NitroParserRULE_expr2

+ const NitroParserRULE_expr3

+ const NitroParserRULE_for_stmt

+ const NitroParserRULE_for_vars

+ const NitroParserRULE_func_stmt

+ const NitroParserRULE_id_or_keyword

+ const NitroParserRULE_if_elif

+ const NitroParserRULE_if_else

+ const NitroParserRULE_if_stmt

+ const NitroParserRULE_import_stmt

+ const NitroParserRULE_lambda_expr

+ const NitroParserRULE_lvalue_expr

+ const NitroParserRULE_meta_attrib

+ const NitroParserRULE_meta_attribs

+ const NitroParserRULE_meta_directive

+ const NitroParserRULE_meta_flag

+ const NitroParserRULE_meta_info

+ const NitroParserRULE_meta_literal

+ const NitroParserRULE_meta_param

+ const NitroParserRULE_module

+ const NitroParserRULE_object_elif

+ const NitroParserRULE_object_else

+ const NitroParserRULE_object_field

+ const NitroParserRULE_object_fields

+ const NitroParserRULE_object_for

+ const NitroParserRULE_object_if

+ const NitroParserRULE_object_literal

+ const NitroParserRULE_param_list

+ const NitroParserRULE_primary_expr

+ const NitroParserRULE_return_stmt

+ const NitroParserRULE_rvalues

+ const NitroParserRULE_short_lambda_expr

+ const NitroParserRULE_simple_literal

+ const NitroParserRULE_start

+ const NitroParserRULE_stmt

+ const NitroParserRULE_stmt_list

+ const NitroParserRULE_stmts

+ const NitroParserRULE_throw_stmt

+ const NitroParserRULE_try_catch_stmt

+ const NitroParserRULE_unary_expr

+ const NitroParserRULE_var_decl_stmt

+ const NitroParserRULE_var_decl_vars

+ const NitroParserRULE_while_stmt

+ const NitroParserRULE_yield_stmt

+ const NitroParserSEMICOLON

+ const NitroParserSTRING

+ const NitroParserSUB

+ const NitroParserTHROW

+ const NitroParserTRUE

+ const NitroParserTRY

+ const NitroParserVAR

+ const NitroParserWHILE

+ const NitroParserWS

+ const NitroParserYIELD

+ type Arg_listContext struct

+ func NewArg_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arg_listContext

+ func NewEmptyArg_listContext() *Arg_listContext

+ func (*Arg_listContext) IsArg_listContext()

+ func (s *Arg_listContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Arg_listContext) AllExpr() []IExprContext

+ func (s *Arg_listContext) COMMA(i int) antlr.TerminalNode

+ func (s *Arg_listContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Arg_listContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Arg_listContext) Expr(i int) IExprContext

+ func (s *Arg_listContext) GetParser() antlr.Parser

+ func (s *Arg_listContext) GetRuleContext() antlr.RuleContext

+ func (s *Arg_listContext) SEMICOLON() antlr.TerminalNode

+ func (s *Arg_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Array_elemContext struct

+ func NewArray_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_elemContext

+ func NewEmptyArray_elemContext() *Array_elemContext

+ func (*Array_elemContext) IsArray_elemContext()

+ func (s *Array_elemContext) Array_for() IArray_forContext

+ func (s *Array_elemContext) Array_if() IArray_ifContext

+ func (s *Array_elemContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Array_elemContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Array_elemContext) Expr() IExprContext

+ func (s *Array_elemContext) GetParser() antlr.Parser

+ func (s *Array_elemContext) GetRuleContext() antlr.RuleContext

+ func (s *Array_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Array_elemsContext struct

+ func NewArray_elemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_elemsContext

+ func NewEmptyArray_elemsContext() *Array_elemsContext

+ func (*Array_elemsContext) IsArray_elemsContext()

+ func (s *Array_elemsContext) AllArray_elem() []IArray_elemContext

+ func (s *Array_elemsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Array_elemsContext) AllSEMICOLON() []antlr.TerminalNode

+ func (s *Array_elemsContext) Array_elem(i int) IArray_elemContext

+ func (s *Array_elemsContext) COMMA(i int) antlr.TerminalNode

+ func (s *Array_elemsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Array_elemsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Array_elemsContext) GetParser() antlr.Parser

+ func (s *Array_elemsContext) GetRuleContext() antlr.RuleContext

+ func (s *Array_elemsContext) SEMICOLON(i int) antlr.TerminalNode

+ func (s *Array_elemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Array_elifContext struct

+ func NewArray_elifContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_elifContext

+ func NewEmptyArray_elifContext() *Array_elifContext

+ func (*Array_elifContext) IsArray_elifContext()

+ func (s *Array_elifContext) Array_elems() IArray_elemsContext

+ func (s *Array_elifContext) CCURLY() antlr.TerminalNode

+ func (s *Array_elifContext) ELSE() antlr.TerminalNode

+ func (s *Array_elifContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Array_elifContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Array_elifContext) Expr() IExprContext

+ func (s *Array_elifContext) GetParser() antlr.Parser

+ func (s *Array_elifContext) GetRuleContext() antlr.RuleContext

+ func (s *Array_elifContext) IF() antlr.TerminalNode

+ func (s *Array_elifContext) OCURLY() antlr.TerminalNode

+ func (s *Array_elifContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Array_elseContext struct

+ func NewArray_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_elseContext

+ func NewEmptyArray_elseContext() *Array_elseContext

+ func (*Array_elseContext) IsArray_elseContext()

+ func (s *Array_elseContext) Array_elems() IArray_elemsContext

+ func (s *Array_elseContext) CCURLY() antlr.TerminalNode

+ func (s *Array_elseContext) ELSE() antlr.TerminalNode

+ func (s *Array_elseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Array_elseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Array_elseContext) GetParser() antlr.Parser

+ func (s *Array_elseContext) GetRuleContext() antlr.RuleContext

+ func (s *Array_elseContext) OCURLY() antlr.TerminalNode

+ func (s *Array_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Array_forContext struct

+ func NewArray_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_forContext

+ func NewEmptyArray_forContext() *Array_forContext

+ func (*Array_forContext) IsArray_forContext()

+ func (s *Array_forContext) Array_elems() IArray_elemsContext

+ func (s *Array_forContext) CCURLY() antlr.TerminalNode

+ func (s *Array_forContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Array_forContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Array_forContext) Expr() IExprContext

+ func (s *Array_forContext) FOR() antlr.TerminalNode

+ func (s *Array_forContext) For_vars() IFor_varsContext

+ func (s *Array_forContext) GetParser() antlr.Parser

+ func (s *Array_forContext) GetRuleContext() antlr.RuleContext

+ func (s *Array_forContext) ID() antlr.TerminalNode

+ func (s *Array_forContext) OCURLY() antlr.TerminalNode

+ func (s *Array_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Array_ifContext struct

+ func NewArray_ifContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_ifContext

+ func NewEmptyArray_ifContext() *Array_ifContext

+ func (*Array_ifContext) IsArray_ifContext()

+ func (s *Array_ifContext) AllArray_elif() []IArray_elifContext

+ func (s *Array_ifContext) Array_elems() IArray_elemsContext

+ func (s *Array_ifContext) Array_elif(i int) IArray_elifContext

+ func (s *Array_ifContext) Array_else() IArray_elseContext

+ func (s *Array_ifContext) CCURLY() antlr.TerminalNode

+ func (s *Array_ifContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Array_ifContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Array_ifContext) Expr() IExprContext

+ func (s *Array_ifContext) GetParser() antlr.Parser

+ func (s *Array_ifContext) GetRuleContext() antlr.RuleContext

+ func (s *Array_ifContext) IF() antlr.TerminalNode

+ func (s *Array_ifContext) OCURLY() antlr.TerminalNode

+ func (s *Array_ifContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Array_literalContext struct

+ func NewArray_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_literalContext

+ func NewEmptyArray_literalContext() *Array_literalContext

+ func (*Array_literalContext) IsArray_literalContext()

+ func (s *Array_literalContext) Array_elems() IArray_elemsContext

+ func (s *Array_literalContext) CBRACKET() antlr.TerminalNode

+ func (s *Array_literalContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Array_literalContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Array_literalContext) GetParser() antlr.Parser

+ func (s *Array_literalContext) GetRuleContext() antlr.RuleContext

+ func (s *Array_literalContext) OBRACKET() antlr.TerminalNode

+ func (s *Array_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Assignment_lvaluesContext struct

+ func NewAssignment_lvaluesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignment_lvaluesContext

+ func NewEmptyAssignment_lvaluesContext() *Assignment_lvaluesContext

+ func (*Assignment_lvaluesContext) IsAssignment_lvaluesContext()

+ func (s *Assignment_lvaluesContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Assignment_lvaluesContext) AllLvalue_expr() []ILvalue_exprContext

+ func (s *Assignment_lvaluesContext) COMMA(i int) antlr.TerminalNode

+ func (s *Assignment_lvaluesContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Assignment_lvaluesContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Assignment_lvaluesContext) GetParser() antlr.Parser

+ func (s *Assignment_lvaluesContext) GetRuleContext() antlr.RuleContext

+ func (s *Assignment_lvaluesContext) Lvalue_expr(i int) ILvalue_exprContext

+ func (s *Assignment_lvaluesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Assignment_stmtContext struct

+ func NewAssignment_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignment_stmtContext

+ func NewEmptyAssignment_stmtContext() *Assignment_stmtContext

+ func (*Assignment_stmtContext) IsAssignment_stmtContext()

+ func (s *Assignment_stmtContext) ASSIGN() antlr.TerminalNode

+ func (s *Assignment_stmtContext) Assignment_lvalues() IAssignment_lvaluesContext

+ func (s *Assignment_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Assignment_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Assignment_stmtContext) GetParser() antlr.Parser

+ func (s *Assignment_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Assignment_stmtContext) Rvalues() IRvaluesContext

+ func (s *Assignment_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type BaseNitroParserListener struct

+ func (s *BaseNitroParserListener) EnterArg_list(ctx *Arg_listContext)

+ func (s *BaseNitroParserListener) EnterArray_elem(ctx *Array_elemContext)

+ func (s *BaseNitroParserListener) EnterArray_elems(ctx *Array_elemsContext)

+ func (s *BaseNitroParserListener) EnterArray_elif(ctx *Array_elifContext)

+ func (s *BaseNitroParserListener) EnterArray_else(ctx *Array_elseContext)

+ func (s *BaseNitroParserListener) EnterArray_for(ctx *Array_forContext)

+ func (s *BaseNitroParserListener) EnterArray_if(ctx *Array_ifContext)

+ func (s *BaseNitroParserListener) EnterArray_literal(ctx *Array_literalContext)

+ func (s *BaseNitroParserListener) EnterAssignment_lvalues(ctx *Assignment_lvaluesContext)

+ func (s *BaseNitroParserListener) EnterAssignment_stmt(ctx *Assignment_stmtContext)

+ func (s *BaseNitroParserListener) EnterBinary_expr(ctx *Binary_exprContext)

+ func (s *BaseNitroParserListener) EnterBreak_stmt(ctx *Break_stmtContext)

+ func (s *BaseNitroParserListener) EnterContinue_stmt(ctx *Continue_stmtContext)

+ func (s *BaseNitroParserListener) EnterDefer_stmt(ctx *Defer_stmtContext)

+ func (s *BaseNitroParserListener) EnterEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseNitroParserListener) EnterExpr(ctx *ExprContext)

+ func (s *BaseNitroParserListener) EnterExpr2(ctx *Expr2Context)

+ func (s *BaseNitroParserListener) EnterExpr3(ctx *Expr3Context)

+ func (s *BaseNitroParserListener) EnterFor_stmt(ctx *For_stmtContext)

+ func (s *BaseNitroParserListener) EnterFor_vars(ctx *For_varsContext)

+ func (s *BaseNitroParserListener) EnterFunc_stmt(ctx *Func_stmtContext)

+ func (s *BaseNitroParserListener) EnterId_or_keyword(ctx *Id_or_keywordContext)

+ func (s *BaseNitroParserListener) EnterIf_elif(ctx *If_elifContext)

+ func (s *BaseNitroParserListener) EnterIf_else(ctx *If_elseContext)

+ func (s *BaseNitroParserListener) EnterIf_stmt(ctx *If_stmtContext)

+ func (s *BaseNitroParserListener) EnterImport_stmt(ctx *Import_stmtContext)

+ func (s *BaseNitroParserListener) EnterLambda_expr(ctx *Lambda_exprContext)

+ func (s *BaseNitroParserListener) EnterLvalue_expr_index(ctx *Lvalue_expr_indexContext)

+ func (s *BaseNitroParserListener) EnterLvalue_expr_member_access(ctx *Lvalue_expr_member_accessContext)

+ func (s *BaseNitroParserListener) EnterLvalue_expr_simple_ref(ctx *Lvalue_expr_simple_refContext)

+ func (s *BaseNitroParserListener) EnterMeta_attrib(ctx *Meta_attribContext)

+ func (s *BaseNitroParserListener) EnterMeta_attribs(ctx *Meta_attribsContext)

+ func (s *BaseNitroParserListener) EnterMeta_directive(ctx *Meta_directiveContext)

+ func (s *BaseNitroParserListener) EnterMeta_flag(ctx *Meta_flagContext)

+ func (s *BaseNitroParserListener) EnterMeta_info(ctx *Meta_infoContext)

+ func (s *BaseNitroParserListener) EnterMeta_literal(ctx *Meta_literalContext)

+ func (s *BaseNitroParserListener) EnterMeta_param(ctx *Meta_paramContext)

+ func (s *BaseNitroParserListener) EnterModule(ctx *ModuleContext)

+ func (s *BaseNitroParserListener) EnterObject_elif(ctx *Object_elifContext)

+ func (s *BaseNitroParserListener) EnterObject_else(ctx *Object_elseContext)

+ func (s *BaseNitroParserListener) EnterObject_field_expansion(ctx *Object_field_expansionContext)

+ func (s *BaseNitroParserListener) EnterObject_field_expr_key(ctx *Object_field_expr_keyContext)

+ func (s *BaseNitroParserListener) EnterObject_field_for(ctx *Object_field_forContext)

+ func (s *BaseNitroParserListener) EnterObject_field_id_key(ctx *Object_field_id_keyContext)

+ func (s *BaseNitroParserListener) EnterObject_field_if(ctx *Object_field_ifContext)

+ func (s *BaseNitroParserListener) EnterObject_fields(ctx *Object_fieldsContext)

+ func (s *BaseNitroParserListener) EnterObject_for(ctx *Object_forContext)

+ func (s *BaseNitroParserListener) EnterObject_if(ctx *Object_ifContext)

+ func (s *BaseNitroParserListener) EnterObject_literal(ctx *Object_literalContext)

+ func (s *BaseNitroParserListener) EnterParam_list(ctx *Param_listContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_array(ctx *Primary_expr_arrayContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_call(ctx *Primary_expr_callContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_index(ctx *Primary_expr_indexContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_lambda(ctx *Primary_expr_lambdaContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_literal(ctx *Primary_expr_literalContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_member_access(ctx *Primary_expr_member_accessContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_object(ctx *Primary_expr_objectContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_parenthesis(ctx *Primary_expr_parenthesisContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_regex(ctx *Primary_expr_regexContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_simple_ref(ctx *Primary_expr_simple_refContext)

+ func (s *BaseNitroParserListener) EnterPrimary_expr_slice(ctx *Primary_expr_sliceContext)

+ func (s *BaseNitroParserListener) EnterReturn_stmt(ctx *Return_stmtContext)

+ func (s *BaseNitroParserListener) EnterRvalues(ctx *RvaluesContext)

+ func (s *BaseNitroParserListener) EnterShort_lambda_expr(ctx *Short_lambda_exprContext)

+ func (s *BaseNitroParserListener) EnterSimple_literal(ctx *Simple_literalContext)

+ func (s *BaseNitroParserListener) EnterStart(ctx *StartContext)

+ func (s *BaseNitroParserListener) EnterStmt_assignment(ctx *Stmt_assignmentContext)

+ func (s *BaseNitroParserListener) EnterStmt_break(ctx *Stmt_breakContext)

+ func (s *BaseNitroParserListener) EnterStmt_continue(ctx *Stmt_continueContext)

+ func (s *BaseNitroParserListener) EnterStmt_defer(ctx *Stmt_deferContext)

+ func (s *BaseNitroParserListener) EnterStmt_expr(ctx *Stmt_exprContext)

+ func (s *BaseNitroParserListener) EnterStmt_for(ctx *Stmt_forContext)

+ func (s *BaseNitroParserListener) EnterStmt_func(ctx *Stmt_funcContext)

+ func (s *BaseNitroParserListener) EnterStmt_if(ctx *Stmt_ifContext)

+ func (s *BaseNitroParserListener) EnterStmt_list(ctx *Stmt_listContext)

+ func (s *BaseNitroParserListener) EnterStmt_return(ctx *Stmt_returnContext)

+ func (s *BaseNitroParserListener) EnterStmt_throw(ctx *Stmt_throwContext)

+ func (s *BaseNitroParserListener) EnterStmt_try_catch(ctx *Stmt_try_catchContext)

+ func (s *BaseNitroParserListener) EnterStmt_var_dec(ctx *Stmt_var_decContext)

+ func (s *BaseNitroParserListener) EnterStmt_while(ctx *Stmt_whileContext)

+ func (s *BaseNitroParserListener) EnterStmt_yield(ctx *Stmt_yieldContext)

+ func (s *BaseNitroParserListener) EnterStmts(ctx *StmtsContext)

+ func (s *BaseNitroParserListener) EnterThrow_stmt(ctx *Throw_stmtContext)

+ func (s *BaseNitroParserListener) EnterTry_catch_stmt(ctx *Try_catch_stmtContext)

+ func (s *BaseNitroParserListener) EnterUnary_expr(ctx *Unary_exprContext)

+ func (s *BaseNitroParserListener) EnterVar_decl_stmt(ctx *Var_decl_stmtContext)

+ func (s *BaseNitroParserListener) EnterVar_decl_vars(ctx *Var_decl_varsContext)

+ func (s *BaseNitroParserListener) EnterWhile_stmt(ctx *While_stmtContext)

+ func (s *BaseNitroParserListener) EnterYield_stmt(ctx *Yield_stmtContext)

+ func (s *BaseNitroParserListener) ExitArg_list(ctx *Arg_listContext)

+ func (s *BaseNitroParserListener) ExitArray_elem(ctx *Array_elemContext)

+ func (s *BaseNitroParserListener) ExitArray_elems(ctx *Array_elemsContext)

+ func (s *BaseNitroParserListener) ExitArray_elif(ctx *Array_elifContext)

+ func (s *BaseNitroParserListener) ExitArray_else(ctx *Array_elseContext)

+ func (s *BaseNitroParserListener) ExitArray_for(ctx *Array_forContext)

+ func (s *BaseNitroParserListener) ExitArray_if(ctx *Array_ifContext)

+ func (s *BaseNitroParserListener) ExitArray_literal(ctx *Array_literalContext)

+ func (s *BaseNitroParserListener) ExitAssignment_lvalues(ctx *Assignment_lvaluesContext)

+ func (s *BaseNitroParserListener) ExitAssignment_stmt(ctx *Assignment_stmtContext)

+ func (s *BaseNitroParserListener) ExitBinary_expr(ctx *Binary_exprContext)

+ func (s *BaseNitroParserListener) ExitBreak_stmt(ctx *Break_stmtContext)

+ func (s *BaseNitroParserListener) ExitContinue_stmt(ctx *Continue_stmtContext)

+ func (s *BaseNitroParserListener) ExitDefer_stmt(ctx *Defer_stmtContext)

+ func (s *BaseNitroParserListener) ExitEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseNitroParserListener) ExitExpr(ctx *ExprContext)

+ func (s *BaseNitroParserListener) ExitExpr2(ctx *Expr2Context)

+ func (s *BaseNitroParserListener) ExitExpr3(ctx *Expr3Context)

+ func (s *BaseNitroParserListener) ExitFor_stmt(ctx *For_stmtContext)

+ func (s *BaseNitroParserListener) ExitFor_vars(ctx *For_varsContext)

+ func (s *BaseNitroParserListener) ExitFunc_stmt(ctx *Func_stmtContext)

+ func (s *BaseNitroParserListener) ExitId_or_keyword(ctx *Id_or_keywordContext)

+ func (s *BaseNitroParserListener) ExitIf_elif(ctx *If_elifContext)

+ func (s *BaseNitroParserListener) ExitIf_else(ctx *If_elseContext)

+ func (s *BaseNitroParserListener) ExitIf_stmt(ctx *If_stmtContext)

+ func (s *BaseNitroParserListener) ExitImport_stmt(ctx *Import_stmtContext)

+ func (s *BaseNitroParserListener) ExitLambda_expr(ctx *Lambda_exprContext)

+ func (s *BaseNitroParserListener) ExitLvalue_expr_index(ctx *Lvalue_expr_indexContext)

+ func (s *BaseNitroParserListener) ExitLvalue_expr_member_access(ctx *Lvalue_expr_member_accessContext)

+ func (s *BaseNitroParserListener) ExitLvalue_expr_simple_ref(ctx *Lvalue_expr_simple_refContext)

+ func (s *BaseNitroParserListener) ExitMeta_attrib(ctx *Meta_attribContext)

+ func (s *BaseNitroParserListener) ExitMeta_attribs(ctx *Meta_attribsContext)

+ func (s *BaseNitroParserListener) ExitMeta_directive(ctx *Meta_directiveContext)

+ func (s *BaseNitroParserListener) ExitMeta_flag(ctx *Meta_flagContext)

+ func (s *BaseNitroParserListener) ExitMeta_info(ctx *Meta_infoContext)

+ func (s *BaseNitroParserListener) ExitMeta_literal(ctx *Meta_literalContext)

+ func (s *BaseNitroParserListener) ExitMeta_param(ctx *Meta_paramContext)

+ func (s *BaseNitroParserListener) ExitModule(ctx *ModuleContext)

+ func (s *BaseNitroParserListener) ExitObject_elif(ctx *Object_elifContext)

+ func (s *BaseNitroParserListener) ExitObject_else(ctx *Object_elseContext)

+ func (s *BaseNitroParserListener) ExitObject_field_expansion(ctx *Object_field_expansionContext)

+ func (s *BaseNitroParserListener) ExitObject_field_expr_key(ctx *Object_field_expr_keyContext)

+ func (s *BaseNitroParserListener) ExitObject_field_for(ctx *Object_field_forContext)

+ func (s *BaseNitroParserListener) ExitObject_field_id_key(ctx *Object_field_id_keyContext)

+ func (s *BaseNitroParserListener) ExitObject_field_if(ctx *Object_field_ifContext)

+ func (s *BaseNitroParserListener) ExitObject_fields(ctx *Object_fieldsContext)

+ func (s *BaseNitroParserListener) ExitObject_for(ctx *Object_forContext)

+ func (s *BaseNitroParserListener) ExitObject_if(ctx *Object_ifContext)

+ func (s *BaseNitroParserListener) ExitObject_literal(ctx *Object_literalContext)

+ func (s *BaseNitroParserListener) ExitParam_list(ctx *Param_listContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_array(ctx *Primary_expr_arrayContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_call(ctx *Primary_expr_callContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_index(ctx *Primary_expr_indexContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_lambda(ctx *Primary_expr_lambdaContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_literal(ctx *Primary_expr_literalContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_member_access(ctx *Primary_expr_member_accessContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_object(ctx *Primary_expr_objectContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_parenthesis(ctx *Primary_expr_parenthesisContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_regex(ctx *Primary_expr_regexContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_simple_ref(ctx *Primary_expr_simple_refContext)

+ func (s *BaseNitroParserListener) ExitPrimary_expr_slice(ctx *Primary_expr_sliceContext)

+ func (s *BaseNitroParserListener) ExitReturn_stmt(ctx *Return_stmtContext)

+ func (s *BaseNitroParserListener) ExitRvalues(ctx *RvaluesContext)

+ func (s *BaseNitroParserListener) ExitShort_lambda_expr(ctx *Short_lambda_exprContext)

+ func (s *BaseNitroParserListener) ExitSimple_literal(ctx *Simple_literalContext)

+ func (s *BaseNitroParserListener) ExitStart(ctx *StartContext)

+ func (s *BaseNitroParserListener) ExitStmt_assignment(ctx *Stmt_assignmentContext)

+ func (s *BaseNitroParserListener) ExitStmt_break(ctx *Stmt_breakContext)

+ func (s *BaseNitroParserListener) ExitStmt_continue(ctx *Stmt_continueContext)

+ func (s *BaseNitroParserListener) ExitStmt_defer(ctx *Stmt_deferContext)

+ func (s *BaseNitroParserListener) ExitStmt_expr(ctx *Stmt_exprContext)

+ func (s *BaseNitroParserListener) ExitStmt_for(ctx *Stmt_forContext)

+ func (s *BaseNitroParserListener) ExitStmt_func(ctx *Stmt_funcContext)

+ func (s *BaseNitroParserListener) ExitStmt_if(ctx *Stmt_ifContext)

+ func (s *BaseNitroParserListener) ExitStmt_list(ctx *Stmt_listContext)

+ func (s *BaseNitroParserListener) ExitStmt_return(ctx *Stmt_returnContext)

+ func (s *BaseNitroParserListener) ExitStmt_throw(ctx *Stmt_throwContext)

+ func (s *BaseNitroParserListener) ExitStmt_try_catch(ctx *Stmt_try_catchContext)

+ func (s *BaseNitroParserListener) ExitStmt_var_dec(ctx *Stmt_var_decContext)

+ func (s *BaseNitroParserListener) ExitStmt_while(ctx *Stmt_whileContext)

+ func (s *BaseNitroParserListener) ExitStmt_yield(ctx *Stmt_yieldContext)

+ func (s *BaseNitroParserListener) ExitStmts(ctx *StmtsContext)

+ func (s *BaseNitroParserListener) ExitThrow_stmt(ctx *Throw_stmtContext)

+ func (s *BaseNitroParserListener) ExitTry_catch_stmt(ctx *Try_catch_stmtContext)

+ func (s *BaseNitroParserListener) ExitUnary_expr(ctx *Unary_exprContext)

+ func (s *BaseNitroParserListener) ExitVar_decl_stmt(ctx *Var_decl_stmtContext)

+ func (s *BaseNitroParserListener) ExitVar_decl_vars(ctx *Var_decl_varsContext)

+ func (s *BaseNitroParserListener) ExitWhile_stmt(ctx *While_stmtContext)

+ func (s *BaseNitroParserListener) ExitYield_stmt(ctx *Yield_stmtContext)

+ func (s *BaseNitroParserListener) VisitErrorNode(node antlr.ErrorNode)

+ func (s *BaseNitroParserListener) VisitTerminal(node antlr.TerminalNode)

+ type Binary_exprContext struct

+ func NewBinary_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Binary_exprContext

+ func NewEmptyBinary_exprContext() *Binary_exprContext

+ func (*Binary_exprContext) IsBinary_exprContext()

+ func (s *Binary_exprContext) ADD() antlr.TerminalNode

+ func (s *Binary_exprContext) AND() antlr.TerminalNode

+ func (s *Binary_exprContext) AllBinary_expr() []IBinary_exprContext

+ func (s *Binary_exprContext) Binary_expr(i int) IBinary_exprContext

+ func (s *Binary_exprContext) DIV() antlr.TerminalNode

+ func (s *Binary_exprContext) EQ() antlr.TerminalNode

+ func (s *Binary_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Binary_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Binary_exprContext) GE() antlr.TerminalNode

+ func (s *Binary_exprContext) GT() antlr.TerminalNode

+ func (s *Binary_exprContext) GetOp() antlr.Token

+ func (s *Binary_exprContext) GetParser() antlr.Parser

+ func (s *Binary_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Binary_exprContext) LE() antlr.TerminalNode

+ func (s *Binary_exprContext) LT() antlr.TerminalNode

+ func (s *Binary_exprContext) MOD() antlr.TerminalNode

+ func (s *Binary_exprContext) MUL() antlr.TerminalNode

+ func (s *Binary_exprContext) NE() antlr.TerminalNode

+ func (s *Binary_exprContext) OR() antlr.TerminalNode

+ func (s *Binary_exprContext) SUB() antlr.TerminalNode

+ func (s *Binary_exprContext) SetOp(v antlr.Token)

+ func (s *Binary_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Binary_exprContext) Unary_expr() IUnary_exprContext

+ type Break_stmtContext struct

+ func NewBreak_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Break_stmtContext

+ func NewEmptyBreak_stmtContext() *Break_stmtContext

+ func (*Break_stmtContext) IsBreak_stmtContext()

+ func (s *Break_stmtContext) BREAK() antlr.TerminalNode

+ func (s *Break_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Break_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Break_stmtContext) GetParser() antlr.Parser

+ func (s *Break_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Break_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Continue_stmtContext struct

+ func NewContinue_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Continue_stmtContext

+ func NewEmptyContinue_stmtContext() *Continue_stmtContext

+ func (*Continue_stmtContext) IsContinue_stmtContext()

+ func (s *Continue_stmtContext) CONTINUE() antlr.TerminalNode

+ func (s *Continue_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Continue_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Continue_stmtContext) GetParser() antlr.Parser

+ func (s *Continue_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Continue_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Defer_stmtContext struct

+ func NewDefer_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Defer_stmtContext

+ func NewEmptyDefer_stmtContext() *Defer_stmtContext

+ func (*Defer_stmtContext) IsDefer_stmtContext()

+ func (s *Defer_stmtContext) DEFER() antlr.TerminalNode

+ func (s *Defer_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Defer_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Defer_stmtContext) GetParser() antlr.Parser

+ func (s *Defer_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Defer_stmtContext) Primary_expr() IPrimary_exprContext

+ func (s *Defer_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Expr2Context struct

+ func NewEmptyExpr2Context() *Expr2Context

+ func NewExpr2Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr2Context

+ func (*Expr2Context) IsExpr2Context()

+ func (s *Expr2Context) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr2Context) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr2Context) Expr3() IExpr3Context

+ func (s *Expr2Context) GetParser() antlr.Parser

+ func (s *Expr2Context) GetRuleContext() antlr.RuleContext

+ func (s *Expr2Context) Short_lambda_expr() IShort_lambda_exprContext

+ func (s *Expr2Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Expr3Context struct

+ func NewEmptyExpr3Context() *Expr3Context

+ func NewExpr3Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr3Context

+ func (*Expr3Context) IsExpr3Context()

+ func (s *Expr3Context) AllExpr3() []IExpr3Context

+ func (s *Expr3Context) Binary_expr() IBinary_exprContext

+ func (s *Expr3Context) COLON() antlr.TerminalNode

+ func (s *Expr3Context) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr3Context) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr3Context) Expr3(i int) IExpr3Context

+ func (s *Expr3Context) GetParser() antlr.Parser

+ func (s *Expr3Context) GetRuleContext() antlr.RuleContext

+ func (s *Expr3Context) QUESTION_MARK() antlr.TerminalNode

+ func (s *Expr3Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ExprContext struct

+ func NewEmptyExprContext() *ExprContext

+ func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext

+ func (*ExprContext) IsExprContext()

+ func (s *ExprContext) AllExpr() []IExprContext

+ func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ExprContext) Expr(i int) IExprContext

+ func (s *ExprContext) Expr2() IExpr2Context

+ func (s *ExprContext) GetParser() antlr.Parser

+ func (s *ExprContext) GetRuleContext() antlr.RuleContext

+ func (s *ExprContext) PIPE() antlr.TerminalNode

+ func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type For_stmtContext struct

+ func NewEmptyFor_stmtContext() *For_stmtContext

+ func NewFor_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_stmtContext

+ func (*For_stmtContext) IsFor_stmtContext()

+ func (s *For_stmtContext) CCURLY() antlr.TerminalNode

+ func (s *For_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *For_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *For_stmtContext) Expr() IExprContext

+ func (s *For_stmtContext) FOR() antlr.TerminalNode

+ func (s *For_stmtContext) For_vars() IFor_varsContext

+ func (s *For_stmtContext) GetParser() antlr.Parser

+ func (s *For_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *For_stmtContext) ID() antlr.TerminalNode

+ func (s *For_stmtContext) OCURLY() antlr.TerminalNode

+ func (s *For_stmtContext) Stmts() IStmtsContext

+ func (s *For_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type For_varsContext struct

+ func NewEmptyFor_varsContext() *For_varsContext

+ func NewFor_varsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_varsContext

+ func (*For_varsContext) IsFor_varsContext()

+ func (s *For_varsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *For_varsContext) AllID() []antlr.TerminalNode

+ func (s *For_varsContext) COMMA(i int) antlr.TerminalNode

+ func (s *For_varsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *For_varsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *For_varsContext) GetParser() antlr.Parser

+ func (s *For_varsContext) GetRuleContext() antlr.RuleContext

+ func (s *For_varsContext) ID(i int) antlr.TerminalNode

+ func (s *For_varsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Func_stmtContext struct

+ func NewEmptyFunc_stmtContext() *Func_stmtContext

+ func NewFunc_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_stmtContext

+ func (*Func_stmtContext) IsFunc_stmtContext()

+ func (s *Func_stmtContext) CCURLY() antlr.TerminalNode

+ func (s *Func_stmtContext) CPAREN() antlr.TerminalNode

+ func (s *Func_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Func_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Func_stmtContext) FUNC() antlr.TerminalNode

+ func (s *Func_stmtContext) GetParser() antlr.Parser

+ func (s *Func_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Func_stmtContext) ID() antlr.TerminalNode

+ func (s *Func_stmtContext) OCURLY() antlr.TerminalNode

+ func (s *Func_stmtContext) OPAREN() antlr.TerminalNode

+ func (s *Func_stmtContext) Param_list() IParam_listContext

+ func (s *Func_stmtContext) Stmts() IStmtsContext

+ func (s *Func_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type IArg_listContext interface

+ GetParser func() antlr.Parser

+ IsArg_listContext func()

+ type IArray_elemContext interface

+ GetParser func() antlr.Parser

+ IsArray_elemContext func()

+ type IArray_elemsContext interface

+ GetParser func() antlr.Parser

+ IsArray_elemsContext func()

+ type IArray_elifContext interface

+ GetParser func() antlr.Parser

+ IsArray_elifContext func()

+ type IArray_elseContext interface

+ GetParser func() antlr.Parser

+ IsArray_elseContext func()

+ type IArray_forContext interface

+ GetParser func() antlr.Parser

+ IsArray_forContext func()

+ type IArray_ifContext interface

+ GetParser func() antlr.Parser

+ IsArray_ifContext func()

+ type IArray_literalContext interface

+ GetParser func() antlr.Parser

+ IsArray_literalContext func()

+ type IAssignment_lvaluesContext interface

+ GetParser func() antlr.Parser

+ IsAssignment_lvaluesContext func()

+ type IAssignment_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAssignment_stmtContext func()

+ type IBinary_exprContext interface

+ GetOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsBinary_exprContext func()

+ SetOp func(antlr.Token)

+ type IBreak_stmtContext interface

+ GetParser func() antlr.Parser

+ IsBreak_stmtContext func()

+ type IContinue_stmtContext interface

+ GetParser func() antlr.Parser

+ IsContinue_stmtContext func()

+ type IDefer_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDefer_stmtContext func()

+ type IExpr2Context interface

+ GetParser func() antlr.Parser

+ IsExpr2Context func()

+ type IExpr3Context interface

+ GetParser func() antlr.Parser

+ IsExpr3Context func()

+ type IExprContext interface

+ GetParser func() antlr.Parser

+ IsExprContext func()

+ type IFor_stmtContext interface

+ GetParser func() antlr.Parser

+ IsFor_stmtContext func()

+ type IFor_varsContext interface

+ GetParser func() antlr.Parser

+ IsFor_varsContext func()

+ type IFunc_stmtContext interface

+ GetParser func() antlr.Parser

+ IsFunc_stmtContext func()

+ type IId_or_keywordContext interface

+ GetParser func() antlr.Parser

+ GetT func() antlr.Token

+ IsId_or_keywordContext func()

+ SetT func(antlr.Token)

+ type IIf_elifContext interface

+ GetParser func() antlr.Parser

+ IsIf_elifContext func()

+ type IIf_elseContext interface

+ GetParser func() antlr.Parser

+ IsIf_elseContext func()

+ type IIf_stmtContext interface

+ GetParser func() antlr.Parser

+ IsIf_stmtContext func()

+ type IImport_stmtContext interface

+ GetParser func() antlr.Parser

+ IsImport_stmtContext func()

+ type ILambda_exprContext interface

+ GetParser func() antlr.Parser

+ IsLambda_exprContext func()

+ type ILvalue_exprContext interface

+ GetParser func() antlr.Parser

+ IsLvalue_exprContext func()

+ type IMeta_attribContext interface

+ GetParser func() antlr.Parser

+ IsMeta_attribContext func()

+ type IMeta_attribsContext interface

+ GetParser func() antlr.Parser

+ IsMeta_attribsContext func()

+ type IMeta_directiveContext interface

+ GetParser func() antlr.Parser

+ IsMeta_directiveContext func()

+ type IMeta_flagContext interface

+ GetParser func() antlr.Parser

+ IsMeta_flagContext func()

+ type IMeta_infoContext interface

+ GetParser func() antlr.Parser

+ IsMeta_infoContext func()

+ type IMeta_literalContext interface

+ GetParser func() antlr.Parser

+ GetVal func() antlr.Token

+ IsMeta_literalContext func()

+ SetVal func(antlr.Token)

+ type IMeta_paramContext interface

+ GetParser func() antlr.Parser

+ IsMeta_paramContext func()

+ type IModuleContext interface

+ GetParser func() antlr.Parser

+ IsModuleContext func()

+ type IObject_elifContext interface

+ GetParser func() antlr.Parser

+ IsObject_elifContext func()

+ type IObject_elseContext interface

+ GetParser func() antlr.Parser

+ IsObject_elseContext func()

+ type IObject_fieldContext interface

+ GetParser func() antlr.Parser

+ IsObject_fieldContext func()

+ type IObject_fieldsContext interface

+ GetParser func() antlr.Parser

+ IsObject_fieldsContext func()

+ type IObject_forContext interface

+ GetParser func() antlr.Parser

+ IsObject_forContext func()

+ type IObject_ifContext interface

+ GetParser func() antlr.Parser

+ IsObject_ifContext func()

+ type IObject_literalContext interface

+ GetParser func() antlr.Parser

+ IsObject_literalContext func()

+ type IParam_listContext interface

+ GetParser func() antlr.Parser

+ IsParam_listContext func()

+ type IPrimary_exprContext interface

+ GetParser func() antlr.Parser

+ IsPrimary_exprContext func()

+ type IReturn_stmtContext interface

+ GetParser func() antlr.Parser

+ IsReturn_stmtContext func()

+ type IRvaluesContext interface

+ GetParser func() antlr.Parser

+ IsRvaluesContext func()

+ type IShort_lambda_exprContext interface

+ GetParser func() antlr.Parser

+ IsShort_lambda_exprContext func()

+ type ISimple_literalContext interface

+ GetParser func() antlr.Parser

+ GetVal func() antlr.Token

+ IsSimple_literalContext func()

+ SetVal func(antlr.Token)

+ type IStartContext interface

+ GetParser func() antlr.Parser

+ IsStartContext func()

+ type IStmtContext interface

+ GetParser func() antlr.Parser

+ IsStmtContext func()

+ type IStmt_listContext interface

+ GetParser func() antlr.Parser

+ IsStmt_listContext func()

+ type IStmtsContext interface

+ GetParser func() antlr.Parser

+ IsStmtsContext func()

+ type IThrow_stmtContext interface

+ GetParser func() antlr.Parser

+ IsThrow_stmtContext func()

+ type ITry_catch_stmtContext interface

+ GetParser func() antlr.Parser

+ IsTry_catch_stmtContext func()

+ type IUnary_exprContext interface

+ GetOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsUnary_exprContext func()

+ SetOp func(antlr.Token)

+ type IVar_decl_stmtContext interface

+ GetParser func() antlr.Parser

+ IsVar_decl_stmtContext func()

+ type IVar_decl_varsContext interface

+ GetParser func() antlr.Parser

+ IsVar_decl_varsContext func()

+ type IWhile_stmtContext interface

+ GetParser func() antlr.Parser

+ IsWhile_stmtContext func()

+ type IYield_stmtContext interface

+ GetParser func() antlr.Parser

+ IsYield_stmtContext func()

+ type Id_or_keywordContext struct

+ func NewEmptyId_or_keywordContext() *Id_or_keywordContext

+ func NewId_or_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Id_or_keywordContext

+ func (*Id_or_keywordContext) IsId_or_keywordContext()

+ func (s *Id_or_keywordContext) AND() antlr.TerminalNode

+ func (s *Id_or_keywordContext) BREAK() antlr.TerminalNode

+ func (s *Id_or_keywordContext) CATCH() antlr.TerminalNode

+ func (s *Id_or_keywordContext) CONTINUE() antlr.TerminalNode

+ func (s *Id_or_keywordContext) DEFER() antlr.TerminalNode

+ func (s *Id_or_keywordContext) ELSE() antlr.TerminalNode

+ func (s *Id_or_keywordContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Id_or_keywordContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Id_or_keywordContext) FALSE() antlr.TerminalNode

+ func (s *Id_or_keywordContext) FOR() antlr.TerminalNode

+ func (s *Id_or_keywordContext) FUNC() antlr.TerminalNode

+ func (s *Id_or_keywordContext) GetParser() antlr.Parser

+ func (s *Id_or_keywordContext) GetRuleContext() antlr.RuleContext

+ func (s *Id_or_keywordContext) GetT() antlr.Token

+ func (s *Id_or_keywordContext) ID() antlr.TerminalNode

+ func (s *Id_or_keywordContext) IF() antlr.TerminalNode

+ func (s *Id_or_keywordContext) IMPORT() antlr.TerminalNode

+ func (s *Id_or_keywordContext) NIL() antlr.TerminalNode

+ func (s *Id_or_keywordContext) NOT() antlr.TerminalNode

+ func (s *Id_or_keywordContext) OR() antlr.TerminalNode

+ func (s *Id_or_keywordContext) RETURN() antlr.TerminalNode

+ func (s *Id_or_keywordContext) SetT(v antlr.Token)

+ func (s *Id_or_keywordContext) THROW() antlr.TerminalNode

+ func (s *Id_or_keywordContext) TRUE() antlr.TerminalNode

+ func (s *Id_or_keywordContext) TRY() antlr.TerminalNode

+ func (s *Id_or_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Id_or_keywordContext) VAR() antlr.TerminalNode

+ func (s *Id_or_keywordContext) WHILE() antlr.TerminalNode

+ func (s *Id_or_keywordContext) YIELD() antlr.TerminalNode

+ type If_elifContext struct

+ func NewEmptyIf_elifContext() *If_elifContext

+ func NewIf_elifContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_elifContext

+ func (*If_elifContext) IsIf_elifContext()

+ func (s *If_elifContext) CCURLY() antlr.TerminalNode

+ func (s *If_elifContext) ELSE() antlr.TerminalNode

+ func (s *If_elifContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *If_elifContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *If_elifContext) Expr() IExprContext

+ func (s *If_elifContext) GetParser() antlr.Parser

+ func (s *If_elifContext) GetRuleContext() antlr.RuleContext

+ func (s *If_elifContext) IF() antlr.TerminalNode

+ func (s *If_elifContext) OCURLY() antlr.TerminalNode

+ func (s *If_elifContext) Stmts() IStmtsContext

+ func (s *If_elifContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type If_elseContext struct

+ func NewEmptyIf_elseContext() *If_elseContext

+ func NewIf_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_elseContext

+ func (*If_elseContext) IsIf_elseContext()

+ func (s *If_elseContext) CCURLY() antlr.TerminalNode

+ func (s *If_elseContext) ELSE() antlr.TerminalNode

+ func (s *If_elseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *If_elseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *If_elseContext) GetParser() antlr.Parser

+ func (s *If_elseContext) GetRuleContext() antlr.RuleContext

+ func (s *If_elseContext) OCURLY() antlr.TerminalNode

+ func (s *If_elseContext) Stmts() IStmtsContext

+ func (s *If_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type If_stmtContext struct

+ func NewEmptyIf_stmtContext() *If_stmtContext

+ func NewIf_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_stmtContext

+ func (*If_stmtContext) IsIf_stmtContext()

+ func (s *If_stmtContext) AllIf_elif() []IIf_elifContext

+ func (s *If_stmtContext) CCURLY() antlr.TerminalNode

+ func (s *If_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *If_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *If_stmtContext) Expr() IExprContext

+ func (s *If_stmtContext) GetParser() antlr.Parser

+ func (s *If_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *If_stmtContext) IF() antlr.TerminalNode

+ func (s *If_stmtContext) If_elif(i int) IIf_elifContext

+ func (s *If_stmtContext) If_else() IIf_elseContext

+ func (s *If_stmtContext) OCURLY() antlr.TerminalNode

+ func (s *If_stmtContext) Stmts() IStmtsContext

+ func (s *If_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Import_stmtContext struct

+ func NewEmptyImport_stmtContext() *Import_stmtContext

+ func NewImport_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_stmtContext

+ func (*Import_stmtContext) IsImport_stmtContext()

+ func (s *Import_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Import_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Import_stmtContext) GetParser() antlr.Parser

+ func (s *Import_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Import_stmtContext) ID() antlr.TerminalNode

+ func (s *Import_stmtContext) IMPORT() antlr.TerminalNode

+ func (s *Import_stmtContext) SEMICOLON() antlr.TerminalNode

+ func (s *Import_stmtContext) STRING() antlr.TerminalNode

+ func (s *Import_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Lambda_exprContext struct

+ func NewEmptyLambda_exprContext() *Lambda_exprContext

+ func NewLambda_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lambda_exprContext

+ func (*Lambda_exprContext) IsLambda_exprContext()

+ func (s *Lambda_exprContext) CCURLY() antlr.TerminalNode

+ func (s *Lambda_exprContext) CPAREN() antlr.TerminalNode

+ func (s *Lambda_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Lambda_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Lambda_exprContext) FUNC() antlr.TerminalNode

+ func (s *Lambda_exprContext) GetParser() antlr.Parser

+ func (s *Lambda_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Lambda_exprContext) OCURLY() antlr.TerminalNode

+ func (s *Lambda_exprContext) OPAREN() antlr.TerminalNode

+ func (s *Lambda_exprContext) Param_list() IParam_listContext

+ func (s *Lambda_exprContext) Stmts() IStmtsContext

+ func (s *Lambda_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Lvalue_exprContext struct

+ func NewEmptyLvalue_exprContext() *Lvalue_exprContext

+ func NewLvalue_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lvalue_exprContext

+ func (*Lvalue_exprContext) IsLvalue_exprContext()

+ func (s *Lvalue_exprContext) CopyFrom(ctx *Lvalue_exprContext)

+ func (s *Lvalue_exprContext) GetParser() antlr.Parser

+ func (s *Lvalue_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Lvalue_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Lvalue_expr_indexContext struct

+ func NewLvalue_expr_indexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Lvalue_expr_indexContext

+ func (s *Lvalue_expr_indexContext) CBRACKET() antlr.TerminalNode

+ func (s *Lvalue_expr_indexContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Lvalue_expr_indexContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Lvalue_expr_indexContext) Expr() IExprContext

+ func (s *Lvalue_expr_indexContext) GetRuleContext() antlr.RuleContext

+ func (s *Lvalue_expr_indexContext) OBRACKET() antlr.TerminalNode

+ func (s *Lvalue_expr_indexContext) Primary_expr() IPrimary_exprContext

+ type Lvalue_expr_member_accessContext struct

+ func NewLvalue_expr_member_accessContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Lvalue_expr_member_accessContext

+ func (s *Lvalue_expr_member_accessContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Lvalue_expr_member_accessContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Lvalue_expr_member_accessContext) GetRuleContext() antlr.RuleContext

+ func (s *Lvalue_expr_member_accessContext) ID() antlr.TerminalNode

+ func (s *Lvalue_expr_member_accessContext) PERIOD() antlr.TerminalNode

+ func (s *Lvalue_expr_member_accessContext) Primary_expr() IPrimary_exprContext

+ type Lvalue_expr_simple_refContext struct

+ func NewLvalue_expr_simple_refContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Lvalue_expr_simple_refContext

+ func (s *Lvalue_expr_simple_refContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Lvalue_expr_simple_refContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Lvalue_expr_simple_refContext) GetRuleContext() antlr.RuleContext

+ func (s *Lvalue_expr_simple_refContext) ID() antlr.TerminalNode

+ type Meta_attribContext struct

+ func NewEmptyMeta_attribContext() *Meta_attribContext

+ func NewMeta_attribContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meta_attribContext

+ func (*Meta_attribContext) IsMeta_attribContext()

+ func (s *Meta_attribContext) COLON() antlr.TerminalNode

+ func (s *Meta_attribContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Meta_attribContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Meta_attribContext) GetParser() antlr.Parser

+ func (s *Meta_attribContext) GetRuleContext() antlr.RuleContext

+ func (s *Meta_attribContext) Id_or_keyword() IId_or_keywordContext

+ func (s *Meta_attribContext) Meta_literal() IMeta_literalContext

+ func (s *Meta_attribContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Meta_attribsContext struct

+ func NewEmptyMeta_attribsContext() *Meta_attribsContext

+ func NewMeta_attribsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meta_attribsContext

+ func (*Meta_attribsContext) IsMeta_attribsContext()

+ func (s *Meta_attribsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Meta_attribsContext) AllMeta_attrib() []IMeta_attribContext

+ func (s *Meta_attribsContext) AllSEMICOLON() []antlr.TerminalNode

+ func (s *Meta_attribsContext) COMMA(i int) antlr.TerminalNode

+ func (s *Meta_attribsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Meta_attribsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Meta_attribsContext) GetParser() antlr.Parser

+ func (s *Meta_attribsContext) GetRuleContext() antlr.RuleContext

+ func (s *Meta_attribsContext) Meta_attrib(i int) IMeta_attribContext

+ func (s *Meta_attribsContext) SEMICOLON(i int) antlr.TerminalNode

+ func (s *Meta_attribsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Meta_directiveContext struct

+ func NewEmptyMeta_directiveContext() *Meta_directiveContext

+ func NewMeta_directiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meta_directiveContext

+ func (*Meta_directiveContext) IsMeta_directiveContext()

+ func (s *Meta_directiveContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Meta_directiveContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Meta_directiveContext) GetParser() antlr.Parser

+ func (s *Meta_directiveContext) GetRuleContext() antlr.RuleContext

+ func (s *Meta_directiveContext) Meta_flag() IMeta_flagContext

+ func (s *Meta_directiveContext) Meta_info() IMeta_infoContext

+ func (s *Meta_directiveContext) Meta_param() IMeta_paramContext

+ func (s *Meta_directiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Meta_flagContext struct

+ func NewEmptyMeta_flagContext() *Meta_flagContext

+ func NewMeta_flagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meta_flagContext

+ func (*Meta_flagContext) IsMeta_flagContext()

+ func (s *Meta_flagContext) ASSIGN() antlr.TerminalNode

+ func (s *Meta_flagContext) CCURLY() antlr.TerminalNode

+ func (s *Meta_flagContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Meta_flagContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Meta_flagContext) Expr() IExprContext

+ func (s *Meta_flagContext) GetParser() antlr.Parser

+ func (s *Meta_flagContext) GetRuleContext() antlr.RuleContext

+ func (s *Meta_flagContext) ID() antlr.TerminalNode

+ func (s *Meta_flagContext) M_FLAG() antlr.TerminalNode

+ func (s *Meta_flagContext) Meta_attribs() IMeta_attribsContext

+ func (s *Meta_flagContext) OCURLY() antlr.TerminalNode

+ func (s *Meta_flagContext) SEMICOLON() antlr.TerminalNode

+ func (s *Meta_flagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Meta_infoContext struct

+ func NewEmptyMeta_infoContext() *Meta_infoContext

+ func NewMeta_infoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meta_infoContext

+ func (*Meta_infoContext) IsMeta_infoContext()

+ func (s *Meta_infoContext) CCURLY() antlr.TerminalNode

+ func (s *Meta_infoContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Meta_infoContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Meta_infoContext) GetParser() antlr.Parser

+ func (s *Meta_infoContext) GetRuleContext() antlr.RuleContext

+ func (s *Meta_infoContext) M_INFO() antlr.TerminalNode

+ func (s *Meta_infoContext) Meta_attribs() IMeta_attribsContext

+ func (s *Meta_infoContext) OCURLY() antlr.TerminalNode

+ func (s *Meta_infoContext) SEMICOLON() antlr.TerminalNode

+ func (s *Meta_infoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Meta_literalContext struct

+ func NewEmptyMeta_literalContext() *Meta_literalContext

+ func NewMeta_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meta_literalContext

+ func (*Meta_literalContext) IsMeta_literalContext()

+ func (s *Meta_literalContext) CHAR() antlr.TerminalNode

+ func (s *Meta_literalContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Meta_literalContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Meta_literalContext) FALSE() antlr.TerminalNode

+ func (s *Meta_literalContext) GetParser() antlr.Parser

+ func (s *Meta_literalContext) GetRuleContext() antlr.RuleContext

+ func (s *Meta_literalContext) GetVal() antlr.Token

+ func (s *Meta_literalContext) NIL() antlr.TerminalNode

+ func (s *Meta_literalContext) NUMBER() antlr.TerminalNode

+ func (s *Meta_literalContext) STRING() antlr.TerminalNode

+ func (s *Meta_literalContext) SetVal(v antlr.Token)

+ func (s *Meta_literalContext) TRUE() antlr.TerminalNode

+ func (s *Meta_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Meta_paramContext struct

+ func NewEmptyMeta_paramContext() *Meta_paramContext

+ func NewMeta_paramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meta_paramContext

+ func (*Meta_paramContext) IsMeta_paramContext()

+ func (s *Meta_paramContext) ASSIGN() antlr.TerminalNode

+ func (s *Meta_paramContext) CCURLY() antlr.TerminalNode

+ func (s *Meta_paramContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Meta_paramContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Meta_paramContext) Expr() IExprContext

+ func (s *Meta_paramContext) GetParser() antlr.Parser

+ func (s *Meta_paramContext) GetRuleContext() antlr.RuleContext

+ func (s *Meta_paramContext) ID() antlr.TerminalNode

+ func (s *Meta_paramContext) M_PARAM() antlr.TerminalNode

+ func (s *Meta_paramContext) Meta_attribs() IMeta_attribsContext

+ func (s *Meta_paramContext) OCURLY() antlr.TerminalNode

+ func (s *Meta_paramContext) SEMICOLON() antlr.TerminalNode

+ func (s *Meta_paramContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ModuleContext struct

+ func NewEmptyModuleContext() *ModuleContext

+ func NewModuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleContext

+ func (*ModuleContext) IsModuleContext()

+ func (s *ModuleContext) AllImport_stmt() []IImport_stmtContext

+ func (s *ModuleContext) AllMeta_directive() []IMeta_directiveContext

+ func (s *ModuleContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ModuleContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ModuleContext) GetParser() antlr.Parser

+ func (s *ModuleContext) GetRuleContext() antlr.RuleContext

+ func (s *ModuleContext) Import_stmt(i int) IImport_stmtContext

+ func (s *ModuleContext) Meta_directive(i int) IMeta_directiveContext

+ func (s *ModuleContext) Stmts() IStmtsContext

+ func (s *ModuleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type NitroLexer struct

+ func NewNitroLexer(input antlr.CharStream) *NitroLexer

+ type NitroParser struct

+ func NewNitroParser(input antlr.TokenStream) *NitroParser

+ func (p *NitroParser) Arg_list() (localctx IArg_listContext)

+ func (p *NitroParser) Array_elem() (localctx IArray_elemContext)

+ func (p *NitroParser) Array_elems() (localctx IArray_elemsContext)

+ func (p *NitroParser) Array_elif() (localctx IArray_elifContext)

+ func (p *NitroParser) Array_else() (localctx IArray_elseContext)

+ func (p *NitroParser) Array_for() (localctx IArray_forContext)

+ func (p *NitroParser) Array_if() (localctx IArray_ifContext)

+ func (p *NitroParser) Array_literal() (localctx IArray_literalContext)

+ func (p *NitroParser) Assignment_lvalues() (localctx IAssignment_lvaluesContext)

+ func (p *NitroParser) Assignment_stmt() (localctx IAssignment_stmtContext)

+ func (p *NitroParser) Binary_expr() (localctx IBinary_exprContext)

+ func (p *NitroParser) Binary_expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *NitroParser) Break_stmt() (localctx IBreak_stmtContext)

+ func (p *NitroParser) Continue_stmt() (localctx IContinue_stmtContext)

+ func (p *NitroParser) Defer_stmt() (localctx IDefer_stmtContext)

+ func (p *NitroParser) Expr() (localctx IExprContext)

+ func (p *NitroParser) Expr2() (localctx IExpr2Context)

+ func (p *NitroParser) Expr3() (localctx IExpr3Context)

+ func (p *NitroParser) Expr3_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *NitroParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *NitroParser) For_stmt() (localctx IFor_stmtContext)

+ func (p *NitroParser) For_vars() (localctx IFor_varsContext)

+ func (p *NitroParser) Func_stmt() (localctx IFunc_stmtContext)

+ func (p *NitroParser) Id_or_keyword() (localctx IId_or_keywordContext)

+ func (p *NitroParser) If_elif() (localctx IIf_elifContext)

+ func (p *NitroParser) If_else() (localctx IIf_elseContext)

+ func (p *NitroParser) If_stmt() (localctx IIf_stmtContext)

+ func (p *NitroParser) Import_stmt() (localctx IImport_stmtContext)

+ func (p *NitroParser) Lambda_expr() (localctx ILambda_exprContext)

+ func (p *NitroParser) Lvalue_expr() (localctx ILvalue_exprContext)

+ func (p *NitroParser) Meta_attrib() (localctx IMeta_attribContext)

+ func (p *NitroParser) Meta_attribs() (localctx IMeta_attribsContext)

+ func (p *NitroParser) Meta_directive() (localctx IMeta_directiveContext)

+ func (p *NitroParser) Meta_flag() (localctx IMeta_flagContext)

+ func (p *NitroParser) Meta_info() (localctx IMeta_infoContext)

+ func (p *NitroParser) Meta_literal() (localctx IMeta_literalContext)

+ func (p *NitroParser) Meta_param() (localctx IMeta_paramContext)

+ func (p *NitroParser) Module() (localctx IModuleContext)

+ func (p *NitroParser) Object_elif() (localctx IObject_elifContext)

+ func (p *NitroParser) Object_else() (localctx IObject_elseContext)

+ func (p *NitroParser) Object_field() (localctx IObject_fieldContext)

+ func (p *NitroParser) Object_fields() (localctx IObject_fieldsContext)

+ func (p *NitroParser) Object_for() (localctx IObject_forContext)

+ func (p *NitroParser) Object_if() (localctx IObject_ifContext)

+ func (p *NitroParser) Object_literal() (localctx IObject_literalContext)

+ func (p *NitroParser) Param_list() (localctx IParam_listContext)

+ func (p *NitroParser) Primary_expr() (localctx IPrimary_exprContext)

+ func (p *NitroParser) Primary_expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *NitroParser) Return_stmt() (localctx IReturn_stmtContext)

+ func (p *NitroParser) Rvalues() (localctx IRvaluesContext)

+ func (p *NitroParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *NitroParser) Short_lambda_expr() (localctx IShort_lambda_exprContext)

+ func (p *NitroParser) Simple_literal() (localctx ISimple_literalContext)

+ func (p *NitroParser) Start() (localctx IStartContext)

+ func (p *NitroParser) Stmt() (localctx IStmtContext)

+ func (p *NitroParser) Stmt_list() (localctx IStmt_listContext)

+ func (p *NitroParser) Stmts() (localctx IStmtsContext)

+ func (p *NitroParser) Throw_stmt() (localctx IThrow_stmtContext)

+ func (p *NitroParser) Try_catch_stmt() (localctx ITry_catch_stmtContext)

+ func (p *NitroParser) Unary_expr() (localctx IUnary_exprContext)

+ func (p *NitroParser) Var_decl_stmt() (localctx IVar_decl_stmtContext)

+ func (p *NitroParser) Var_decl_vars() (localctx IVar_decl_varsContext)

+ func (p *NitroParser) While_stmt() (localctx IWhile_stmtContext)

+ func (p *NitroParser) Yield_stmt() (localctx IYield_stmtContext)

+ type NitroParserListener interface

+ EnterArg_list func(c *Arg_listContext)

+ EnterArray_elem func(c *Array_elemContext)

+ EnterArray_elems func(c *Array_elemsContext)

+ EnterArray_elif func(c *Array_elifContext)

+ EnterArray_else func(c *Array_elseContext)

+ EnterArray_for func(c *Array_forContext)

+ EnterArray_if func(c *Array_ifContext)

+ EnterArray_literal func(c *Array_literalContext)

+ EnterAssignment_lvalues func(c *Assignment_lvaluesContext)

+ EnterAssignment_stmt func(c *Assignment_stmtContext)

+ EnterBinary_expr func(c *Binary_exprContext)

+ EnterBreak_stmt func(c *Break_stmtContext)

+ EnterContinue_stmt func(c *Continue_stmtContext)

+ EnterDefer_stmt func(c *Defer_stmtContext)

+ EnterExpr func(c *ExprContext)

+ EnterExpr2 func(c *Expr2Context)

+ EnterExpr3 func(c *Expr3Context)

+ EnterFor_stmt func(c *For_stmtContext)

+ EnterFor_vars func(c *For_varsContext)

+ EnterFunc_stmt func(c *Func_stmtContext)

+ EnterId_or_keyword func(c *Id_or_keywordContext)

+ EnterIf_elif func(c *If_elifContext)

+ EnterIf_else func(c *If_elseContext)

+ EnterIf_stmt func(c *If_stmtContext)

+ EnterImport_stmt func(c *Import_stmtContext)

+ EnterLambda_expr func(c *Lambda_exprContext)

+ EnterLvalue_expr_index func(c *Lvalue_expr_indexContext)

+ EnterLvalue_expr_member_access func(c *Lvalue_expr_member_accessContext)

+ EnterLvalue_expr_simple_ref func(c *Lvalue_expr_simple_refContext)

+ EnterMeta_attrib func(c *Meta_attribContext)

+ EnterMeta_attribs func(c *Meta_attribsContext)

+ EnterMeta_directive func(c *Meta_directiveContext)

+ EnterMeta_flag func(c *Meta_flagContext)

+ EnterMeta_info func(c *Meta_infoContext)

+ EnterMeta_literal func(c *Meta_literalContext)

+ EnterMeta_param func(c *Meta_paramContext)

+ EnterModule func(c *ModuleContext)

+ EnterObject_elif func(c *Object_elifContext)

+ EnterObject_else func(c *Object_elseContext)

+ EnterObject_field_expansion func(c *Object_field_expansionContext)

+ EnterObject_field_expr_key func(c *Object_field_expr_keyContext)

+ EnterObject_field_for func(c *Object_field_forContext)

+ EnterObject_field_id_key func(c *Object_field_id_keyContext)

+ EnterObject_field_if func(c *Object_field_ifContext)

+ EnterObject_fields func(c *Object_fieldsContext)

+ EnterObject_for func(c *Object_forContext)

+ EnterObject_if func(c *Object_ifContext)

+ EnterObject_literal func(c *Object_literalContext)

+ EnterParam_list func(c *Param_listContext)

+ EnterPrimary_expr_array func(c *Primary_expr_arrayContext)

+ EnterPrimary_expr_call func(c *Primary_expr_callContext)

+ EnterPrimary_expr_index func(c *Primary_expr_indexContext)

+ EnterPrimary_expr_lambda func(c *Primary_expr_lambdaContext)

+ EnterPrimary_expr_literal func(c *Primary_expr_literalContext)

+ EnterPrimary_expr_member_access func(c *Primary_expr_member_accessContext)

+ EnterPrimary_expr_object func(c *Primary_expr_objectContext)

+ EnterPrimary_expr_parenthesis func(c *Primary_expr_parenthesisContext)

+ EnterPrimary_expr_regex func(c *Primary_expr_regexContext)

+ EnterPrimary_expr_simple_ref func(c *Primary_expr_simple_refContext)

+ EnterPrimary_expr_slice func(c *Primary_expr_sliceContext)

+ EnterReturn_stmt func(c *Return_stmtContext)

+ EnterRvalues func(c *RvaluesContext)

+ EnterShort_lambda_expr func(c *Short_lambda_exprContext)

+ EnterSimple_literal func(c *Simple_literalContext)

+ EnterStart func(c *StartContext)

+ EnterStmt_assignment func(c *Stmt_assignmentContext)

+ EnterStmt_break func(c *Stmt_breakContext)

+ EnterStmt_continue func(c *Stmt_continueContext)

+ EnterStmt_defer func(c *Stmt_deferContext)

+ EnterStmt_expr func(c *Stmt_exprContext)

+ EnterStmt_for func(c *Stmt_forContext)

+ EnterStmt_func func(c *Stmt_funcContext)

+ EnterStmt_if func(c *Stmt_ifContext)

+ EnterStmt_list func(c *Stmt_listContext)

+ EnterStmt_return func(c *Stmt_returnContext)

+ EnterStmt_throw func(c *Stmt_throwContext)

+ EnterStmt_try_catch func(c *Stmt_try_catchContext)

+ EnterStmt_var_dec func(c *Stmt_var_decContext)

+ EnterStmt_while func(c *Stmt_whileContext)

+ EnterStmt_yield func(c *Stmt_yieldContext)

+ EnterStmts func(c *StmtsContext)

+ EnterThrow_stmt func(c *Throw_stmtContext)

+ EnterTry_catch_stmt func(c *Try_catch_stmtContext)

+ EnterUnary_expr func(c *Unary_exprContext)

+ EnterVar_decl_stmt func(c *Var_decl_stmtContext)

+ EnterVar_decl_vars func(c *Var_decl_varsContext)

+ EnterWhile_stmt func(c *While_stmtContext)

+ EnterYield_stmt func(c *Yield_stmtContext)

+ ExitArg_list func(c *Arg_listContext)

+ ExitArray_elem func(c *Array_elemContext)

+ ExitArray_elems func(c *Array_elemsContext)

+ ExitArray_elif func(c *Array_elifContext)

+ ExitArray_else func(c *Array_elseContext)

+ ExitArray_for func(c *Array_forContext)

+ ExitArray_if func(c *Array_ifContext)

+ ExitArray_literal func(c *Array_literalContext)

+ ExitAssignment_lvalues func(c *Assignment_lvaluesContext)

+ ExitAssignment_stmt func(c *Assignment_stmtContext)

+ ExitBinary_expr func(c *Binary_exprContext)

+ ExitBreak_stmt func(c *Break_stmtContext)

+ ExitContinue_stmt func(c *Continue_stmtContext)

+ ExitDefer_stmt func(c *Defer_stmtContext)

+ ExitExpr func(c *ExprContext)

+ ExitExpr2 func(c *Expr2Context)

+ ExitExpr3 func(c *Expr3Context)

+ ExitFor_stmt func(c *For_stmtContext)

+ ExitFor_vars func(c *For_varsContext)

+ ExitFunc_stmt func(c *Func_stmtContext)

+ ExitId_or_keyword func(c *Id_or_keywordContext)

+ ExitIf_elif func(c *If_elifContext)

+ ExitIf_else func(c *If_elseContext)

+ ExitIf_stmt func(c *If_stmtContext)

+ ExitImport_stmt func(c *Import_stmtContext)

+ ExitLambda_expr func(c *Lambda_exprContext)

+ ExitLvalue_expr_index func(c *Lvalue_expr_indexContext)

+ ExitLvalue_expr_member_access func(c *Lvalue_expr_member_accessContext)

+ ExitLvalue_expr_simple_ref func(c *Lvalue_expr_simple_refContext)

+ ExitMeta_attrib func(c *Meta_attribContext)

+ ExitMeta_attribs func(c *Meta_attribsContext)

+ ExitMeta_directive func(c *Meta_directiveContext)

+ ExitMeta_flag func(c *Meta_flagContext)

+ ExitMeta_info func(c *Meta_infoContext)

+ ExitMeta_literal func(c *Meta_literalContext)

+ ExitMeta_param func(c *Meta_paramContext)

+ ExitModule func(c *ModuleContext)

+ ExitObject_elif func(c *Object_elifContext)

+ ExitObject_else func(c *Object_elseContext)

+ ExitObject_field_expansion func(c *Object_field_expansionContext)

+ ExitObject_field_expr_key func(c *Object_field_expr_keyContext)

+ ExitObject_field_for func(c *Object_field_forContext)

+ ExitObject_field_id_key func(c *Object_field_id_keyContext)

+ ExitObject_field_if func(c *Object_field_ifContext)

+ ExitObject_fields func(c *Object_fieldsContext)

+ ExitObject_for func(c *Object_forContext)

+ ExitObject_if func(c *Object_ifContext)

+ ExitObject_literal func(c *Object_literalContext)

+ ExitParam_list func(c *Param_listContext)

+ ExitPrimary_expr_array func(c *Primary_expr_arrayContext)

+ ExitPrimary_expr_call func(c *Primary_expr_callContext)

+ ExitPrimary_expr_index func(c *Primary_expr_indexContext)

+ ExitPrimary_expr_lambda func(c *Primary_expr_lambdaContext)

+ ExitPrimary_expr_literal func(c *Primary_expr_literalContext)

+ ExitPrimary_expr_member_access func(c *Primary_expr_member_accessContext)

+ ExitPrimary_expr_object func(c *Primary_expr_objectContext)

+ ExitPrimary_expr_parenthesis func(c *Primary_expr_parenthesisContext)

+ ExitPrimary_expr_regex func(c *Primary_expr_regexContext)

+ ExitPrimary_expr_simple_ref func(c *Primary_expr_simple_refContext)

+ ExitPrimary_expr_slice func(c *Primary_expr_sliceContext)

+ ExitReturn_stmt func(c *Return_stmtContext)

+ ExitRvalues func(c *RvaluesContext)

+ ExitShort_lambda_expr func(c *Short_lambda_exprContext)

+ ExitSimple_literal func(c *Simple_literalContext)

+ ExitStart func(c *StartContext)

+ ExitStmt_assignment func(c *Stmt_assignmentContext)

+ ExitStmt_break func(c *Stmt_breakContext)

+ ExitStmt_continue func(c *Stmt_continueContext)

+ ExitStmt_defer func(c *Stmt_deferContext)

+ ExitStmt_expr func(c *Stmt_exprContext)

+ ExitStmt_for func(c *Stmt_forContext)

+ ExitStmt_func func(c *Stmt_funcContext)

+ ExitStmt_if func(c *Stmt_ifContext)

+ ExitStmt_list func(c *Stmt_listContext)

+ ExitStmt_return func(c *Stmt_returnContext)

+ ExitStmt_throw func(c *Stmt_throwContext)

+ ExitStmt_try_catch func(c *Stmt_try_catchContext)

+ ExitStmt_var_dec func(c *Stmt_var_decContext)

+ ExitStmt_while func(c *Stmt_whileContext)

+ ExitStmt_yield func(c *Stmt_yieldContext)

+ ExitStmts func(c *StmtsContext)

+ ExitThrow_stmt func(c *Throw_stmtContext)

+ ExitTry_catch_stmt func(c *Try_catch_stmtContext)

+ ExitUnary_expr func(c *Unary_exprContext)

+ ExitVar_decl_stmt func(c *Var_decl_stmtContext)

+ ExitVar_decl_vars func(c *Var_decl_varsContext)

+ ExitWhile_stmt func(c *While_stmtContext)

+ ExitYield_stmt func(c *Yield_stmtContext)

+ type Object_elifContext struct

+ func NewEmptyObject_elifContext() *Object_elifContext

+ func NewObject_elifContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_elifContext

+ func (*Object_elifContext) IsObject_elifContext()

+ func (s *Object_elifContext) CCURLY() antlr.TerminalNode

+ func (s *Object_elifContext) ELSE() antlr.TerminalNode

+ func (s *Object_elifContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_elifContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_elifContext) Expr() IExprContext

+ func (s *Object_elifContext) GetParser() antlr.Parser

+ func (s *Object_elifContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_elifContext) IF() antlr.TerminalNode

+ func (s *Object_elifContext) OCURLY() antlr.TerminalNode

+ func (s *Object_elifContext) Object_fields() IObject_fieldsContext

+ func (s *Object_elifContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Object_elseContext struct

+ func NewEmptyObject_elseContext() *Object_elseContext

+ func NewObject_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_elseContext

+ func (*Object_elseContext) IsObject_elseContext()

+ func (s *Object_elseContext) CCURLY() antlr.TerminalNode

+ func (s *Object_elseContext) ELSE() antlr.TerminalNode

+ func (s *Object_elseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_elseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_elseContext) GetParser() antlr.Parser

+ func (s *Object_elseContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_elseContext) OCURLY() antlr.TerminalNode

+ func (s *Object_elseContext) Object_fields() IObject_fieldsContext

+ func (s *Object_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Object_fieldContext struct

+ func NewEmptyObject_fieldContext() *Object_fieldContext

+ func NewObject_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_fieldContext

+ func (*Object_fieldContext) IsObject_fieldContext()

+ func (s *Object_fieldContext) CopyFrom(ctx *Object_fieldContext)

+ func (s *Object_fieldContext) GetParser() antlr.Parser

+ func (s *Object_fieldContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Object_field_expansionContext struct

+ func NewObject_field_expansionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Object_field_expansionContext

+ func (s *Object_field_expansionContext) EXPAND() antlr.TerminalNode

+ func (s *Object_field_expansionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_expansionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_expansionContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_field_expansionContext) Primary_expr() IPrimary_exprContext

+ type Object_field_expr_keyContext struct

+ func NewObject_field_expr_keyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Object_field_expr_keyContext

+ func (s *Object_field_expr_keyContext) AllExpr() []IExprContext

+ func (s *Object_field_expr_keyContext) CBRACKET() antlr.TerminalNode

+ func (s *Object_field_expr_keyContext) COLON() antlr.TerminalNode

+ func (s *Object_field_expr_keyContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_expr_keyContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_expr_keyContext) Expr(i int) IExprContext

+ func (s *Object_field_expr_keyContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_field_expr_keyContext) OBRACKET() antlr.TerminalNode

+ type Object_field_forContext struct

+ func NewObject_field_forContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Object_field_forContext

+ func (s *Object_field_forContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_forContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_forContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_field_forContext) Object_for() IObject_forContext

+ type Object_field_id_keyContext struct

+ func NewObject_field_id_keyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Object_field_id_keyContext

+ func (s *Object_field_id_keyContext) COLON() antlr.TerminalNode

+ func (s *Object_field_id_keyContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_id_keyContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_id_keyContext) Expr() IExprContext

+ func (s *Object_field_id_keyContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_field_id_keyContext) Id_or_keyword() IId_or_keywordContext

+ type Object_field_ifContext struct

+ func NewObject_field_ifContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Object_field_ifContext

+ func (s *Object_field_ifContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_ifContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_field_ifContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_field_ifContext) Object_if() IObject_ifContext

+ type Object_fieldsContext struct

+ func NewEmptyObject_fieldsContext() *Object_fieldsContext

+ func NewObject_fieldsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_fieldsContext

+ func (*Object_fieldsContext) IsObject_fieldsContext()

+ func (s *Object_fieldsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Object_fieldsContext) AllObject_field() []IObject_fieldContext

+ func (s *Object_fieldsContext) AllSEMICOLON() []antlr.TerminalNode

+ func (s *Object_fieldsContext) COMMA(i int) antlr.TerminalNode

+ func (s *Object_fieldsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_fieldsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_fieldsContext) GetParser() antlr.Parser

+ func (s *Object_fieldsContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_fieldsContext) Object_field(i int) IObject_fieldContext

+ func (s *Object_fieldsContext) SEMICOLON(i int) antlr.TerminalNode

+ func (s *Object_fieldsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Object_forContext struct

+ func NewEmptyObject_forContext() *Object_forContext

+ func NewObject_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_forContext

+ func (*Object_forContext) IsObject_forContext()

+ func (s *Object_forContext) CCURLY() antlr.TerminalNode

+ func (s *Object_forContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_forContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_forContext) Expr() IExprContext

+ func (s *Object_forContext) FOR() antlr.TerminalNode

+ func (s *Object_forContext) For_vars() IFor_varsContext

+ func (s *Object_forContext) GetParser() antlr.Parser

+ func (s *Object_forContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_forContext) ID() antlr.TerminalNode

+ func (s *Object_forContext) OCURLY() antlr.TerminalNode

+ func (s *Object_forContext) Object_fields() IObject_fieldsContext

+ func (s *Object_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Object_ifContext struct

+ func NewEmptyObject_ifContext() *Object_ifContext

+ func NewObject_ifContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_ifContext

+ func (*Object_ifContext) IsObject_ifContext()

+ func (s *Object_ifContext) AllObject_elif() []IObject_elifContext

+ func (s *Object_ifContext) CCURLY() antlr.TerminalNode

+ func (s *Object_ifContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_ifContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_ifContext) Expr() IExprContext

+ func (s *Object_ifContext) GetParser() antlr.Parser

+ func (s *Object_ifContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_ifContext) IF() antlr.TerminalNode

+ func (s *Object_ifContext) OCURLY() antlr.TerminalNode

+ func (s *Object_ifContext) Object_elif(i int) IObject_elifContext

+ func (s *Object_ifContext) Object_else() IObject_elseContext

+ func (s *Object_ifContext) Object_fields() IObject_fieldsContext

+ func (s *Object_ifContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Object_literalContext struct

+ func NewEmptyObject_literalContext() *Object_literalContext

+ func NewObject_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_literalContext

+ func (*Object_literalContext) IsObject_literalContext()

+ func (s *Object_literalContext) CCURLY() antlr.TerminalNode

+ func (s *Object_literalContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Object_literalContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Object_literalContext) GetParser() antlr.Parser

+ func (s *Object_literalContext) GetRuleContext() antlr.RuleContext

+ func (s *Object_literalContext) OCURLY() antlr.TerminalNode

+ func (s *Object_literalContext) Object_fields() IObject_fieldsContext

+ func (s *Object_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Param_listContext struct

+ func NewEmptyParam_listContext() *Param_listContext

+ func NewParam_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Param_listContext

+ func (*Param_listContext) IsParam_listContext()

+ func (s *Param_listContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Param_listContext) AllID() []antlr.TerminalNode

+ func (s *Param_listContext) COMMA(i int) antlr.TerminalNode

+ func (s *Param_listContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Param_listContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Param_listContext) GetParser() antlr.Parser

+ func (s *Param_listContext) GetRuleContext() antlr.RuleContext

+ func (s *Param_listContext) ID(i int) antlr.TerminalNode

+ func (s *Param_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Primary_exprContext struct

+ func NewEmptyPrimary_exprContext() *Primary_exprContext

+ func NewPrimary_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_exprContext

+ func (*Primary_exprContext) IsPrimary_exprContext()

+ func (s *Primary_exprContext) CopyFrom(ctx *Primary_exprContext)

+ func (s *Primary_exprContext) GetParser() antlr.Parser

+ func (s *Primary_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Primary_expr_arrayContext struct

+ func NewPrimary_expr_arrayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_arrayContext

+ func (s *Primary_expr_arrayContext) Array_literal() IArray_literalContext

+ func (s *Primary_expr_arrayContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_arrayContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_arrayContext) GetRuleContext() antlr.RuleContext

+ type Primary_expr_callContext struct

+ func NewPrimary_expr_callContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_callContext

+ func (s *Primary_expr_callContext) Arg_list() IArg_listContext

+ func (s *Primary_expr_callContext) CPAREN() antlr.TerminalNode

+ func (s *Primary_expr_callContext) EXPAND() antlr.TerminalNode

+ func (s *Primary_expr_callContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_callContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_callContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_callContext) OPAREN() antlr.TerminalNode

+ func (s *Primary_expr_callContext) Primary_expr() IPrimary_exprContext

+ type Primary_expr_indexContext struct

+ func NewPrimary_expr_indexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_indexContext

+ func (s *Primary_expr_indexContext) CBRACKET() antlr.TerminalNode

+ func (s *Primary_expr_indexContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_indexContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_indexContext) Expr() IExprContext

+ func (s *Primary_expr_indexContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_indexContext) OBRACKET() antlr.TerminalNode

+ func (s *Primary_expr_indexContext) Primary_expr() IPrimary_exprContext

+ type Primary_expr_lambdaContext struct

+ func NewPrimary_expr_lambdaContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_lambdaContext

+ func (s *Primary_expr_lambdaContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_lambdaContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_lambdaContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_lambdaContext) Lambda_expr() ILambda_exprContext

+ type Primary_expr_literalContext struct

+ func NewPrimary_expr_literalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_literalContext

+ func (s *Primary_expr_literalContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_literalContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_literalContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_literalContext) Simple_literal() ISimple_literalContext

+ type Primary_expr_member_accessContext struct

+ func NewPrimary_expr_member_accessContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_member_accessContext

+ func (s *Primary_expr_member_accessContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_member_accessContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_member_accessContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_member_accessContext) ID() antlr.TerminalNode

+ func (s *Primary_expr_member_accessContext) PERIOD() antlr.TerminalNode

+ func (s *Primary_expr_member_accessContext) Primary_expr() IPrimary_exprContext

+ type Primary_expr_objectContext struct

+ func NewPrimary_expr_objectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_objectContext

+ func (s *Primary_expr_objectContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_objectContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_objectContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_objectContext) Object_literal() IObject_literalContext

+ type Primary_expr_parenthesisContext struct

+ func NewPrimary_expr_parenthesisContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_parenthesisContext

+ func (s *Primary_expr_parenthesisContext) CPAREN() antlr.TerminalNode

+ func (s *Primary_expr_parenthesisContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_parenthesisContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_parenthesisContext) Expr() IExprContext

+ func (s *Primary_expr_parenthesisContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_parenthesisContext) OPAREN() antlr.TerminalNode

+ type Primary_expr_regexContext struct

+ func NewPrimary_expr_regexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_regexContext

+ func (s *Primary_expr_regexContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_regexContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_regexContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_regexContext) REGEX() antlr.TerminalNode

+ type Primary_expr_simple_refContext struct

+ func NewPrimary_expr_simple_refContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_simple_refContext

+ func (s *Primary_expr_simple_refContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_simple_refContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_simple_refContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_simple_refContext) ID() antlr.TerminalNode

+ type Primary_expr_sliceContext struct

+ func NewPrimary_expr_sliceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Primary_expr_sliceContext

+ func (s *Primary_expr_sliceContext) AllExpr() []IExprContext

+ func (s *Primary_expr_sliceContext) CBRACKET() antlr.TerminalNode

+ func (s *Primary_expr_sliceContext) COLON() antlr.TerminalNode

+ func (s *Primary_expr_sliceContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_sliceContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Primary_expr_sliceContext) Expr(i int) IExprContext

+ func (s *Primary_expr_sliceContext) GetB() IExprContext

+ func (s *Primary_expr_sliceContext) GetE() IExprContext

+ func (s *Primary_expr_sliceContext) GetRuleContext() antlr.RuleContext

+ func (s *Primary_expr_sliceContext) OBRACKET() antlr.TerminalNode

+ func (s *Primary_expr_sliceContext) Primary_expr() IPrimary_exprContext

+ func (s *Primary_expr_sliceContext) SetB(v IExprContext)

+ func (s *Primary_expr_sliceContext) SetE(v IExprContext)

+ type Return_stmtContext struct

+ func NewEmptyReturn_stmtContext() *Return_stmtContext

+ func NewReturn_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Return_stmtContext

+ func (*Return_stmtContext) IsReturn_stmtContext()

+ func (s *Return_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Return_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Return_stmtContext) GetParser() antlr.Parser

+ func (s *Return_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Return_stmtContext) RETURN() antlr.TerminalNode

+ func (s *Return_stmtContext) Rvalues() IRvaluesContext

+ func (s *Return_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RvaluesContext struct

+ func NewEmptyRvaluesContext() *RvaluesContext

+ func NewRvaluesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RvaluesContext

+ func (*RvaluesContext) IsRvaluesContext()

+ func (s *RvaluesContext) AllCOMMA() []antlr.TerminalNode

+ func (s *RvaluesContext) AllExpr() []IExprContext

+ func (s *RvaluesContext) COMMA(i int) antlr.TerminalNode

+ func (s *RvaluesContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RvaluesContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RvaluesContext) Expr(i int) IExprContext

+ func (s *RvaluesContext) GetParser() antlr.Parser

+ func (s *RvaluesContext) GetRuleContext() antlr.RuleContext

+ func (s *RvaluesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Short_lambda_exprContext struct

+ func NewEmptyShort_lambda_exprContext() *Short_lambda_exprContext

+ func NewShort_lambda_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Short_lambda_exprContext

+ func (*Short_lambda_exprContext) IsShort_lambda_exprContext()

+ func (s *Short_lambda_exprContext) ARROW() antlr.TerminalNode

+ func (s *Short_lambda_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Short_lambda_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Short_lambda_exprContext) Expr3() IExpr3Context

+ func (s *Short_lambda_exprContext) GetParser() antlr.Parser

+ func (s *Short_lambda_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Short_lambda_exprContext) LAMBDA() antlr.TerminalNode

+ func (s *Short_lambda_exprContext) Param_list() IParam_listContext

+ func (s *Short_lambda_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Simple_literalContext struct

+ func NewEmptySimple_literalContext() *Simple_literalContext

+ func NewSimple_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_literalContext

+ func (*Simple_literalContext) IsSimple_literalContext()

+ func (s *Simple_literalContext) CHAR() antlr.TerminalNode

+ func (s *Simple_literalContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Simple_literalContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Simple_literalContext) FALSE() antlr.TerminalNode

+ func (s *Simple_literalContext) GetParser() antlr.Parser

+ func (s *Simple_literalContext) GetRuleContext() antlr.RuleContext

+ func (s *Simple_literalContext) GetVal() antlr.Token

+ func (s *Simple_literalContext) NIL() antlr.TerminalNode

+ func (s *Simple_literalContext) NUMBER() antlr.TerminalNode

+ func (s *Simple_literalContext) STRING() antlr.TerminalNode

+ func (s *Simple_literalContext) SetVal(v antlr.Token)

+ func (s *Simple_literalContext) TRUE() antlr.TerminalNode

+ func (s *Simple_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type StartContext struct

+ func NewEmptyStartContext() *StartContext

+ func NewStartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartContext

+ func (*StartContext) IsStartContext()

+ func (s *StartContext) EOF() antlr.TerminalNode

+ func (s *StartContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *StartContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *StartContext) GetParser() antlr.Parser

+ func (s *StartContext) GetRuleContext() antlr.RuleContext

+ func (s *StartContext) Module() IModuleContext

+ func (s *StartContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type StmtContext struct

+ func NewEmptyStmtContext() *StmtContext

+ func NewStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtContext

+ func (*StmtContext) IsStmtContext()

+ func (s *StmtContext) CopyFrom(ctx *StmtContext)

+ func (s *StmtContext) GetParser() antlr.Parser

+ func (s *StmtContext) GetRuleContext() antlr.RuleContext

+ func (s *StmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Stmt_assignmentContext struct

+ func NewStmt_assignmentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_assignmentContext

+ func (s *Stmt_assignmentContext) Assignment_stmt() IAssignment_stmtContext

+ func (s *Stmt_assignmentContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_assignmentContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_assignmentContext) GetRuleContext() antlr.RuleContext

+ type Stmt_breakContext struct

+ func NewStmt_breakContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_breakContext

+ func (s *Stmt_breakContext) Break_stmt() IBreak_stmtContext

+ func (s *Stmt_breakContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_breakContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_breakContext) GetRuleContext() antlr.RuleContext

+ type Stmt_continueContext struct

+ func NewStmt_continueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_continueContext

+ func (s *Stmt_continueContext) Continue_stmt() IContinue_stmtContext

+ func (s *Stmt_continueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_continueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_continueContext) GetRuleContext() antlr.RuleContext

+ type Stmt_deferContext struct

+ func NewStmt_deferContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_deferContext

+ func (s *Stmt_deferContext) Defer_stmt() IDefer_stmtContext

+ func (s *Stmt_deferContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_deferContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_deferContext) GetRuleContext() antlr.RuleContext

+ type Stmt_exprContext struct

+ func NewStmt_exprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_exprContext

+ func (s *Stmt_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_exprContext) Expr() IExprContext

+ func (s *Stmt_exprContext) GetRuleContext() antlr.RuleContext

+ type Stmt_forContext struct

+ func NewStmt_forContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_forContext

+ func (s *Stmt_forContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_forContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_forContext) For_stmt() IFor_stmtContext

+ func (s *Stmt_forContext) GetRuleContext() antlr.RuleContext

+ type Stmt_funcContext struct

+ func NewStmt_funcContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_funcContext

+ func (s *Stmt_funcContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_funcContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_funcContext) Func_stmt() IFunc_stmtContext

+ func (s *Stmt_funcContext) GetRuleContext() antlr.RuleContext

+ type Stmt_ifContext struct

+ func NewStmt_ifContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_ifContext

+ func (s *Stmt_ifContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_ifContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_ifContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_ifContext) If_stmt() IIf_stmtContext

+ type Stmt_listContext struct

+ func NewEmptyStmt_listContext() *Stmt_listContext

+ func NewStmt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_listContext

+ func (*Stmt_listContext) IsStmt_listContext()

+ func (s *Stmt_listContext) AllSEMICOLON() []antlr.TerminalNode

+ func (s *Stmt_listContext) AllStmt() []IStmtContext

+ func (s *Stmt_listContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_listContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_listContext) GetParser() antlr.Parser

+ func (s *Stmt_listContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_listContext) SEMICOLON(i int) antlr.TerminalNode

+ func (s *Stmt_listContext) Stmt(i int) IStmtContext

+ func (s *Stmt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Stmt_returnContext struct

+ func NewStmt_returnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_returnContext

+ func (s *Stmt_returnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_returnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_returnContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_returnContext) Return_stmt() IReturn_stmtContext

+ type Stmt_throwContext struct

+ func NewStmt_throwContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_throwContext

+ func (s *Stmt_throwContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_throwContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_throwContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_throwContext) Throw_stmt() IThrow_stmtContext

+ type Stmt_try_catchContext struct

+ func NewStmt_try_catchContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_try_catchContext

+ func (s *Stmt_try_catchContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_try_catchContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_try_catchContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_try_catchContext) Try_catch_stmt() ITry_catch_stmtContext

+ type Stmt_var_decContext struct

+ func NewStmt_var_decContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_var_decContext

+ func (s *Stmt_var_decContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_var_decContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_var_decContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_var_decContext) Var_decl_stmt() IVar_decl_stmtContext

+ type Stmt_whileContext struct

+ func NewStmt_whileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_whileContext

+ func (s *Stmt_whileContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_whileContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_whileContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_whileContext) While_stmt() IWhile_stmtContext

+ type Stmt_yieldContext struct

+ func NewStmt_yieldContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Stmt_yieldContext

+ func (s *Stmt_yieldContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_yieldContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Stmt_yieldContext) GetRuleContext() antlr.RuleContext

+ func (s *Stmt_yieldContext) Yield_stmt() IYield_stmtContext

+ type StmtsContext struct

+ func NewEmptyStmtsContext() *StmtsContext

+ func NewStmtsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtsContext

+ func (*StmtsContext) IsStmtsContext()

+ func (s *StmtsContext) AllSEMICOLON() []antlr.TerminalNode

+ func (s *StmtsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *StmtsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *StmtsContext) GetParser() antlr.Parser

+ func (s *StmtsContext) GetRuleContext() antlr.RuleContext

+ func (s *StmtsContext) SEMICOLON(i int) antlr.TerminalNode

+ func (s *StmtsContext) Stmt_list() IStmt_listContext

+ func (s *StmtsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Throw_stmtContext struct

+ func NewEmptyThrow_stmtContext() *Throw_stmtContext

+ func NewThrow_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_stmtContext

+ func (*Throw_stmtContext) IsThrow_stmtContext()

+ func (s *Throw_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Throw_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Throw_stmtContext) Expr() IExprContext

+ func (s *Throw_stmtContext) GetParser() antlr.Parser

+ func (s *Throw_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Throw_stmtContext) THROW() antlr.TerminalNode

+ func (s *Throw_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Try_catch_stmtContext struct

+ func NewEmptyTry_catch_stmtContext() *Try_catch_stmtContext

+ func NewTry_catch_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Try_catch_stmtContext

+ func (*Try_catch_stmtContext) IsTry_catch_stmtContext()

+ func (s *Try_catch_stmtContext) AllCCURLY() []antlr.TerminalNode

+ func (s *Try_catch_stmtContext) AllOCURLY() []antlr.TerminalNode

+ func (s *Try_catch_stmtContext) AllStmts() []IStmtsContext

+ func (s *Try_catch_stmtContext) CATCH() antlr.TerminalNode

+ func (s *Try_catch_stmtContext) CCURLY(i int) antlr.TerminalNode

+ func (s *Try_catch_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Try_catch_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Try_catch_stmtContext) GetParser() antlr.Parser

+ func (s *Try_catch_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Try_catch_stmtContext) ID() antlr.TerminalNode

+ func (s *Try_catch_stmtContext) OCURLY(i int) antlr.TerminalNode

+ func (s *Try_catch_stmtContext) Stmts(i int) IStmtsContext

+ func (s *Try_catch_stmtContext) TRY() antlr.TerminalNode

+ func (s *Try_catch_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Unary_exprContext struct

+ func NewEmptyUnary_exprContext() *Unary_exprContext

+ func NewUnary_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_exprContext

+ func (*Unary_exprContext) IsUnary_exprContext()

+ func (s *Unary_exprContext) ADD() antlr.TerminalNode

+ func (s *Unary_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Unary_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Unary_exprContext) GetOp() antlr.Token

+ func (s *Unary_exprContext) GetParser() antlr.Parser

+ func (s *Unary_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Unary_exprContext) NOT() antlr.TerminalNode

+ func (s *Unary_exprContext) Primary_expr() IPrimary_exprContext

+ func (s *Unary_exprContext) SUB() antlr.TerminalNode

+ func (s *Unary_exprContext) SetOp(v antlr.Token)

+ func (s *Unary_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Unary_exprContext) Unary_expr() IUnary_exprContext

+ type Var_decl_stmtContext struct

+ func NewEmptyVar_decl_stmtContext() *Var_decl_stmtContext

+ func NewVar_decl_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_decl_stmtContext

+ func (*Var_decl_stmtContext) IsVar_decl_stmtContext()

+ func (s *Var_decl_stmtContext) ASSIGN() antlr.TerminalNode

+ func (s *Var_decl_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Var_decl_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Var_decl_stmtContext) GetParser() antlr.Parser

+ func (s *Var_decl_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Var_decl_stmtContext) Rvalues() IRvaluesContext

+ func (s *Var_decl_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Var_decl_stmtContext) VAR() antlr.TerminalNode

+ func (s *Var_decl_stmtContext) Var_decl_vars() IVar_decl_varsContext

+ type Var_decl_varsContext struct

+ func NewEmptyVar_decl_varsContext() *Var_decl_varsContext

+ func NewVar_decl_varsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_decl_varsContext

+ func (*Var_decl_varsContext) IsVar_decl_varsContext()

+ func (s *Var_decl_varsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Var_decl_varsContext) AllID() []antlr.TerminalNode

+ func (s *Var_decl_varsContext) COMMA(i int) antlr.TerminalNode

+ func (s *Var_decl_varsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Var_decl_varsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Var_decl_varsContext) GetParser() antlr.Parser

+ func (s *Var_decl_varsContext) GetRuleContext() antlr.RuleContext

+ func (s *Var_decl_varsContext) ID(i int) antlr.TerminalNode

+ func (s *Var_decl_varsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type While_stmtContext struct

+ func NewEmptyWhile_stmtContext() *While_stmtContext

+ func NewWhile_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *While_stmtContext

+ func (*While_stmtContext) IsWhile_stmtContext()

+ func (s *While_stmtContext) CCURLY() antlr.TerminalNode

+ func (s *While_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *While_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *While_stmtContext) Expr() IExprContext

+ func (s *While_stmtContext) GetParser() antlr.Parser

+ func (s *While_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *While_stmtContext) OCURLY() antlr.TerminalNode

+ func (s *While_stmtContext) Stmts() IStmtsContext

+ func (s *While_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *While_stmtContext) WHILE() antlr.TerminalNode

+ type Yield_stmtContext struct

+ func NewEmptyYield_stmtContext() *Yield_stmtContext

+ func NewYield_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Yield_stmtContext

+ func (*Yield_stmtContext) IsYield_stmtContext()

+ func (s *Yield_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Yield_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Yield_stmtContext) GetParser() antlr.Parser

+ func (s *Yield_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Yield_stmtContext) Rvalues() IRvaluesContext

+ func (s *Yield_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Yield_stmtContext) YIELD() antlr.TerminalNode

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL