parser

Documentation

Index

• Constants
• Variables
• func InitEmptyAliasNameContext(p *AliasNameContext)
• func InitEmptyAnonymousFunctionContext(p *AnonymousFunctionContext)
• func InitEmptyArgumentContext(p *ArgumentContext)
• func InitEmptyArgumentsContext(p *ArgumentsContext)
• func InitEmptyArrayElementContext(p *ArrayElementContext)
• func InitEmptyArrayLiteralContext(p *ArrayLiteralContext)
• func InitEmptyArrowFunctionBodyContext(p *ArrowFunctionBodyContext)
• func InitEmptyArrowFunctionParametersContext(p *ArrowFunctionParametersContext)
• func InitEmptyAssignableContext(p *AssignableContext)
• func InitEmptyAssignmentOperatorContext(p *AssignmentOperatorContext)
• func InitEmptyBigintLiteralContext(p *BigintLiteralContext)
• func InitEmptyBlockContext(p *BlockContext)
• func InitEmptyBreakStatementContext(p *BreakStatementContext)
• func InitEmptyCaseBlockContext(p *CaseBlockContext)
• func InitEmptyCaseClauseContext(p *CaseClauseContext)
• func InitEmptyCaseClausesContext(p *CaseClausesContext)
• func InitEmptyCatchProductionContext(p *CatchProductionContext)
• func InitEmptyClassDeclarationContext(p *ClassDeclarationContext)
• func InitEmptyClassElementContext(p *ClassElementContext)
• func InitEmptyClassElementNameContext(p *ClassElementNameContext)
• func InitEmptyClassTailContext(p *ClassTailContext)
• func InitEmptyContinueStatementContext(p *ContinueStatementContext)
• func InitEmptyDebuggerStatementContext(p *DebuggerStatementContext)
• func InitEmptyDeclarationContext(p *DeclarationContext)
• func InitEmptyDefaultClauseContext(p *DefaultClauseContext)
• func InitEmptyElementListContext(p *ElementListContext)
• func InitEmptyElseBlockContext(p *ElseBlockContext)
• func InitEmptyEmptyStatement_Context(p *EmptyStatement_Context)
• func InitEmptyEosContext(p *EosContext)
• func InitEmptyExportAliasNameContext(p *ExportAliasNameContext)
• func InitEmptyExportFromBlockContext(p *ExportFromBlockContext)
• func InitEmptyExportModuleItemsContext(p *ExportModuleItemsContext)
• func InitEmptyExportStatementContext(p *ExportStatementContext)
• func InitEmptyExpressionSequenceContext(p *ExpressionSequenceContext)
• func InitEmptyExpressionStatementContext(p *ExpressionStatementContext)
• func InitEmptyFieldDefinitionContext(p *FieldDefinitionContext)
• func InitEmptyFinallyProductionContext(p *FinallyProductionContext)
• func InitEmptyForFirstContext(p *ForFirstContext)
• func InitEmptyForSecondContext(p *ForSecondContext)
• func InitEmptyForThirdContext(p *ForThirdContext)
• func InitEmptyFormalParameterArgContext(p *FormalParameterArgContext)
• func InitEmptyFormalParameterListContext(p *FormalParameterListContext)
• func InitEmptyFunctionBodyContext(p *FunctionBodyContext)
• func InitEmptyFunctionDeclarationContext(p *FunctionDeclarationContext)
• func InitEmptyGetterContext(p *GetterContext)
• func InitEmptyIdentifierContext(p *IdentifierContext)
• func InitEmptyIdentifierNameContext(p *IdentifierNameContext)
• func InitEmptyIfStatementContext(p *IfStatementContext)
• func InitEmptyImportAliasNameContext(p *ImportAliasNameContext)
• func InitEmptyImportDefaultContext(p *ImportDefaultContext)
• func InitEmptyImportFromBlockContext(p *ImportFromBlockContext)
• func InitEmptyImportFromContext(p *ImportFromContext)
• func InitEmptyImportModuleItemsContext(p *ImportModuleItemsContext)
• func InitEmptyImportNamespaceContext(p *ImportNamespaceContext)
• func InitEmptyImportStatementContext(p *ImportStatementContext)
• func InitEmptyImportedBindingContext(p *ImportedBindingContext)
• func InitEmptyInitializerContext(p *InitializerContext)
• func InitEmptyIterationStatementContext(p *IterationStatementContext)
• func InitEmptyKeywordContext(p *KeywordContext)
• func InitEmptyLabelledStatementContext(p *LabelledStatementContext)
• func InitEmptyLastFormalParameterArgContext(p *LastFormalParameterArgContext)
• func InitEmptyLet_Context(p *Let_Context)
• func InitEmptyLiteralContext(p *LiteralContext)
• func InitEmptyMethodDefinitionContext(p *MethodDefinitionContext)
• func InitEmptyModuleExportNameContext(p *ModuleExportNameContext)
• func InitEmptyNumericLiteralContext(p *NumericLiteralContext)
• func InitEmptyObjectLiteralContext(p *ObjectLiteralContext)
• func InitEmptyPrivateIdentifierContext(p *PrivateIdentifierContext)
• func InitEmptyProgramContext(p *ProgramContext)
• func InitEmptyPropertyAssignmentContext(p *PropertyAssignmentContext)
• func InitEmptyPropertyNameContext(p *PropertyNameContext)
• func InitEmptyReservedWordContext(p *ReservedWordContext)
• func InitEmptyReturnStatementContext(p *ReturnStatementContext)
• func InitEmptySetterContext(p *SetterContext)
• func InitEmptySingleExpressionContext(p *SingleExpressionContext)
• func InitEmptySourceElementContext(p *SourceElementContext)
• func InitEmptySourceElementsContext(p *SourceElementsContext)
• func InitEmptyStatementContext(p *StatementContext)
• func InitEmptyStatementListContext(p *StatementListContext)
• func InitEmptySwitchStatementContext(p *SwitchStatementContext)
• func InitEmptyTemplateStringAtomContext(p *TemplateStringAtomContext)
• func InitEmptyTemplateStringLiteralContext(p *TemplateStringLiteralContext)
• func InitEmptyThrowStatementContext(p *ThrowStatementContext)
• func InitEmptyTryStatementContext(p *TryStatementContext)
• func InitEmptyVarModifierContext(p *VarModifierContext)
• func InitEmptyVariableDeclarationContext(p *VariableDeclarationContext)
• func InitEmptyVariableDeclarationListContext(p *VariableDeclarationListContext)
• func InitEmptyVariableStatementContext(p *VariableStatementContext)
• func InitEmptyWithStatementContext(p *WithStatementContext)
• func InitEmptyYieldStatementContext(p *YieldStatementContext)
• func JavaScriptLexerInit()
• func JavaScriptParserInit()
• type AdditiveExpressionContext
  • func NewAdditiveExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdditiveExpressionContext
  • func (s *AdditiveExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AdditiveExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *AdditiveExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *AdditiveExpressionContext) Minus() antlr.TerminalNode
  • func (s *AdditiveExpressionContext) Plus() antlr.TerminalNode
  • func (s *AdditiveExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type AliasNameContext
  • func NewAliasNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AliasNameContext
  • func NewEmptyAliasNameContext() *AliasNameContext
  • func (s *AliasNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AliasNameContext) AllIdentifierName() []IIdentifierNameContext
  • func (s *AliasNameContext) As() antlr.TerminalNode
  • func (s *AliasNameContext) GetParser() antlr.Parser
  • func (s *AliasNameContext) GetRuleContext() antlr.RuleContext
  • func (s *AliasNameContext) IdentifierName(i int) IIdentifierNameContext
  • func (*AliasNameContext) IsAliasNameContext()
  • func (s *AliasNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type AnonymousFunctionContext
  • func NewAnonymousFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnonymousFunctionContext
  • func NewEmptyAnonymousFunctionContext() *AnonymousFunctionContext
  • func (s *AnonymousFunctionContext) CopyAll(ctx *AnonymousFunctionContext)
  • func (s *AnonymousFunctionContext) GetParser() antlr.Parser
  • func (s *AnonymousFunctionContext) GetRuleContext() antlr.RuleContext
  • func (*AnonymousFunctionContext) IsAnonymousFunctionContext()
  • func (s *AnonymousFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type AnonymousFunctionDeclContext
  • func NewAnonymousFunctionDeclContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AnonymousFunctionDeclContext
  • func (s *AnonymousFunctionDeclContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AnonymousFunctionDeclContext) Async() antlr.TerminalNode
  • func (s *AnonymousFunctionDeclContext) CloseParen() antlr.TerminalNode
  • func (s *AnonymousFunctionDeclContext) FormalParameterList() IFormalParameterListContext
  • func (s *AnonymousFunctionDeclContext) FunctionBody() IFunctionBodyContext
  • func (s *AnonymousFunctionDeclContext) Function_() antlr.TerminalNode
  • func (s *AnonymousFunctionDeclContext) GetRuleContext() antlr.RuleContext
  • func (s *AnonymousFunctionDeclContext) Multiply() antlr.TerminalNode
  • func (s *AnonymousFunctionDeclContext) OpenParen() antlr.TerminalNode
• type ArgumentContext
  • func NewArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentContext
  • func NewEmptyArgumentContext() *ArgumentContext
  • func (s *ArgumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArgumentContext) Ellipsis() antlr.TerminalNode
  • func (s *ArgumentContext) GetParser() antlr.Parser
  • func (s *ArgumentContext) GetRuleContext() antlr.RuleContext
  • func (s *ArgumentContext) Identifier() IIdentifierContext
  • func (*ArgumentContext) IsArgumentContext()
  • func (s *ArgumentContext) SingleExpression() ISingleExpressionContext
  • func (s *ArgumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ArgumentsContext
  • func NewArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentsContext
  • func NewEmptyArgumentsContext() *ArgumentsContext
  • func (s *ArgumentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArgumentsContext) AllArgument() []IArgumentContext
  • func (s *ArgumentsContext) AllComma() []antlr.TerminalNode
  • func (s *ArgumentsContext) Argument(i int) IArgumentContext
  • func (s *ArgumentsContext) CloseParen() antlr.TerminalNode
  • func (s *ArgumentsContext) Comma(i int) antlr.TerminalNode
  • func (s *ArgumentsContext) GetParser() antlr.Parser
  • func (s *ArgumentsContext) GetRuleContext() antlr.RuleContext
  • func (*ArgumentsContext) IsArgumentsContext()
  • func (s *ArgumentsContext) OpenParen() antlr.TerminalNode
  • func (s *ArgumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ArgumentsExpressionContext
  • func NewArgumentsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArgumentsExpressionContext
  • func (s *ArgumentsExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArgumentsExpressionContext) Arguments() IArgumentsContext
  • func (s *ArgumentsExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *ArgumentsExpressionContext) SingleExpression() ISingleExpressionContext
• type ArrayElementContext
  • func NewArrayElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayElementContext
  • func NewEmptyArrayElementContext() *ArrayElementContext
  • func (s *ArrayElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArrayElementContext) Ellipsis() antlr.TerminalNode
  • func (s *ArrayElementContext) GetParser() antlr.Parser
  • func (s *ArrayElementContext) GetRuleContext() antlr.RuleContext
  • func (*ArrayElementContext) IsArrayElementContext()
  • func (s *ArrayElementContext) SingleExpression() ISingleExpressionContext
  • func (s *ArrayElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ArrayLiteralContext
  • func NewArrayLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayLiteralContext
  • func NewEmptyArrayLiteralContext() *ArrayLiteralContext
  • func (s *ArrayLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArrayLiteralContext) CloseBracket() antlr.TerminalNode
  • func (s *ArrayLiteralContext) ElementList() IElementListContext
  • func (s *ArrayLiteralContext) GetParser() antlr.Parser
  • func (s *ArrayLiteralContext) GetRuleContext() antlr.RuleContext
  • func (*ArrayLiteralContext) IsArrayLiteralContext()
  • func (s *ArrayLiteralContext) OpenBracket() antlr.TerminalNode
  • func (s *ArrayLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ArrayLiteralExpressionContext
  • func NewArrayLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayLiteralExpressionContext
  • func (s *ArrayLiteralExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArrayLiteralExpressionContext) ArrayLiteral() IArrayLiteralContext
  • func (s *ArrayLiteralExpressionContext) GetRuleContext() antlr.RuleContext
• type ArrowFunctionBodyContext
  • func NewArrowFunctionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrowFunctionBodyContext
  • func NewEmptyArrowFunctionBodyContext() *ArrowFunctionBodyContext
  • func (s *ArrowFunctionBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArrowFunctionBodyContext) FunctionBody() IFunctionBodyContext
  • func (s *ArrowFunctionBodyContext) GetParser() antlr.Parser
  • func (s *ArrowFunctionBodyContext) GetRuleContext() antlr.RuleContext
  • func (*ArrowFunctionBodyContext) IsArrowFunctionBodyContext()
  • func (s *ArrowFunctionBodyContext) SingleExpression() ISingleExpressionContext
  • func (s *ArrowFunctionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ArrowFunctionContext
  • func NewArrowFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrowFunctionContext
  • func (s *ArrowFunctionContext) ARROW() antlr.TerminalNode
  • func (s *ArrowFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArrowFunctionContext) ArrowFunctionBody() IArrowFunctionBodyContext
  • func (s *ArrowFunctionContext) ArrowFunctionParameters() IArrowFunctionParametersContext
  • func (s *ArrowFunctionContext) Async() antlr.TerminalNode
  • func (s *ArrowFunctionContext) GetRuleContext() antlr.RuleContext
• type ArrowFunctionParametersContext
  • func NewArrowFunctionParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrowFunctionParametersContext
  • func NewEmptyArrowFunctionParametersContext() *ArrowFunctionParametersContext
  • func (s *ArrowFunctionParametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ArrowFunctionParametersContext) CloseParen() antlr.TerminalNode
  • func (s *ArrowFunctionParametersContext) FormalParameterList() IFormalParameterListContext
  • func (s *ArrowFunctionParametersContext) GetParser() antlr.Parser
  • func (s *ArrowFunctionParametersContext) GetRuleContext() antlr.RuleContext
  • func (s *ArrowFunctionParametersContext) Identifier() IIdentifierContext
  • func (*ArrowFunctionParametersContext) IsArrowFunctionParametersContext()
  • func (s *ArrowFunctionParametersContext) OpenParen() antlr.TerminalNode
  • func (s *ArrowFunctionParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type AssignableContext
  • func NewAssignableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignableContext
  • func NewEmptyAssignableContext() *AssignableContext
  • func (s *AssignableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignableContext) ArrayLiteral() IArrayLiteralContext
  • func (s *AssignableContext) GetParser() antlr.Parser
  • func (s *AssignableContext) GetRuleContext() antlr.RuleContext
  • func (s *AssignableContext) Identifier() IIdentifierContext
  • func (*AssignableContext) IsAssignableContext()
  • func (s *AssignableContext) ObjectLiteral() IObjectLiteralContext
  • func (s *AssignableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type AssignmentExpressionContext
  • func NewAssignmentExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignmentExpressionContext
  • func (s *AssignmentExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignmentExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *AssignmentExpressionContext) Assign() antlr.TerminalNode
  • func (s *AssignmentExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *AssignmentExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type AssignmentOperatorContext
  • func NewAssignmentOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentOperatorContext
  • func NewEmptyAssignmentOperatorContext() *AssignmentOperatorContext
  • func (s *AssignmentOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignmentOperatorContext) BitAndAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) BitOrAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) BitXorAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) DivideAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) GetParser() antlr.Parser
  • func (s *AssignmentOperatorContext) GetRuleContext() antlr.RuleContext
  • func (*AssignmentOperatorContext) IsAssignmentOperatorContext()
  • func (s *AssignmentOperatorContext) LeftShiftArithmeticAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) MinusAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) ModulusAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) MultiplyAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) PlusAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) PowerAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) RightShiftArithmeticAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) RightShiftLogicalAssign() antlr.TerminalNode
  • func (s *AssignmentOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type AssignmentOperatorExpressionContext
  • func NewAssignmentOperatorExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignmentOperatorExpressionContext
  • func (s *AssignmentOperatorExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AssignmentOperatorExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *AssignmentOperatorExpressionContext) AssignmentOperator() IAssignmentOperatorContext
  • func (s *AssignmentOperatorExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *AssignmentOperatorExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type AwaitExpressionContext
  • func NewAwaitExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AwaitExpressionContext
  • func (s *AwaitExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *AwaitExpressionContext) Await() antlr.TerminalNode
  • func (s *AwaitExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *AwaitExpressionContext) SingleExpression() ISingleExpressionContext
• type BaseJavaScriptParserVisitor
  • func (v *BaseJavaScriptParserVisitor) VisitAdditiveExpression(ctx *AdditiveExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitAliasName(ctx *AliasNameContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitAnonymousFunctionDecl(ctx *AnonymousFunctionDeclContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArgument(ctx *ArgumentContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArguments(ctx *ArgumentsContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArgumentsExpression(ctx *ArgumentsExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArrayElement(ctx *ArrayElementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArrayLiteralExpression(ctx *ArrayLiteralExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArrowFunction(ctx *ArrowFunctionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArrowFunctionBody(ctx *ArrowFunctionBodyContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitArrowFunctionParameters(ctx *ArrowFunctionParametersContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitAssignable(ctx *AssignableContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitAssignmentExpression(ctx *AssignmentExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitAssignmentOperator(ctx *AssignmentOperatorContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitAssignmentOperatorExpression(ctx *AssignmentOperatorExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitAwaitExpression(ctx *AwaitExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBigintLiteral(ctx *BigintLiteralContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBitAndExpression(ctx *BitAndExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBitNotExpression(ctx *BitNotExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBitOrExpression(ctx *BitOrExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBitShiftExpression(ctx *BitShiftExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBitXOrExpression(ctx *BitXOrExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBlock(ctx *BlockContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBreakStatement(ctx *BreakStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitCaseBlock(ctx *CaseBlockContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitCaseClause(ctx *CaseClauseContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitCaseClauses(ctx *CaseClausesContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitCatchProduction(ctx *CatchProductionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitClassDeclaration(ctx *ClassDeclarationContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitClassElement(ctx *ClassElementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitClassElementName(ctx *ClassElementNameContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitClassExpression(ctx *ClassExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitClassTail(ctx *ClassTailContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitCoalesceExpression(ctx *CoalesceExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitComputedPropertyExpressionAssignment(ctx *ComputedPropertyExpressionAssignmentContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitContinueStatement(ctx *ContinueStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitDebuggerStatement(ctx *DebuggerStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitDeclaration(ctx *DeclarationContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitDefaultClause(ctx *DefaultClauseContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitDeleteExpression(ctx *DeleteExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitDoStatement(ctx *DoStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitElementList(ctx *ElementListContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitElseBlock(ctx *ElseBlockContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitEmptyStatement_(ctx *EmptyStatement_Context) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitEos(ctx *EosContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitEqualityExpression(ctx *EqualityExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitExportAliasName(ctx *ExportAliasNameContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitExportDeclaration(ctx *ExportDeclarationContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitExportDefaultDeclaration(ctx *ExportDefaultDeclarationContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitExportFromBlock(ctx *ExportFromBlockContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitExportModuleItems(ctx *ExportModuleItemsContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitExpressionSequence(ctx *ExpressionSequenceContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitExpressionStatement(ctx *ExpressionStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitFieldDefinition(ctx *FieldDefinitionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitFinallyProduction(ctx *FinallyProductionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitForFirst(ctx *ForFirstContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitForInStatement(ctx *ForInStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitForOfStatement(ctx *ForOfStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitForSecond(ctx *ForSecondContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitForStatement(ctx *ForStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitForThird(ctx *ForThirdContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitFormalParameterArg(ctx *FormalParameterArgContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitFormalParameterList(ctx *FormalParameterListContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitFunctionBody(ctx *FunctionBodyContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitFunctionDeclaration(ctx *FunctionDeclarationContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitFunctionExpression(ctx *FunctionExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitFunctionProperty(ctx *FunctionPropertyContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitGetter(ctx *GetterContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitIdentifier(ctx *IdentifierContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitIdentifierExpression(ctx *IdentifierExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitIdentifierName(ctx *IdentifierNameContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitIfStatement(ctx *IfStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportAliasName(ctx *ImportAliasNameContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportDefault(ctx *ImportDefaultContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportExpression(ctx *ImportExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportFrom(ctx *ImportFromContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportFromBlock(ctx *ImportFromBlockContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportModuleItems(ctx *ImportModuleItemsContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportNamespace(ctx *ImportNamespaceContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportStatement(ctx *ImportStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitImportedBinding(ctx *ImportedBindingContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitInExpression(ctx *InExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitInitializer(ctx *InitializerContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitInstanceofExpression(ctx *InstanceofExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitKeyword(ctx *KeywordContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLabelledStatement(ctx *LabelledStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLastFormalParameterArg(ctx *LastFormalParameterArgContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLet_(ctx *Let_Context) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLiteral(ctx *LiteralContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLiteralExpression(ctx *LiteralExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLogicalAndExpression(ctx *LogicalAndExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLogicalOrExpression(ctx *LogicalOrExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitMemberDotExpression(ctx *MemberDotExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitMemberIndexExpression(ctx *MemberIndexExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitMetaExpression(ctx *MetaExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitMethodDefinition(ctx *MethodDefinitionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitModuleExportName(ctx *ModuleExportNameContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitNewExpression(ctx *NewExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitNotExpression(ctx *NotExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitNumericLiteral(ctx *NumericLiteralContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitObjectLiteral(ctx *ObjectLiteralContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitObjectLiteralExpression(ctx *ObjectLiteralExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitOptionalChainExpression(ctx *OptionalChainExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPostDecreaseExpression(ctx *PostDecreaseExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPostIncrementExpression(ctx *PostIncrementExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPowerExpression(ctx *PowerExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPreDecreaseExpression(ctx *PreDecreaseExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPreIncrementExpression(ctx *PreIncrementExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPrivateIdentifier(ctx *PrivateIdentifierContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitProgram(ctx *ProgramContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPropertyExpressionAssignment(ctx *PropertyExpressionAssignmentContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPropertyGetter(ctx *PropertyGetterContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPropertyName(ctx *PropertyNameContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPropertySetter(ctx *PropertySetterContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPropertyShorthand(ctx *PropertyShorthandContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitRelationalExpression(ctx *RelationalExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitReservedWord(ctx *ReservedWordContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitReturnStatement(ctx *ReturnStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitSetter(ctx *SetterContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitSourceElement(ctx *SourceElementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitSourceElements(ctx *SourceElementsContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitStatement(ctx *StatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitStatementList(ctx *StatementListContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitSuperExpression(ctx *SuperExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitSwitchStatement(ctx *SwitchStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitTemplateStringAtom(ctx *TemplateStringAtomContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitTemplateStringExpression(ctx *TemplateStringExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitTemplateStringLiteral(ctx *TemplateStringLiteralContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitTernaryExpression(ctx *TernaryExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitThisExpression(ctx *ThisExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitThrowStatement(ctx *ThrowStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitTryStatement(ctx *TryStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitTypeofExpression(ctx *TypeofExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitUnaryMinusExpression(ctx *UnaryMinusExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitUnaryPlusExpression(ctx *UnaryPlusExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitVarModifier(ctx *VarModifierContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitVariableDeclarationList(ctx *VariableDeclarationListContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitVariableStatement(ctx *VariableStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitVoidExpression(ctx *VoidExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitWhileStatement(ctx *WhileStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitWithStatement(ctx *WithStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitYieldExpression(ctx *YieldExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitYieldStatement(ctx *YieldStatementContext) interface{}
• type BigintLiteralContext
  • func NewBigintLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BigintLiteralContext
  • func NewEmptyBigintLiteralContext() *BigintLiteralContext
  • func (s *BigintLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BigintLiteralContext) BigBinaryIntegerLiteral() antlr.TerminalNode
  • func (s *BigintLiteralContext) BigDecimalIntegerLiteral() antlr.TerminalNode
  • func (s *BigintLiteralContext) BigHexIntegerLiteral() antlr.TerminalNode
  • func (s *BigintLiteralContext) BigOctalIntegerLiteral() antlr.TerminalNode
  • func (s *BigintLiteralContext) GetParser() antlr.Parser
  • func (s *BigintLiteralContext) GetRuleContext() antlr.RuleContext
  • func (*BigintLiteralContext) IsBigintLiteralContext()
  • func (s *BigintLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type BitAndExpressionContext
  • func NewBitAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitAndExpressionContext
  • func (s *BitAndExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BitAndExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *BitAndExpressionContext) BitAnd() antlr.TerminalNode
  • func (s *BitAndExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *BitAndExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type BitNotExpressionContext
  • func NewBitNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitNotExpressionContext
  • func (s *BitNotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BitNotExpressionContext) BitNot() antlr.TerminalNode
  • func (s *BitNotExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *BitNotExpressionContext) SingleExpression() ISingleExpressionContext
• type BitOrExpressionContext
  • func NewBitOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitOrExpressionContext
  • func (s *BitOrExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BitOrExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *BitOrExpressionContext) BitOr() antlr.TerminalNode
  • func (s *BitOrExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *BitOrExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type BitShiftExpressionContext
  • func NewBitShiftExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitShiftExpressionContext
  • func (s *BitShiftExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BitShiftExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *BitShiftExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *BitShiftExpressionContext) LeftShiftArithmetic() antlr.TerminalNode
  • func (s *BitShiftExpressionContext) RightShiftArithmetic() antlr.TerminalNode
  • func (s *BitShiftExpressionContext) RightShiftLogical() antlr.TerminalNode
  • func (s *BitShiftExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type BitXOrExpressionContext
  • func NewBitXOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitXOrExpressionContext
  • func (s *BitXOrExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BitXOrExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *BitXOrExpressionContext) BitXOr() antlr.TerminalNode
  • func (s *BitXOrExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *BitXOrExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type BlockContext
  • func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext
  • func NewEmptyBlockContext() *BlockContext
  • func (s *BlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BlockContext) CloseBrace() antlr.TerminalNode
  • func (s *BlockContext) GetParser() antlr.Parser
  • func (s *BlockContext) GetRuleContext() antlr.RuleContext
  • func (*BlockContext) IsBlockContext()
  • func (s *BlockContext) OpenBrace() antlr.TerminalNode
  • func (s *BlockContext) StatementList() IStatementListContext
  • func (s *BlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type BreakStatementContext
  • func NewBreakStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BreakStatementContext
  • func NewEmptyBreakStatementContext() *BreakStatementContext
  • func (s *BreakStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BreakStatementContext) Break() antlr.TerminalNode
  • func (s *BreakStatementContext) Eos() IEosContext
  • func (s *BreakStatementContext) GetParser() antlr.Parser
  • func (s *BreakStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *BreakStatementContext) Identifier() IIdentifierContext
  • func (*BreakStatementContext) IsBreakStatementContext()
  • func (s *BreakStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type CaseBlockContext
  • func NewCaseBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseBlockContext
  • func NewEmptyCaseBlockContext() *CaseBlockContext
  • func (s *CaseBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *CaseBlockContext) AllCaseClauses() []ICaseClausesContext
  • func (s *CaseBlockContext) CaseClauses(i int) ICaseClausesContext
  • func (s *CaseBlockContext) CloseBrace() antlr.TerminalNode
  • func (s *CaseBlockContext) DefaultClause() IDefaultClauseContext
  • func (s *CaseBlockContext) GetParser() antlr.Parser
  • func (s *CaseBlockContext) GetRuleContext() antlr.RuleContext
  • func (*CaseBlockContext) IsCaseBlockContext()
  • func (s *CaseBlockContext) OpenBrace() antlr.TerminalNode
  • func (s *CaseBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type CaseClauseContext
  • func NewCaseClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseClauseContext
  • func NewEmptyCaseClauseContext() *CaseClauseContext
  • func (s *CaseClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *CaseClauseContext) Case() antlr.TerminalNode
  • func (s *CaseClauseContext) Colon() antlr.TerminalNode
  • func (s *CaseClauseContext) GetParser() antlr.Parser
  • func (s *CaseClauseContext) GetRuleContext() antlr.RuleContext
  • func (*CaseClauseContext) IsCaseClauseContext()
  • func (s *CaseClauseContext) SingleExpression() ISingleExpressionContext
  • func (s *CaseClauseContext) StatementList() IStatementListContext
  • func (s *CaseClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type CaseClausesContext
  • func NewCaseClausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseClausesContext
  • func NewEmptyCaseClausesContext() *CaseClausesContext
  • func (s *CaseClausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *CaseClausesContext) AllCaseClause() []ICaseClauseContext
  • func (s *CaseClausesContext) CaseClause(i int) ICaseClauseContext
  • func (s *CaseClausesContext) GetParser() antlr.Parser
  • func (s *CaseClausesContext) GetRuleContext() antlr.RuleContext
  • func (*CaseClausesContext) IsCaseClausesContext()
  • func (s *CaseClausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type CatchProductionContext
  • func NewCatchProductionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchProductionContext
  • func NewEmptyCatchProductionContext() *CatchProductionContext
  • func (s *CatchProductionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *CatchProductionContext) Assignable() IAssignableContext
  • func (s *CatchProductionContext) Block() IBlockContext
  • func (s *CatchProductionContext) Catch() antlr.TerminalNode
  • func (s *CatchProductionContext) CloseParen() antlr.TerminalNode
  • func (s *CatchProductionContext) GetParser() antlr.Parser
  • func (s *CatchProductionContext) GetRuleContext() antlr.RuleContext
  • func (*CatchProductionContext) IsCatchProductionContext()
  • func (s *CatchProductionContext) OpenParen() antlr.TerminalNode
  • func (s *CatchProductionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ClassDeclarationContext
  • func NewClassDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassDeclarationContext
  • func NewEmptyClassDeclarationContext() *ClassDeclarationContext
  • func (s *ClassDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ClassDeclarationContext) Class() antlr.TerminalNode
  • func (s *ClassDeclarationContext) ClassTail() IClassTailContext
  • func (s *ClassDeclarationContext) GetParser() antlr.Parser
  • func (s *ClassDeclarationContext) GetRuleContext() antlr.RuleContext
  • func (s *ClassDeclarationContext) Identifier() IIdentifierContext
  • func (*ClassDeclarationContext) IsClassDeclarationContext()
  • func (s *ClassDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ClassElementContext
  • func NewClassElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassElementContext
  • func NewEmptyClassElementContext() *ClassElementContext
  • func (s *ClassElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ClassElementContext) Block() IBlockContext
  • func (s *ClassElementContext) EmptyStatement_() IEmptyStatement_Context
  • func (s *ClassElementContext) FieldDefinition() IFieldDefinitionContext
  • func (s *ClassElementContext) GetParser() antlr.Parser
  • func (s *ClassElementContext) GetRuleContext() antlr.RuleContext
  • func (s *ClassElementContext) Identifier() IIdentifierContext
  • func (*ClassElementContext) IsClassElementContext()
  • func (s *ClassElementContext) MethodDefinition() IMethodDefinitionContext
  • func (s *ClassElementContext) Static() antlr.TerminalNode
  • func (s *ClassElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ClassElementNameContext
  • func NewClassElementNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassElementNameContext
  • func NewEmptyClassElementNameContext() *ClassElementNameContext
  • func (s *ClassElementNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ClassElementNameContext) GetParser() antlr.Parser
  • func (s *ClassElementNameContext) GetRuleContext() antlr.RuleContext
  • func (*ClassElementNameContext) IsClassElementNameContext()
  • func (s *ClassElementNameContext) PrivateIdentifier() IPrivateIdentifierContext
  • func (s *ClassElementNameContext) PropertyName() IPropertyNameContext
  • func (s *ClassElementNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ClassExpressionContext
  • func NewClassExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ClassExpressionContext
  • func (s *ClassExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ClassExpressionContext) Class() antlr.TerminalNode
  • func (s *ClassExpressionContext) ClassTail() IClassTailContext
  • func (s *ClassExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *ClassExpressionContext) Identifier() IIdentifierContext
• type ClassTailContext
  • func NewClassTailContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassTailContext
  • func NewEmptyClassTailContext() *ClassTailContext
  • func (s *ClassTailContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ClassTailContext) AllClassElement() []IClassElementContext
  • func (s *ClassTailContext) ClassElement(i int) IClassElementContext
  • func (s *ClassTailContext) CloseBrace() antlr.TerminalNode
  • func (s *ClassTailContext) Extends() antlr.TerminalNode
  • func (s *ClassTailContext) GetParser() antlr.Parser
  • func (s *ClassTailContext) GetRuleContext() antlr.RuleContext
  • func (*ClassTailContext) IsClassTailContext()
  • func (s *ClassTailContext) OpenBrace() antlr.TerminalNode
  • func (s *ClassTailContext) SingleExpression() ISingleExpressionContext
  • func (s *ClassTailContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type CoalesceExpressionContext
  • func NewCoalesceExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CoalesceExpressionContext
  • func (s *CoalesceExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *CoalesceExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *CoalesceExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *CoalesceExpressionContext) NullCoalesce() antlr.TerminalNode
  • func (s *CoalesceExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type ComputedPropertyExpressionAssignmentContext
  • func NewComputedPropertyExpressionAssignmentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ComputedPropertyExpressionAssignmentContext
  • func (s *ComputedPropertyExpressionAssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ComputedPropertyExpressionAssignmentContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *ComputedPropertyExpressionAssignmentContext) CloseBracket() antlr.TerminalNode
  • func (s *ComputedPropertyExpressionAssignmentContext) Colon() antlr.TerminalNode
  • func (s *ComputedPropertyExpressionAssignmentContext) GetRuleContext() antlr.RuleContext
  • func (s *ComputedPropertyExpressionAssignmentContext) OpenBracket() antlr.TerminalNode
  • func (s *ComputedPropertyExpressionAssignmentContext) SingleExpression(i int) ISingleExpressionContext
• type ContinueStatementContext
  • func NewContinueStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContinueStatementContext
  • func NewEmptyContinueStatementContext() *ContinueStatementContext
  • func (s *ContinueStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ContinueStatementContext) Continue() antlr.TerminalNode
  • func (s *ContinueStatementContext) Eos() IEosContext
  • func (s *ContinueStatementContext) GetParser() antlr.Parser
  • func (s *ContinueStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *ContinueStatementContext) Identifier() IIdentifierContext
  • func (*ContinueStatementContext) IsContinueStatementContext()
  • func (s *ContinueStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type DebuggerStatementContext
  • func NewDebuggerStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DebuggerStatementContext
  • func NewEmptyDebuggerStatementContext() *DebuggerStatementContext
  • func (s *DebuggerStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *DebuggerStatementContext) Debugger() antlr.TerminalNode
  • func (s *DebuggerStatementContext) Eos() IEosContext
  • func (s *DebuggerStatementContext) GetParser() antlr.Parser
  • func (s *DebuggerStatementContext) GetRuleContext() antlr.RuleContext
  • func (*DebuggerStatementContext) IsDebuggerStatementContext()
  • func (s *DebuggerStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type DeclarationContext
  • func NewDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclarationContext
  • func NewEmptyDeclarationContext() *DeclarationContext
  • func (s *DeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *DeclarationContext) ClassDeclaration() IClassDeclarationContext
  • func (s *DeclarationContext) FunctionDeclaration() IFunctionDeclarationContext
  • func (s *DeclarationContext) GetParser() antlr.Parser
  • func (s *DeclarationContext) GetRuleContext() antlr.RuleContext
  • func (*DeclarationContext) IsDeclarationContext()
  • func (s *DeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *DeclarationContext) VariableStatement() IVariableStatementContext
• type DefaultClauseContext
  • func NewDefaultClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultClauseContext
  • func NewEmptyDefaultClauseContext() *DefaultClauseContext
  • func (s *DefaultClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *DefaultClauseContext) Colon() antlr.TerminalNode
  • func (s *DefaultClauseContext) Default() antlr.TerminalNode
  • func (s *DefaultClauseContext) GetParser() antlr.Parser
  • func (s *DefaultClauseContext) GetRuleContext() antlr.RuleContext
  • func (*DefaultClauseContext) IsDefaultClauseContext()
  • func (s *DefaultClauseContext) StatementList() IStatementListContext
  • func (s *DefaultClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type DeleteExpressionContext
  • func NewDeleteExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DeleteExpressionContext
  • func (s *DeleteExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *DeleteExpressionContext) Delete() antlr.TerminalNode
  • func (s *DeleteExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *DeleteExpressionContext) SingleExpression() ISingleExpressionContext
• type DoStatementContext
  • func NewDoStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoStatementContext
  • func (s *DoStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *DoStatementContext) CloseParen() antlr.TerminalNode
  • func (s *DoStatementContext) Do() antlr.TerminalNode
  • func (s *DoStatementContext) Eos() IEosContext
  • func (s *DoStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *DoStatementContext) OpenParen() antlr.TerminalNode
  • func (s *DoStatementContext) SingleExpression() ISingleExpressionContext
  • func (s *DoStatementContext) Statement() IStatementContext
  • func (s *DoStatementContext) While() antlr.TerminalNode
• type ElementListContext
  • func NewElementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementListContext
  • func NewEmptyElementListContext() *ElementListContext
  • func (s *ElementListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ElementListContext) AllArrayElement() []IArrayElementContext
  • func (s *ElementListContext) AllComma() []antlr.TerminalNode
  • func (s *ElementListContext) ArrayElement(i int) IArrayElementContext
  • func (s *ElementListContext) Comma(i int) antlr.TerminalNode
  • func (s *ElementListContext) GetParser() antlr.Parser
  • func (s *ElementListContext) GetRuleContext() antlr.RuleContext
  • func (*ElementListContext) IsElementListContext()
  • func (s *ElementListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ElseBlockContext
  • func NewElseBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElseBlockContext
  • func NewEmptyElseBlockContext() *ElseBlockContext
  • func (s *ElseBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ElseBlockContext) Else() antlr.TerminalNode
  • func (s *ElseBlockContext) GetParser() antlr.Parser
  • func (s *ElseBlockContext) GetRuleContext() antlr.RuleContext
  • func (*ElseBlockContext) IsElseBlockContext()
  • func (s *ElseBlockContext) Statement() IStatementContext
  • func (s *ElseBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type EmptyStatement_Context
  • func NewEmptyEmptyStatement_Context() *EmptyStatement_Context
  • func NewEmptyStatement_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EmptyStatement_Context
  • func (s *EmptyStatement_Context) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *EmptyStatement_Context) GetParser() antlr.Parser
  • func (s *EmptyStatement_Context) GetRuleContext() antlr.RuleContext
  • func (*EmptyStatement_Context) IsEmptyStatement_Context()
  • func (s *EmptyStatement_Context) SemiColon() antlr.TerminalNode
  • func (s *EmptyStatement_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type EosContext
  • func NewEmptyEosContext() *EosContext
  • func NewEosContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EosContext
  • func (s *EosContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *EosContext) EOF() antlr.TerminalNode
  • func (s *EosContext) GetParser() antlr.Parser
  • func (s *EosContext) GetRuleContext() antlr.RuleContext
  • func (*EosContext) IsEosContext()
  • func (s *EosContext) SemiColon() antlr.TerminalNode
  • func (s *EosContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type EqualityExpressionContext
  • func NewEqualityExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqualityExpressionContext
  • func (s *EqualityExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *EqualityExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *EqualityExpressionContext) Equals_() antlr.TerminalNode
  • func (s *EqualityExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *EqualityExpressionContext) IdentityEquals() antlr.TerminalNode
  • func (s *EqualityExpressionContext) IdentityNotEquals() antlr.TerminalNode
  • func (s *EqualityExpressionContext) NotEquals() antlr.TerminalNode
  • func (s *EqualityExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type ExportAliasNameContext
  • func NewEmptyExportAliasNameContext() *ExportAliasNameContext
  • func NewExportAliasNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExportAliasNameContext
  • func (s *ExportAliasNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExportAliasNameContext) AllModuleExportName() []IModuleExportNameContext
  • func (s *ExportAliasNameContext) As() antlr.TerminalNode
  • func (s *ExportAliasNameContext) GetParser() antlr.Parser
  • func (s *ExportAliasNameContext) GetRuleContext() antlr.RuleContext
  • func (*ExportAliasNameContext) IsExportAliasNameContext()
  • func (s *ExportAliasNameContext) ModuleExportName(i int) IModuleExportNameContext
  • func (s *ExportAliasNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ExportDeclarationContext
  • func NewExportDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExportDeclarationContext
  • func (s *ExportDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExportDeclarationContext) Declaration() IDeclarationContext
  • func (s *ExportDeclarationContext) Default() antlr.TerminalNode
  • func (s *ExportDeclarationContext) Eos() IEosContext
  • func (s *ExportDeclarationContext) Export() antlr.TerminalNode
  • func (s *ExportDeclarationContext) ExportFromBlock() IExportFromBlockContext
  • func (s *ExportDeclarationContext) GetRuleContext() antlr.RuleContext
• type ExportDefaultDeclarationContext
  • func NewExportDefaultDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExportDefaultDeclarationContext
  • func (s *ExportDefaultDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExportDefaultDeclarationContext) Default() antlr.TerminalNode
  • func (s *ExportDefaultDeclarationContext) Eos() IEosContext
  • func (s *ExportDefaultDeclarationContext) Export() antlr.TerminalNode
  • func (s *ExportDefaultDeclarationContext) GetRuleContext() antlr.RuleContext
  • func (s *ExportDefaultDeclarationContext) SingleExpression() ISingleExpressionContext
• type ExportFromBlockContext
  • func NewEmptyExportFromBlockContext() *ExportFromBlockContext
  • func NewExportFromBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExportFromBlockContext
  • func (s *ExportFromBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExportFromBlockContext) Eos() IEosContext
  • func (s *ExportFromBlockContext) ExportModuleItems() IExportModuleItemsContext
  • func (s *ExportFromBlockContext) GetParser() antlr.Parser
  • func (s *ExportFromBlockContext) GetRuleContext() antlr.RuleContext
  • func (s *ExportFromBlockContext) ImportFrom() IImportFromContext
  • func (s *ExportFromBlockContext) ImportNamespace() IImportNamespaceContext
  • func (*ExportFromBlockContext) IsExportFromBlockContext()
  • func (s *ExportFromBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ExportModuleItemsContext
  • func NewEmptyExportModuleItemsContext() *ExportModuleItemsContext
  • func NewExportModuleItemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExportModuleItemsContext
  • func (s *ExportModuleItemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExportModuleItemsContext) AllComma() []antlr.TerminalNode
  • func (s *ExportModuleItemsContext) AllExportAliasName() []IExportAliasNameContext
  • func (s *ExportModuleItemsContext) CloseBrace() antlr.TerminalNode
  • func (s *ExportModuleItemsContext) Comma(i int) antlr.TerminalNode
  • func (s *ExportModuleItemsContext) ExportAliasName(i int) IExportAliasNameContext
  • func (s *ExportModuleItemsContext) GetParser() antlr.Parser
  • func (s *ExportModuleItemsContext) GetRuleContext() antlr.RuleContext
  • func (*ExportModuleItemsContext) IsExportModuleItemsContext()
  • func (s *ExportModuleItemsContext) OpenBrace() antlr.TerminalNode
  • func (s *ExportModuleItemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ExportStatementContext
  • func NewEmptyExportStatementContext() *ExportStatementContext
  • func NewExportStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExportStatementContext
  • func (s *ExportStatementContext) CopyAll(ctx *ExportStatementContext)
  • func (s *ExportStatementContext) GetParser() antlr.Parser
  • func (s *ExportStatementContext) GetRuleContext() antlr.RuleContext
  • func (*ExportStatementContext) IsExportStatementContext()
  • func (s *ExportStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ExpressionSequenceContext
  • func NewEmptyExpressionSequenceContext() *ExpressionSequenceContext
  • func NewExpressionSequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionSequenceContext
  • func (s *ExpressionSequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExpressionSequenceContext) AllComma() []antlr.TerminalNode
  • func (s *ExpressionSequenceContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *ExpressionSequenceContext) Comma(i int) antlr.TerminalNode
  • func (s *ExpressionSequenceContext) GetParser() antlr.Parser
  • func (s *ExpressionSequenceContext) GetRuleContext() antlr.RuleContext
  • func (*ExpressionSequenceContext) IsExpressionSequenceContext()
  • func (s *ExpressionSequenceContext) SingleExpression(i int) ISingleExpressionContext
  • func (s *ExpressionSequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ExpressionStatementContext
  • func NewEmptyExpressionStatementContext() *ExpressionStatementContext
  • func NewExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionStatementContext
  • func (s *ExpressionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ExpressionStatementContext) Eos() IEosContext
  • func (s *ExpressionStatementContext) ExpressionSequence() IExpressionSequenceContext
  • func (s *ExpressionStatementContext) GetParser() antlr.Parser
  • func (s *ExpressionStatementContext) GetRuleContext() antlr.RuleContext
  • func (*ExpressionStatementContext) IsExpressionStatementContext()
  • func (s *ExpressionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type FieldDefinitionContext
  • func NewEmptyFieldDefinitionContext() *FieldDefinitionContext
  • func NewFieldDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldDefinitionContext
  • func (s *FieldDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FieldDefinitionContext) ClassElementName() IClassElementNameContext
  • func (s *FieldDefinitionContext) GetParser() antlr.Parser
  • func (s *FieldDefinitionContext) GetRuleContext() antlr.RuleContext
  • func (s *FieldDefinitionContext) Initializer() IInitializerContext
  • func (*FieldDefinitionContext) IsFieldDefinitionContext()
  • func (s *FieldDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type FinallyProductionContext
  • func NewEmptyFinallyProductionContext() *FinallyProductionContext
  • func NewFinallyProductionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FinallyProductionContext
  • func (s *FinallyProductionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FinallyProductionContext) Block() IBlockContext
  • func (s *FinallyProductionContext) Finally() antlr.TerminalNode
  • func (s *FinallyProductionContext) GetParser() antlr.Parser
  • func (s *FinallyProductionContext) GetRuleContext() antlr.RuleContext
  • func (*FinallyProductionContext) IsFinallyProductionContext()
  • func (s *FinallyProductionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ForFirstContext
  • func NewEmptyForFirstContext() *ForFirstContext
  • func NewForFirstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForFirstContext
  • func (s *ForFirstContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ForFirstContext) GetParser() antlr.Parser
  • func (s *ForFirstContext) GetRuleContext() antlr.RuleContext
  • func (*ForFirstContext) IsForFirstContext()
  • func (s *ForFirstContext) SingleExpression() ISingleExpressionContext
  • func (s *ForFirstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *ForFirstContext) VariableDeclarationList() IVariableDeclarationListContext
• type ForInStatementContext
  • func NewForInStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForInStatementContext
  • func (s *ForInStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ForInStatementContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *ForInStatementContext) CloseParen() antlr.TerminalNode
  • func (s *ForInStatementContext) For() antlr.TerminalNode
  • func (s *ForInStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *ForInStatementContext) In() antlr.TerminalNode
  • func (s *ForInStatementContext) OpenParen() antlr.TerminalNode
  • func (s *ForInStatementContext) SingleExpression(i int) ISingleExpressionContext
  • func (s *ForInStatementContext) Statement() IStatementContext
  • func (s *ForInStatementContext) VariableDeclaration() IVariableDeclarationContext
• type ForOfStatementContext
  • func NewForOfStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForOfStatementContext
  • func (s *ForOfStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ForOfStatementContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *ForOfStatementContext) Await() antlr.TerminalNode
  • func (s *ForOfStatementContext) CloseParen() antlr.TerminalNode
  • func (s *ForOfStatementContext) For() antlr.TerminalNode
  • func (s *ForOfStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *ForOfStatementContext) Identifier() IIdentifierContext
  • func (s *ForOfStatementContext) OpenParen() antlr.TerminalNode
  • func (s *ForOfStatementContext) SingleExpression(i int) ISingleExpressionContext
  • func (s *ForOfStatementContext) Statement() IStatementContext
  • func (s *ForOfStatementContext) VariableDeclaration() IVariableDeclarationContext
• type ForSecondContext
  • func NewEmptyForSecondContext() *ForSecondContext
  • func NewForSecondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForSecondContext
  • func (s *ForSecondContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ForSecondContext) GetParser() antlr.Parser
  • func (s *ForSecondContext) GetRuleContext() antlr.RuleContext
  • func (*ForSecondContext) IsForSecondContext()
  • func (s *ForSecondContext) SingleExpression() ISingleExpressionContext
  • func (s *ForSecondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ForStatementContext
  • func NewForStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForStatementContext
  • func (s *ForStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ForStatementContext) AllSemiColon() []antlr.TerminalNode
  • func (s *ForStatementContext) CloseParen() antlr.TerminalNode
  • func (s *ForStatementContext) For() antlr.TerminalNode
  • func (s *ForStatementContext) ForFirst() IForFirstContext
  • func (s *ForStatementContext) ForSecond() IForSecondContext
  • func (s *ForStatementContext) ForThird() IForThirdContext
  • func (s *ForStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *ForStatementContext) OpenParen() antlr.TerminalNode
  • func (s *ForStatementContext) SemiColon(i int) antlr.TerminalNode
  • func (s *ForStatementContext) Statement() IStatementContext
• type ForThirdContext
  • func NewEmptyForThirdContext() *ForThirdContext
  • func NewForThirdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForThirdContext
  • func (s *ForThirdContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ForThirdContext) GetParser() antlr.Parser
  • func (s *ForThirdContext) GetRuleContext() antlr.RuleContext
  • func (*ForThirdContext) IsForThirdContext()
  • func (s *ForThirdContext) SingleExpression() ISingleExpressionContext
  • func (s *ForThirdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type FormalParameterArgContext
  • func NewEmptyFormalParameterArgContext() *FormalParameterArgContext
  • func NewFormalParameterArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParameterArgContext
  • func (s *FormalParameterArgContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FormalParameterArgContext) Assign() antlr.TerminalNode
  • func (s *FormalParameterArgContext) Assignable() IAssignableContext
  • func (s *FormalParameterArgContext) GetParser() antlr.Parser
  • func (s *FormalParameterArgContext) GetRuleContext() antlr.RuleContext
  • func (*FormalParameterArgContext) IsFormalParameterArgContext()
  • func (s *FormalParameterArgContext) SingleExpression() ISingleExpressionContext
  • func (s *FormalParameterArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type FormalParameterListContext
  • func NewEmptyFormalParameterListContext() *FormalParameterListContext
  • func NewFormalParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParameterListContext
  • func (s *FormalParameterListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FormalParameterListContext) AllComma() []antlr.TerminalNode
  • func (s *FormalParameterListContext) AllFormalParameterArg() []IFormalParameterArgContext
  • func (s *FormalParameterListContext) Comma(i int) antlr.TerminalNode
  • func (s *FormalParameterListContext) FormalParameterArg(i int) IFormalParameterArgContext
  • func (s *FormalParameterListContext) GetParser() antlr.Parser
  • func (s *FormalParameterListContext) GetRuleContext() antlr.RuleContext
  • func (*FormalParameterListContext) IsFormalParameterListContext()
  • func (s *FormalParameterListContext) LastFormalParameterArg() ILastFormalParameterArgContext
  • func (s *FormalParameterListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type FunctionBodyContext
  • func NewEmptyFunctionBodyContext() *FunctionBodyContext
  • func NewFunctionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionBodyContext
  • func (s *FunctionBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FunctionBodyContext) CloseBrace() antlr.TerminalNode
  • func (s *FunctionBodyContext) GetParser() antlr.Parser
  • func (s *FunctionBodyContext) GetRuleContext() antlr.RuleContext
  • func (*FunctionBodyContext) IsFunctionBodyContext()
  • func (s *FunctionBodyContext) OpenBrace() antlr.TerminalNode
  • func (s *FunctionBodyContext) SourceElements() ISourceElementsContext
  • func (s *FunctionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type FunctionDeclarationContext
  • func NewEmptyFunctionDeclarationContext() *FunctionDeclarationContext
  • func NewFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionDeclarationContext
  • func (s *FunctionDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FunctionDeclarationContext) Async() antlr.TerminalNode
  • func (s *FunctionDeclarationContext) CloseParen() antlr.TerminalNode
  • func (s *FunctionDeclarationContext) FormalParameterList() IFormalParameterListContext
  • func (s *FunctionDeclarationContext) FunctionBody() IFunctionBodyContext
  • func (s *FunctionDeclarationContext) Function_() antlr.TerminalNode
  • func (s *FunctionDeclarationContext) GetParser() antlr.Parser
  • func (s *FunctionDeclarationContext) GetRuleContext() antlr.RuleContext
  • func (s *FunctionDeclarationContext) Identifier() IIdentifierContext
  • func (*FunctionDeclarationContext) IsFunctionDeclarationContext()
  • func (s *FunctionDeclarationContext) Multiply() antlr.TerminalNode
  • func (s *FunctionDeclarationContext) OpenParen() antlr.TerminalNode
  • func (s *FunctionDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type FunctionExpressionContext
  • func NewFunctionExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionExpressionContext
  • func (s *FunctionExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FunctionExpressionContext) AnonymousFunction() IAnonymousFunctionContext
  • func (s *FunctionExpressionContext) GetRuleContext() antlr.RuleContext
• type FunctionPropertyContext
  • func NewFunctionPropertyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionPropertyContext
  • func (s *FunctionPropertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *FunctionPropertyContext) Async() antlr.TerminalNode
  • func (s *FunctionPropertyContext) CloseParen() antlr.TerminalNode
  • func (s *FunctionPropertyContext) FormalParameterList() IFormalParameterListContext
  • func (s *FunctionPropertyContext) FunctionBody() IFunctionBodyContext
  • func (s *FunctionPropertyContext) GetRuleContext() antlr.RuleContext
  • func (s *FunctionPropertyContext) Multiply() antlr.TerminalNode
  • func (s *FunctionPropertyContext) OpenParen() antlr.TerminalNode
  • func (s *FunctionPropertyContext) PropertyName() IPropertyNameContext
• type GetterContext
  • func NewEmptyGetterContext() *GetterContext
  • func NewGetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GetterContext
  • func (s *GetterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *GetterContext) ClassElementName() IClassElementNameContext
  • func (s *GetterContext) GetParser() antlr.Parser
  • func (s *GetterContext) GetRuleContext() antlr.RuleContext
  • func (s *GetterContext) Identifier() IIdentifierContext
  • func (*GetterContext) IsGetterContext()
  • func (s *GetterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type IAliasNameContext
• type IAnonymousFunctionContext
• type IArgumentContext
• type IArgumentsContext
• type IArrayElementContext
• type IArrayLiteralContext
• type IArrowFunctionBodyContext
• type IArrowFunctionParametersContext
• type IAssignableContext
• type IAssignmentOperatorContext
• type IBigintLiteralContext
• type IBlockContext
• type IBreakStatementContext
• type ICaseBlockContext
• type ICaseClauseContext
• type ICaseClausesContext
• type ICatchProductionContext
• type IClassDeclarationContext
• type IClassElementContext
• type IClassElementNameContext
• type IClassTailContext
• type IContinueStatementContext
• type IDebuggerStatementContext
• type IDeclarationContext
• type IDefaultClauseContext
• type IElementListContext
• type IElseBlockContext
• type IEmptyStatement_Context
• type IEosContext
• type IExportAliasNameContext
• type IExportFromBlockContext
• type IExportModuleItemsContext
• type IExportStatementContext
• type IExpressionSequenceContext
• type IExpressionStatementContext
• type IFieldDefinitionContext
• type IFinallyProductionContext
• type IForFirstContext
• type IForSecondContext
• type IForThirdContext
• type IFormalParameterArgContext
• type IFormalParameterListContext
• type IFunctionBodyContext
• type IFunctionDeclarationContext
• type IGetterContext
• type IIdentifierContext
• type IIdentifierNameContext
• type IIfStatementContext
• type IImportAliasNameContext
• type IImportDefaultContext
• type IImportFromBlockContext
• type IImportFromContext
• type IImportModuleItemsContext
• type IImportNamespaceContext
• type IImportStatementContext
• type IImportedBindingContext
• type IInitializerContext
• type IIterationStatementContext
• type IKeywordContext
• type ILabelledStatementContext
• type ILastFormalParameterArgContext
• type ILet_Context
• type ILiteralContext
• type IMethodDefinitionContext
• type IModuleExportNameContext
• type INumericLiteralContext
• type IObjectLiteralContext
• type IPrivateIdentifierContext
• type IProgramContext
• type IPropertyAssignmentContext
• type IPropertyNameContext
• type IReservedWordContext
• type IReturnStatementContext
• type ISetterContext
• type ISingleExpressionContext
• type ISourceElementContext
• type ISourceElementsContext
• type IStatementContext
• type IStatementListContext
• type ISwitchStatementContext
• type ITemplateStringAtomContext
• type ITemplateStringLiteralContext
• type IThrowStatementContext
• type ITryStatementContext
• type IVarModifierContext
• type IVariableDeclarationContext
• type IVariableDeclarationListContext
• type IVariableStatementContext
• type IWithStatementContext
• type IYieldStatementContext
• type IdentifierContext
  • func NewEmptyIdentifierContext() *IdentifierContext
  • func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext
  • func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IdentifierContext) As() antlr.TerminalNode
  • func (s *IdentifierContext) Async() antlr.TerminalNode
  • func (s *IdentifierContext) From() antlr.TerminalNode
  • func (s *IdentifierContext) GetParser() antlr.Parser
  • func (s *IdentifierContext) GetRuleContext() antlr.RuleContext
  • func (s *IdentifierContext) Identifier() antlr.TerminalNode
  • func (*IdentifierContext) IsIdentifierContext()
  • func (s *IdentifierContext) NonStrictLet() antlr.TerminalNode
  • func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type IdentifierExpressionContext
  • func NewIdentifierExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierExpressionContext
  • func (s *IdentifierExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IdentifierExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *IdentifierExpressionContext) Identifier() IIdentifierContext
• type IdentifierNameContext
  • func NewEmptyIdentifierNameContext() *IdentifierNameContext
  • func NewIdentifierNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierNameContext
  • func (s *IdentifierNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IdentifierNameContext) GetParser() antlr.Parser
  • func (s *IdentifierNameContext) GetRuleContext() antlr.RuleContext
  • func (s *IdentifierNameContext) Identifier() IIdentifierContext
  • func (*IdentifierNameContext) IsIdentifierNameContext()
  • func (s *IdentifierNameContext) ReservedWord() IReservedWordContext
  • func (s *IdentifierNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type IfStatementContext
  • func NewEmptyIfStatementContext() *IfStatementContext
  • func NewIfStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStatementContext
  • func (s *IfStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *IfStatementContext) AllCloseParen() []antlr.TerminalNode
  • func (s *IfStatementContext) AllElse() []antlr.TerminalNode
  • func (s *IfStatementContext) AllIf() []antlr.TerminalNode
  • func (s *IfStatementContext) AllOpenParen() []antlr.TerminalNode
  • func (s *IfStatementContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *IfStatementContext) AllStatement() []IStatementContext
  • func (s *IfStatementContext) CloseParen(i int) antlr.TerminalNode
  • func (s *IfStatementContext) Else(i int) antlr.TerminalNode
  • func (s *IfStatementContext) ElseBlock() IElseBlockContext
  • func (s *IfStatementContext) GetParser() antlr.Parser
  • func (s *IfStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *IfStatementContext) If(i int) antlr.TerminalNode
  • func (*IfStatementContext) IsIfStatementContext()
  • func (s *IfStatementContext) OpenParen(i int) antlr.TerminalNode
  • func (s *IfStatementContext) SingleExpression(i int) ISingleExpressionContext
  • func (s *IfStatementContext) Statement(i int) IStatementContext
  • func (s *IfStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ImportAliasNameContext
  • func NewEmptyImportAliasNameContext() *ImportAliasNameContext
  • func NewImportAliasNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportAliasNameContext
  • func (s *ImportAliasNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportAliasNameContext) As() antlr.TerminalNode
  • func (s *ImportAliasNameContext) GetParser() antlr.Parser
  • func (s *ImportAliasNameContext) GetRuleContext() antlr.RuleContext
  • func (s *ImportAliasNameContext) ImportedBinding() IImportedBindingContext
  • func (*ImportAliasNameContext) IsImportAliasNameContext()
  • func (s *ImportAliasNameContext) ModuleExportName() IModuleExportNameContext
  • func (s *ImportAliasNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ImportDefaultContext
  • func NewEmptyImportDefaultContext() *ImportDefaultContext
  • func NewImportDefaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportDefaultContext
  • func (s *ImportDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportDefaultContext) AliasName() IAliasNameContext
  • func (s *ImportDefaultContext) Comma() antlr.TerminalNode
  • func (s *ImportDefaultContext) GetParser() antlr.Parser
  • func (s *ImportDefaultContext) GetRuleContext() antlr.RuleContext
  • func (*ImportDefaultContext) IsImportDefaultContext()
  • func (s *ImportDefaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ImportExpressionContext
  • func NewImportExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportExpressionContext
  • func (s *ImportExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportExpressionContext) CloseParen() antlr.TerminalNode
  • func (s *ImportExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *ImportExpressionContext) Import() antlr.TerminalNode
  • func (s *ImportExpressionContext) OpenParen() antlr.TerminalNode
  • func (s *ImportExpressionContext) SingleExpression() ISingleExpressionContext
• type ImportFromBlockContext
  • func NewEmptyImportFromBlockContext() *ImportFromBlockContext
  • func NewImportFromBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportFromBlockContext
  • func (s *ImportFromBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportFromBlockContext) Eos() IEosContext
  • func (s *ImportFromBlockContext) GetParser() antlr.Parser
  • func (s *ImportFromBlockContext) GetRuleContext() antlr.RuleContext
  • func (s *ImportFromBlockContext) ImportDefault() IImportDefaultContext
  • func (s *ImportFromBlockContext) ImportFrom() IImportFromContext
  • func (s *ImportFromBlockContext) ImportModuleItems() IImportModuleItemsContext
  • func (s *ImportFromBlockContext) ImportNamespace() IImportNamespaceContext
  • func (*ImportFromBlockContext) IsImportFromBlockContext()
  • func (s *ImportFromBlockContext) StringLiteral() antlr.TerminalNode
  • func (s *ImportFromBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ImportFromContext
  • func NewEmptyImportFromContext() *ImportFromContext
  • func NewImportFromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportFromContext
  • func (s *ImportFromContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportFromContext) From() antlr.TerminalNode
  • func (s *ImportFromContext) GetParser() antlr.Parser
  • func (s *ImportFromContext) GetRuleContext() antlr.RuleContext
  • func (*ImportFromContext) IsImportFromContext()
  • func (s *ImportFromContext) StringLiteral() antlr.TerminalNode
  • func (s *ImportFromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ImportModuleItemsContext
  • func NewEmptyImportModuleItemsContext() *ImportModuleItemsContext
  • func NewImportModuleItemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportModuleItemsContext
  • func (s *ImportModuleItemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportModuleItemsContext) AllComma() []antlr.TerminalNode
  • func (s *ImportModuleItemsContext) AllImportAliasName() []IImportAliasNameContext
  • func (s *ImportModuleItemsContext) CloseBrace() antlr.TerminalNode
  • func (s *ImportModuleItemsContext) Comma(i int) antlr.TerminalNode
  • func (s *ImportModuleItemsContext) GetParser() antlr.Parser
  • func (s *ImportModuleItemsContext) GetRuleContext() antlr.RuleContext
  • func (s *ImportModuleItemsContext) ImportAliasName(i int) IImportAliasNameContext
  • func (*ImportModuleItemsContext) IsImportModuleItemsContext()
  • func (s *ImportModuleItemsContext) OpenBrace() antlr.TerminalNode
  • func (s *ImportModuleItemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ImportNamespaceContext
  • func NewEmptyImportNamespaceContext() *ImportNamespaceContext
  • func NewImportNamespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportNamespaceContext
  • func (s *ImportNamespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportNamespaceContext) AllIdentifierName() []IIdentifierNameContext
  • func (s *ImportNamespaceContext) As() antlr.TerminalNode
  • func (s *ImportNamespaceContext) GetParser() antlr.Parser
  • func (s *ImportNamespaceContext) GetRuleContext() antlr.RuleContext
  • func (s *ImportNamespaceContext) IdentifierName(i int) IIdentifierNameContext
  • func (*ImportNamespaceContext) IsImportNamespaceContext()
  • func (s *ImportNamespaceContext) Multiply() antlr.TerminalNode
  • func (s *ImportNamespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ImportStatementContext
  • func NewEmptyImportStatementContext() *ImportStatementContext
  • func NewImportStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportStatementContext
  • func (s *ImportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportStatementContext) GetParser() antlr.Parser
  • func (s *ImportStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *ImportStatementContext) Import() antlr.TerminalNode
  • func (s *ImportStatementContext) ImportFromBlock() IImportFromBlockContext
  • func (*ImportStatementContext) IsImportStatementContext()
  • func (s *ImportStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ImportedBindingContext
  • func NewEmptyImportedBindingContext() *ImportedBindingContext
  • func NewImportedBindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportedBindingContext
  • func (s *ImportedBindingContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ImportedBindingContext) Await() antlr.TerminalNode
  • func (s *ImportedBindingContext) GetParser() antlr.Parser
  • func (s *ImportedBindingContext) GetRuleContext() antlr.RuleContext
  • func (s *ImportedBindingContext) Identifier() antlr.TerminalNode
  • func (*ImportedBindingContext) IsImportedBindingContext()
  • func (s *ImportedBindingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *ImportedBindingContext) Yield() antlr.TerminalNode
• type InExpressionContext
  • func NewInExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InExpressionContext
  • func (s *InExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *InExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *InExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *InExpressionContext) In() antlr.TerminalNode
  • func (s *InExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type InitializerContext
  • func NewEmptyInitializerContext() *InitializerContext
  • func NewInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitializerContext
  • func (s *InitializerContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *InitializerContext) Assign() antlr.TerminalNode
  • func (s *InitializerContext) GetParser() antlr.Parser
  • func (s *InitializerContext) GetRuleContext() antlr.RuleContext
  • func (*InitializerContext) IsInitializerContext()
  • func (s *InitializerContext) SingleExpression() ISingleExpressionContext
  • func (s *InitializerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type InstanceofExpressionContext
  • func NewInstanceofExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InstanceofExpressionContext
  • func (s *InstanceofExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *InstanceofExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *InstanceofExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *InstanceofExpressionContext) Instanceof() antlr.TerminalNode
  • func (s *InstanceofExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type IterationStatementContext
  • func NewEmptyIterationStatementContext() *IterationStatementContext
  • func NewIterationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterationStatementContext
  • func (s *IterationStatementContext) CopyAll(ctx *IterationStatementContext)
  • func (s *IterationStatementContext) GetParser() antlr.Parser
  • func (s *IterationStatementContext) GetRuleContext() antlr.RuleContext
  • func (*IterationStatementContext) IsIterationStatementContext()
  • func (s *IterationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type JavaScriptLexer
  • func NewJavaScriptLexer(input antlr.CharStream) *JavaScriptLexer
  • func (l *JavaScriptLexer) Action(localctx antlr.RuleContext, ruleIndex, actionIndex int)
  • func (l *JavaScriptLexer) BackTickInside_Action(localctx antlr.RuleContext, actionIndex int)
  • func (l *JavaScriptLexer) BackTick_Action(localctx antlr.RuleContext, actionIndex int)
  • func (l *JavaScriptLexer) CloseBrace_Action(localctx antlr.RuleContext, actionIndex int)
  • func (p *JavaScriptLexer) HashBangLine_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) Implements_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) Interface_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) NonStrictLet_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) OctalIntegerLiteral_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (l *JavaScriptLexer) OpenBrace_Action(localctx antlr.RuleContext, actionIndex int)
  • func (p *JavaScriptLexer) Package_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) Private_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) Protected_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) Public_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) RegularExpressionLiteral_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (l *JavaScriptLexer) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool
  • func (p *JavaScriptLexer) Static_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptLexer) StrictLet_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (l *JavaScriptLexer) StringLiteral_Action(localctx antlr.RuleContext, actionIndex int)
  • func (p *JavaScriptLexer) TemplateCloseBrace_Sempred(localctx antlr.RuleContext, predIndex int) bool
• type JavaScriptLexerBase
  • func (l *JavaScriptLexerBase) DecreaseTemplateDepth()
  • func (l *JavaScriptLexerBase) IncreaseTemplateDepth()
  • func (l *JavaScriptLexerBase) IsInTemplateString() bool
  • func (l *JavaScriptLexerBase) IsRegexPossible() bool
  • func (l *JavaScriptLexerBase) IsStartOfFile() bool
  • func (l *JavaScriptLexerBase) IsStrictMode() bool
  • func (l *JavaScriptLexerBase) NextToken() antlr.Token
  • func (l *JavaScriptLexerBase) ProcessCloseBrace()
  • func (l *JavaScriptLexerBase) ProcessOpenBrace()
  • func (l *JavaScriptLexerBase) ProcessStringLiteral()
  • func (l *JavaScriptLexerBase) Reset()
• type JavaScriptParser
  • func NewJavaScriptParser(input antlr.TokenStream) *JavaScriptParser
  • func (p *JavaScriptParser) AliasName() (localctx IAliasNameContext)
  • func (p *JavaScriptParser) AnonymousFunction() (localctx IAnonymousFunctionContext)
  • func (p *JavaScriptParser) Argument() (localctx IArgumentContext)
  • func (p *JavaScriptParser) Arguments() (localctx IArgumentsContext)
  • func (p *JavaScriptParser) ArrayElement() (localctx IArrayElementContext)
  • func (p *JavaScriptParser) ArrayLiteral() (localctx IArrayLiteralContext)
  • func (p *JavaScriptParser) ArrowFunctionBody() (localctx IArrowFunctionBodyContext)
  • func (p *JavaScriptParser) ArrowFunctionParameters() (localctx IArrowFunctionParametersContext)
  • func (p *JavaScriptParser) Assignable() (localctx IAssignableContext)
  • func (p *JavaScriptParser) AssignmentOperator() (localctx IAssignmentOperatorContext)
  • func (p *JavaScriptParser) BigintLiteral() (localctx IBigintLiteralContext)
  • func (p *JavaScriptParser) Block() (localctx IBlockContext)
  • func (p *JavaScriptParser) BreakStatement() (localctx IBreakStatementContext)
  • func (p *JavaScriptParser) BreakStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) CaseBlock() (localctx ICaseBlockContext)
  • func (p *JavaScriptParser) CaseClause() (localctx ICaseClauseContext)
  • func (p *JavaScriptParser) CaseClauses() (localctx ICaseClausesContext)
  • func (p *JavaScriptParser) CatchProduction() (localctx ICatchProductionContext)
  • func (p *JavaScriptParser) ClassDeclaration() (localctx IClassDeclarationContext)
  • func (p *JavaScriptParser) ClassElement() (localctx IClassElementContext)
  • func (p *JavaScriptParser) ClassElementName() (localctx IClassElementNameContext)
  • func (p *JavaScriptParser) ClassElement_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) ClassTail() (localctx IClassTailContext)
  • func (p *JavaScriptParser) ContinueStatement() (localctx IContinueStatementContext)
  • func (p *JavaScriptParser) ContinueStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) DebuggerStatement() (localctx IDebuggerStatementContext)
  • func (p *JavaScriptParser) Declaration() (localctx IDeclarationContext)
  • func (p *JavaScriptParser) DefaultClause() (localctx IDefaultClauseContext)
  • func (p *JavaScriptParser) ElementList() (localctx IElementListContext)
  • func (p *JavaScriptParser) ElseBlock() (localctx IElseBlockContext)
  • func (p *JavaScriptParser) EmptyStatement_() (localctx IEmptyStatement_Context)
  • func (p *JavaScriptParser) Eos() (localctx IEosContext)
  • func (p *JavaScriptParser) Eos_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) ExportAliasName() (localctx IExportAliasNameContext)
  • func (p *JavaScriptParser) ExportFromBlock() (localctx IExportFromBlockContext)
  • func (p *JavaScriptParser) ExportModuleItems() (localctx IExportModuleItemsContext)
  • func (p *JavaScriptParser) ExportStatement() (localctx IExportStatementContext)
  • func (p *JavaScriptParser) ExpressionSequence() (localctx IExpressionSequenceContext)
  • func (p *JavaScriptParser) ExpressionStatement() (localctx IExpressionStatementContext)
  • func (p *JavaScriptParser) ExpressionStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) FieldDefinition() (localctx IFieldDefinitionContext)
  • func (p *JavaScriptParser) FinallyProduction() (localctx IFinallyProductionContext)
  • func (p *JavaScriptParser) ForFirst() (localctx IForFirstContext)
  • func (p *JavaScriptParser) ForSecond() (localctx IForSecondContext)
  • func (p *JavaScriptParser) ForThird() (localctx IForThirdContext)
  • func (p *JavaScriptParser) FormalParameterArg() (localctx IFormalParameterArgContext)
  • func (p *JavaScriptParser) FormalParameterList() (localctx IFormalParameterListContext)
  • func (p *JavaScriptParser) FunctionBody() (localctx IFunctionBodyContext)
  • func (p *JavaScriptParser) FunctionDeclaration() (localctx IFunctionDeclarationContext)
  • func (p *JavaScriptParser) Getter() (localctx IGetterContext)
  • func (p *JavaScriptParser) Getter_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) Identifier() (localctx IIdentifierContext)
  • func (p *JavaScriptParser) IdentifierName() (localctx IIdentifierNameContext)
  • func (p *JavaScriptParser) IfStatement() (localctx IIfStatementContext)
  • func (p *JavaScriptParser) ImportAliasName() (localctx IImportAliasNameContext)
  • func (p *JavaScriptParser) ImportDefault() (localctx IImportDefaultContext)
  • func (p *JavaScriptParser) ImportFrom() (localctx IImportFromContext)
  • func (p *JavaScriptParser) ImportFromBlock() (localctx IImportFromBlockContext)
  • func (p *JavaScriptParser) ImportModuleItems() (localctx IImportModuleItemsContext)
  • func (p *JavaScriptParser) ImportNamespace() (localctx IImportNamespaceContext)
  • func (p *JavaScriptParser) ImportStatement() (localctx IImportStatementContext)
  • func (p *JavaScriptParser) ImportedBinding() (localctx IImportedBindingContext)
  • func (p *JavaScriptParser) Initializer() (localctx IInitializerContext)
  • func (p *JavaScriptParser) IterationStatement() (localctx IIterationStatementContext)
  • func (p *JavaScriptParser) IterationStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) Keyword() (localctx IKeywordContext)
  • func (p *JavaScriptParser) LabelledStatement() (localctx ILabelledStatementContext)
  • func (p *JavaScriptParser) LastFormalParameterArg() (localctx ILastFormalParameterArgContext)
  • func (p *JavaScriptParser) Let_() (localctx ILet_Context)
  • func (p *JavaScriptParser) Literal() (localctx ILiteralContext)
  • func (p *JavaScriptParser) MethodDefinition() (localctx IMethodDefinitionContext)
  • func (p *JavaScriptParser) MethodDefinition_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) ModuleExportName() (localctx IModuleExportNameContext)
  • func (p *JavaScriptParser) NumericLiteral() (localctx INumericLiteralContext)
  • func (p *JavaScriptParser) ObjectLiteral() (localctx IObjectLiteralContext)
  • func (p *JavaScriptParser) PrivateIdentifier() (localctx IPrivateIdentifierContext)
  • func (p *JavaScriptParser) Program() (localctx IProgramContext)
  • func (p *JavaScriptParser) PropertyAssignment() (localctx IPropertyAssignmentContext)
  • func (p *JavaScriptParser) PropertyName() (localctx IPropertyNameContext)
  • func (p *JavaScriptParser) ReservedWord() (localctx IReservedWordContext)
  • func (p *JavaScriptParser) ReturnStatement() (localctx IReturnStatementContext)
  • func (p *JavaScriptParser) ReturnStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool
  • func (p *JavaScriptParser) Setter() (localctx ISetterContext)
  • func (p *JavaScriptParser) Setter_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) SingleExpression() (localctx ISingleExpressionContext)
  • func (p *JavaScriptParser) SingleExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) SourceElement() (localctx ISourceElementContext)
  • func (p *JavaScriptParser) SourceElements() (localctx ISourceElementsContext)
  • func (p *JavaScriptParser) Statement() (localctx IStatementContext)
  • func (p *JavaScriptParser) StatementList() (localctx IStatementListContext)
  • func (p *JavaScriptParser) SwitchStatement() (localctx ISwitchStatementContext)
  • func (p *JavaScriptParser) TemplateStringAtom() (localctx ITemplateStringAtomContext)
  • func (p *JavaScriptParser) TemplateStringLiteral() (localctx ITemplateStringLiteralContext)
  • func (p *JavaScriptParser) ThrowStatement() (localctx IThrowStatementContext)
  • func (p *JavaScriptParser) ThrowStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) TryStatement() (localctx ITryStatementContext)
  • func (p *JavaScriptParser) VarModifier() (localctx IVarModifierContext)
  • func (p *JavaScriptParser) VariableDeclaration() (localctx IVariableDeclarationContext)
  • func (p *JavaScriptParser) VariableDeclarationList() (localctx IVariableDeclarationListContext)
  • func (p *JavaScriptParser) VariableStatement() (localctx IVariableStatementContext)
  • func (p *JavaScriptParser) WithStatement() (localctx IWithStatementContext)
  • func (p *JavaScriptParser) YieldStatement() (localctx IYieldStatementContext)
  • func (p *JavaScriptParser) YieldStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool
• type JavaScriptParserBase
• type JavaScriptParserVisitor
• type KeywordContext
  • func NewEmptyKeywordContext() *KeywordContext
  • func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext
  • func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *KeywordContext) As() antlr.TerminalNode
  • func (s *KeywordContext) Async() antlr.TerminalNode
  • func (s *KeywordContext) Await() antlr.TerminalNode
  • func (s *KeywordContext) Break() antlr.TerminalNode
  • func (s *KeywordContext) Case() antlr.TerminalNode
  • func (s *KeywordContext) Catch() antlr.TerminalNode
  • func (s *KeywordContext) Class() antlr.TerminalNode
  • func (s *KeywordContext) Const() antlr.TerminalNode
  • func (s *KeywordContext) Continue() antlr.TerminalNode
  • func (s *KeywordContext) Debugger() antlr.TerminalNode
  • func (s *KeywordContext) Default() antlr.TerminalNode
  • func (s *KeywordContext) Delete() antlr.TerminalNode
  • func (s *KeywordContext) Do() antlr.TerminalNode
  • func (s *KeywordContext) Else() antlr.TerminalNode
  • func (s *KeywordContext) Enum() antlr.TerminalNode
  • func (s *KeywordContext) Export() antlr.TerminalNode
  • func (s *KeywordContext) Extends() antlr.TerminalNode
  • func (s *KeywordContext) Finally() antlr.TerminalNode
  • func (s *KeywordContext) For() antlr.TerminalNode
  • func (s *KeywordContext) From() antlr.TerminalNode
  • func (s *KeywordContext) Function_() antlr.TerminalNode
  • func (s *KeywordContext) GetParser() antlr.Parser
  • func (s *KeywordContext) GetRuleContext() antlr.RuleContext
  • func (s *KeywordContext) If() antlr.TerminalNode
  • func (s *KeywordContext) Implements() antlr.TerminalNode
  • func (s *KeywordContext) Import() antlr.TerminalNode
  • func (s *KeywordContext) In() antlr.TerminalNode
  • func (s *KeywordContext) Instanceof() antlr.TerminalNode
  • func (s *KeywordContext) Interface() antlr.TerminalNode
  • func (*KeywordContext) IsKeywordContext()
  • func (s *KeywordContext) Let_() ILet_Context
  • func (s *KeywordContext) New() antlr.TerminalNode
  • func (s *KeywordContext) Package() antlr.TerminalNode
  • func (s *KeywordContext) Private() antlr.TerminalNode
  • func (s *KeywordContext) Protected() antlr.TerminalNode
  • func (s *KeywordContext) Public() antlr.TerminalNode
  • func (s *KeywordContext) Return() antlr.TerminalNode
  • func (s *KeywordContext) Static() antlr.TerminalNode
  • func (s *KeywordContext) Super() antlr.TerminalNode
  • func (s *KeywordContext) Switch() antlr.TerminalNode
  • func (s *KeywordContext) This() antlr.TerminalNode
  • func (s *KeywordContext) Throw() antlr.TerminalNode
  • func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *KeywordContext) Try() antlr.TerminalNode
  • func (s *KeywordContext) Typeof() antlr.TerminalNode
  • func (s *KeywordContext) Var() antlr.TerminalNode
  • func (s *KeywordContext) Void() antlr.TerminalNode
  • func (s *KeywordContext) While() antlr.TerminalNode
  • func (s *KeywordContext) With() antlr.TerminalNode
  • func (s *KeywordContext) Yield() antlr.TerminalNode
• type LabelledStatementContext
  • func NewEmptyLabelledStatementContext() *LabelledStatementContext
  • func NewLabelledStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabelledStatementContext
  • func (s *LabelledStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LabelledStatementContext) Colon() antlr.TerminalNode
  • func (s *LabelledStatementContext) GetParser() antlr.Parser
  • func (s *LabelledStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *LabelledStatementContext) Identifier() IIdentifierContext
  • func (*LabelledStatementContext) IsLabelledStatementContext()
  • func (s *LabelledStatementContext) Statement() IStatementContext
  • func (s *LabelledStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type LastFormalParameterArgContext
  • func NewEmptyLastFormalParameterArgContext() *LastFormalParameterArgContext
  • func NewLastFormalParameterArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LastFormalParameterArgContext
  • func (s *LastFormalParameterArgContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LastFormalParameterArgContext) Ellipsis() antlr.TerminalNode
  • func (s *LastFormalParameterArgContext) GetParser() antlr.Parser
  • func (s *LastFormalParameterArgContext) GetRuleContext() antlr.RuleContext
  • func (*LastFormalParameterArgContext) IsLastFormalParameterArgContext()
  • func (s *LastFormalParameterArgContext) SingleExpression() ISingleExpressionContext
  • func (s *LastFormalParameterArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type Let_Context
  • func NewEmptyLet_Context() *Let_Context
  • func NewLet_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Let_Context
  • func (s *Let_Context) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *Let_Context) GetParser() antlr.Parser
  • func (s *Let_Context) GetRuleContext() antlr.RuleContext
  • func (*Let_Context) IsLet_Context()
  • func (s *Let_Context) NonStrictLet() antlr.TerminalNode
  • func (s *Let_Context) StrictLet() antlr.TerminalNode
  • func (s *Let_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type LiteralContext
  • func NewEmptyLiteralContext() *LiteralContext
  • func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext
  • func (s *LiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralContext) BigintLiteral() IBigintLiteralContext
  • func (s *LiteralContext) BooleanLiteral() antlr.TerminalNode
  • func (s *LiteralContext) GetParser() antlr.Parser
  • func (s *LiteralContext) GetRuleContext() antlr.RuleContext
  • func (*LiteralContext) IsLiteralContext()
  • func (s *LiteralContext) NullLiteral() antlr.TerminalNode
  • func (s *LiteralContext) NumericLiteral() INumericLiteralContext
  • func (s *LiteralContext) RegularExpressionLiteral() antlr.TerminalNode
  • func (s *LiteralContext) StringLiteral() antlr.TerminalNode
  • func (s *LiteralContext) TemplateStringLiteral() ITemplateStringLiteralContext
  • func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type LiteralExpressionContext
  • func NewLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralExpressionContext
  • func (s *LiteralExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LiteralExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *LiteralExpressionContext) Literal() ILiteralContext
• type LogicalAndExpressionContext
  • func NewLogicalAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalAndExpressionContext
  • func (s *LogicalAndExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LogicalAndExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *LogicalAndExpressionContext) And() antlr.TerminalNode
  • func (s *LogicalAndExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *LogicalAndExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type LogicalOrExpressionContext
  • func NewLogicalOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalOrExpressionContext
  • func (s *LogicalOrExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *LogicalOrExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *LogicalOrExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *LogicalOrExpressionContext) Or() antlr.TerminalNode
  • func (s *LogicalOrExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type MemberDotExpressionContext
  • func NewMemberDotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberDotExpressionContext
  • func (s *MemberDotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *MemberDotExpressionContext) Dot() antlr.TerminalNode
  • func (s *MemberDotExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *MemberDotExpressionContext) Hashtag() antlr.TerminalNode
  • func (s *MemberDotExpressionContext) IdentifierName() IIdentifierNameContext
  • func (s *MemberDotExpressionContext) QuestionMark() antlr.TerminalNode
  • func (s *MemberDotExpressionContext) SingleExpression() ISingleExpressionContext
• type MemberIndexExpressionContext
  • func NewMemberIndexExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberIndexExpressionContext
  • func (s *MemberIndexExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *MemberIndexExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *MemberIndexExpressionContext) CloseBracket() antlr.TerminalNode
  • func (s *MemberIndexExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *MemberIndexExpressionContext) OpenBracket() antlr.TerminalNode
  • func (s *MemberIndexExpressionContext) QuestionMarkDot() antlr.TerminalNode
  • func (s *MemberIndexExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type MetaExpressionContext
  • func NewMetaExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MetaExpressionContext
  • func (s *MetaExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *MetaExpressionContext) Dot() antlr.TerminalNode
  • func (s *MetaExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *MetaExpressionContext) Identifier() IIdentifierContext
  • func (s *MetaExpressionContext) New() antlr.TerminalNode
• type MethodDefinitionContext
  • func NewEmptyMethodDefinitionContext() *MethodDefinitionContext
  • func NewMethodDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodDefinitionContext
  • func (s *MethodDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *MethodDefinitionContext) Async() antlr.TerminalNode
  • func (s *MethodDefinitionContext) ClassElementName() IClassElementNameContext
  • func (s *MethodDefinitionContext) CloseParen() antlr.TerminalNode
  • func (s *MethodDefinitionContext) FormalParameterList() IFormalParameterListContext
  • func (s *MethodDefinitionContext) FunctionBody() IFunctionBodyContext
  • func (s *MethodDefinitionContext) GetParser() antlr.Parser
  • func (s *MethodDefinitionContext) GetRuleContext() antlr.RuleContext
  • func (s *MethodDefinitionContext) Getter() IGetterContext
  • func (*MethodDefinitionContext) IsMethodDefinitionContext()
  • func (s *MethodDefinitionContext) Multiply() antlr.TerminalNode
  • func (s *MethodDefinitionContext) OpenParen() antlr.TerminalNode
  • func (s *MethodDefinitionContext) Setter() ISetterContext
  • func (s *MethodDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ModuleExportNameContext
  • func NewEmptyModuleExportNameContext() *ModuleExportNameContext
  • func NewModuleExportNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleExportNameContext
  • func (s *ModuleExportNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ModuleExportNameContext) GetParser() antlr.Parser
  • func (s *ModuleExportNameContext) GetRuleContext() antlr.RuleContext
  • func (s *ModuleExportNameContext) IdentifierName() IIdentifierNameContext
  • func (*ModuleExportNameContext) IsModuleExportNameContext()
  • func (s *ModuleExportNameContext) StringLiteral() antlr.TerminalNode
  • func (s *ModuleExportNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type MultiplicativeExpressionContext
  • func NewMultiplicativeExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MultiplicativeExpressionContext
  • func (s *MultiplicativeExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *MultiplicativeExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *MultiplicativeExpressionContext) Divide() antlr.TerminalNode
  • func (s *MultiplicativeExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *MultiplicativeExpressionContext) Modulus() antlr.TerminalNode
  • func (s *MultiplicativeExpressionContext) Multiply() antlr.TerminalNode
  • func (s *MultiplicativeExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type NewExpressionContext
  • func NewNewExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NewExpressionContext
  • func (s *NewExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *NewExpressionContext) Arguments() IArgumentsContext
  • func (s *NewExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *NewExpressionContext) New() antlr.TerminalNode
  • func (s *NewExpressionContext) SingleExpression() ISingleExpressionContext
• type NotExpressionContext
  • func NewNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExpressionContext
  • func (s *NotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *NotExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *NotExpressionContext) Not() antlr.TerminalNode
  • func (s *NotExpressionContext) SingleExpression() ISingleExpressionContext
• type NumericLiteralContext
  • func NewEmptyNumericLiteralContext() *NumericLiteralContext
  • func NewNumericLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericLiteralContext
  • func (s *NumericLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *NumericLiteralContext) BinaryIntegerLiteral() antlr.TerminalNode
  • func (s *NumericLiteralContext) DecimalLiteral() antlr.TerminalNode
  • func (s *NumericLiteralContext) GetParser() antlr.Parser
  • func (s *NumericLiteralContext) GetRuleContext() antlr.RuleContext
  • func (s *NumericLiteralContext) HexIntegerLiteral() antlr.TerminalNode
  • func (*NumericLiteralContext) IsNumericLiteralContext()
  • func (s *NumericLiteralContext) OctalIntegerLiteral() antlr.TerminalNode
  • func (s *NumericLiteralContext) OctalIntegerLiteral2() antlr.TerminalNode
  • func (s *NumericLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ObjectLiteralContext
  • func NewEmptyObjectLiteralContext() *ObjectLiteralContext
  • func NewObjectLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectLiteralContext
  • func (s *ObjectLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ObjectLiteralContext) AllComma() []antlr.TerminalNode
  • func (s *ObjectLiteralContext) AllPropertyAssignment() []IPropertyAssignmentContext
  • func (s *ObjectLiteralContext) CloseBrace() antlr.TerminalNode
  • func (s *ObjectLiteralContext) Comma(i int) antlr.TerminalNode
  • func (s *ObjectLiteralContext) GetParser() antlr.Parser
  • func (s *ObjectLiteralContext) GetRuleContext() antlr.RuleContext
  • func (*ObjectLiteralContext) IsObjectLiteralContext()
  • func (s *ObjectLiteralContext) OpenBrace() antlr.TerminalNode
  • func (s *ObjectLiteralContext) PropertyAssignment(i int) IPropertyAssignmentContext
  • func (s *ObjectLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ObjectLiteralExpressionContext
  • func NewObjectLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjectLiteralExpressionContext
  • func (s *ObjectLiteralExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ObjectLiteralExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *ObjectLiteralExpressionContext) ObjectLiteral() IObjectLiteralContext
• type OptionalChainExpressionContext
  • func NewOptionalChainExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OptionalChainExpressionContext
  • func (s *OptionalChainExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *OptionalChainExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *OptionalChainExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *OptionalChainExpressionContext) QuestionMarkDot() antlr.TerminalNode
  • func (s *OptionalChainExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type ParenthesizedExpressionContext
  • func NewParenthesizedExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesizedExpressionContext
  • func (s *ParenthesizedExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ParenthesizedExpressionContext) CloseParen() antlr.TerminalNode
  • func (s *ParenthesizedExpressionContext) ExpressionSequence() IExpressionSequenceContext
  • func (s *ParenthesizedExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *ParenthesizedExpressionContext) OpenParen() antlr.TerminalNode
• type PostDecreaseExpressionContext
  • func NewPostDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostDecreaseExpressionContext
  • func (s *PostDecreaseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PostDecreaseExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *PostDecreaseExpressionContext) MinusMinus() antlr.TerminalNode
  • func (s *PostDecreaseExpressionContext) SingleExpression() ISingleExpressionContext
• type PostIncrementExpressionContext
  • func NewPostIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostIncrementExpressionContext
  • func (s *PostIncrementExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PostIncrementExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *PostIncrementExpressionContext) PlusPlus() antlr.TerminalNode
  • func (s *PostIncrementExpressionContext) SingleExpression() ISingleExpressionContext
• type PowerExpressionContext
  • func NewPowerExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PowerExpressionContext
  • func (s *PowerExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PowerExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *PowerExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *PowerExpressionContext) Power() antlr.TerminalNode
  • func (s *PowerExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type PreDecreaseExpressionContext
  • func NewPreDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreDecreaseExpressionContext
  • func (s *PreDecreaseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PreDecreaseExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *PreDecreaseExpressionContext) MinusMinus() antlr.TerminalNode
  • func (s *PreDecreaseExpressionContext) SingleExpression() ISingleExpressionContext
• type PreIncrementExpressionContext
  • func NewPreIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreIncrementExpressionContext
  • func (s *PreIncrementExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PreIncrementExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *PreIncrementExpressionContext) PlusPlus() antlr.TerminalNode
  • func (s *PreIncrementExpressionContext) SingleExpression() ISingleExpressionContext
• type PrivateIdentifierContext
  • func NewEmptyPrivateIdentifierContext() *PrivateIdentifierContext
  • func NewPrivateIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivateIdentifierContext
  • func (s *PrivateIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PrivateIdentifierContext) GetParser() antlr.Parser
  • func (s *PrivateIdentifierContext) GetRuleContext() antlr.RuleContext
  • func (s *PrivateIdentifierContext) Hashtag() antlr.TerminalNode
  • func (s *PrivateIdentifierContext) IdentifierName() IIdentifierNameContext
  • func (*PrivateIdentifierContext) IsPrivateIdentifierContext()
  • func (s *PrivateIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ProgramContext
  • func NewEmptyProgramContext() *ProgramContext
  • func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext
  • func (s *ProgramContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ProgramContext) EOF() antlr.TerminalNode
  • func (s *ProgramContext) GetParser() antlr.Parser
  • func (s *ProgramContext) GetRuleContext() antlr.RuleContext
  • func (s *ProgramContext) HashBangLine() antlr.TerminalNode
  • func (*ProgramContext) IsProgramContext()
  • func (s *ProgramContext) SourceElements() ISourceElementsContext
  • func (s *ProgramContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type PropertyAssignmentContext
  • func NewEmptyPropertyAssignmentContext() *PropertyAssignmentContext
  • func NewPropertyAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyAssignmentContext
  • func (s *PropertyAssignmentContext) CopyAll(ctx *PropertyAssignmentContext)
  • func (s *PropertyAssignmentContext) GetParser() antlr.Parser
  • func (s *PropertyAssignmentContext) GetRuleContext() antlr.RuleContext
  • func (*PropertyAssignmentContext) IsPropertyAssignmentContext()
  • func (s *PropertyAssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type PropertyExpressionAssignmentContext
  • func NewPropertyExpressionAssignmentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyExpressionAssignmentContext
  • func (s *PropertyExpressionAssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PropertyExpressionAssignmentContext) Colon() antlr.TerminalNode
  • func (s *PropertyExpressionAssignmentContext) GetRuleContext() antlr.RuleContext
  • func (s *PropertyExpressionAssignmentContext) PropertyName() IPropertyNameContext
  • func (s *PropertyExpressionAssignmentContext) SingleExpression() ISingleExpressionContext
• type PropertyGetterContext
  • func NewPropertyGetterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyGetterContext
  • func (s *PropertyGetterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PropertyGetterContext) CloseParen() antlr.TerminalNode
  • func (s *PropertyGetterContext) FunctionBody() IFunctionBodyContext
  • func (s *PropertyGetterContext) GetRuleContext() antlr.RuleContext
  • func (s *PropertyGetterContext) Getter() IGetterContext
  • func (s *PropertyGetterContext) OpenParen() antlr.TerminalNode
• type PropertyNameContext
  • func NewEmptyPropertyNameContext() *PropertyNameContext
  • func NewPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyNameContext
  • func (s *PropertyNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PropertyNameContext) CloseBracket() antlr.TerminalNode
  • func (s *PropertyNameContext) GetParser() antlr.Parser
  • func (s *PropertyNameContext) GetRuleContext() antlr.RuleContext
  • func (s *PropertyNameContext) IdentifierName() IIdentifierNameContext
  • func (*PropertyNameContext) IsPropertyNameContext()
  • func (s *PropertyNameContext) NumericLiteral() INumericLiteralContext
  • func (s *PropertyNameContext) OpenBracket() antlr.TerminalNode
  • func (s *PropertyNameContext) SingleExpression() ISingleExpressionContext
  • func (s *PropertyNameContext) StringLiteral() antlr.TerminalNode
  • func (s *PropertyNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type PropertySetterContext
  • func NewPropertySetterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertySetterContext
  • func (s *PropertySetterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PropertySetterContext) CloseParen() antlr.TerminalNode
  • func (s *PropertySetterContext) FormalParameterArg() IFormalParameterArgContext
  • func (s *PropertySetterContext) FunctionBody() IFunctionBodyContext
  • func (s *PropertySetterContext) GetRuleContext() antlr.RuleContext
  • func (s *PropertySetterContext) OpenParen() antlr.TerminalNode
  • func (s *PropertySetterContext) Setter() ISetterContext
• type PropertyShorthandContext
  • func NewPropertyShorthandContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyShorthandContext
  • func (s *PropertyShorthandContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PropertyShorthandContext) Ellipsis() antlr.TerminalNode
  • func (s *PropertyShorthandContext) GetRuleContext() antlr.RuleContext
  • func (s *PropertyShorthandContext) SingleExpression() ISingleExpressionContext
• type RelationalExpressionContext
  • func NewRelationalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelationalExpressionContext
  • func (s *RelationalExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *RelationalExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *RelationalExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *RelationalExpressionContext) GreaterThanEquals() antlr.TerminalNode
  • func (s *RelationalExpressionContext) LessThan() antlr.TerminalNode
  • func (s *RelationalExpressionContext) LessThanEquals() antlr.TerminalNode
  • func (s *RelationalExpressionContext) MoreThan() antlr.TerminalNode
  • func (s *RelationalExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type ReservedWordContext
  • func NewEmptyReservedWordContext() *ReservedWordContext
  • func NewReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReservedWordContext
  • func (s *ReservedWordContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ReservedWordContext) BooleanLiteral() antlr.TerminalNode
  • func (s *ReservedWordContext) GetParser() antlr.Parser
  • func (s *ReservedWordContext) GetRuleContext() antlr.RuleContext
  • func (*ReservedWordContext) IsReservedWordContext()
  • func (s *ReservedWordContext) Keyword() IKeywordContext
  • func (s *ReservedWordContext) NullLiteral() antlr.TerminalNode
  • func (s *ReservedWordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type ReturnStatementContext
  • func NewEmptyReturnStatementContext() *ReturnStatementContext
  • func NewReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStatementContext
  • func (s *ReturnStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ReturnStatementContext) Eos() IEosContext
  • func (s *ReturnStatementContext) ExpressionSequence() IExpressionSequenceContext
  • func (s *ReturnStatementContext) GetParser() antlr.Parser
  • func (s *ReturnStatementContext) GetRuleContext() antlr.RuleContext
  • func (*ReturnStatementContext) IsReturnStatementContext()
  • func (s *ReturnStatementContext) Return() antlr.TerminalNode
  • func (s *ReturnStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type SetterContext
  • func NewEmptySetterContext() *SetterContext
  • func NewSetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetterContext
  • func (s *SetterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *SetterContext) ClassElementName() IClassElementNameContext
  • func (s *SetterContext) GetParser() antlr.Parser
  • func (s *SetterContext) GetRuleContext() antlr.RuleContext
  • func (s *SetterContext) Identifier() IIdentifierContext
  • func (*SetterContext) IsSetterContext()
  • func (s *SetterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type SingleExpressionContext
  • func NewEmptySingleExpressionContext() *SingleExpressionContext
  • func NewSingleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleExpressionContext
  • func (s *SingleExpressionContext) CopyAll(ctx *SingleExpressionContext)
  • func (s *SingleExpressionContext) GetParser() antlr.Parser
  • func (s *SingleExpressionContext) GetRuleContext() antlr.RuleContext
  • func (*SingleExpressionContext) IsSingleExpressionContext()
  • func (s *SingleExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type SourceElementContext
  • func NewEmptySourceElementContext() *SourceElementContext
  • func NewSourceElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SourceElementContext
  • func (s *SourceElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *SourceElementContext) GetParser() antlr.Parser
  • func (s *SourceElementContext) GetRuleContext() antlr.RuleContext
  • func (*SourceElementContext) IsSourceElementContext()
  • func (s *SourceElementContext) Statement() IStatementContext
  • func (s *SourceElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type SourceElementsContext
  • func NewEmptySourceElementsContext() *SourceElementsContext
  • func NewSourceElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SourceElementsContext
  • func (s *SourceElementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *SourceElementsContext) AllSourceElement() []ISourceElementContext
  • func (s *SourceElementsContext) GetParser() antlr.Parser
  • func (s *SourceElementsContext) GetRuleContext() antlr.RuleContext
  • func (*SourceElementsContext) IsSourceElementsContext()
  • func (s *SourceElementsContext) SourceElement(i int) ISourceElementContext
  • func (s *SourceElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type StatementContext
  • func NewEmptyStatementContext() *StatementContext
  • func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext
  • func (s *StatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StatementContext) Block() IBlockContext
  • func (s *StatementContext) BreakStatement() IBreakStatementContext
  • func (s *StatementContext) ClassDeclaration() IClassDeclarationContext
  • func (s *StatementContext) ContinueStatement() IContinueStatementContext
  • func (s *StatementContext) DebuggerStatement() IDebuggerStatementContext
  • func (s *StatementContext) EmptyStatement_() IEmptyStatement_Context
  • func (s *StatementContext) ExportStatement() IExportStatementContext
  • func (s *StatementContext) ExpressionStatement() IExpressionStatementContext
  • func (s *StatementContext) FunctionDeclaration() IFunctionDeclarationContext
  • func (s *StatementContext) GetParser() antlr.Parser
  • func (s *StatementContext) GetRuleContext() antlr.RuleContext
  • func (s *StatementContext) IfStatement() IIfStatementContext
  • func (s *StatementContext) ImportStatement() IImportStatementContext
  • func (*StatementContext) IsStatementContext()
  • func (s *StatementContext) IterationStatement() IIterationStatementContext
  • func (s *StatementContext) LabelledStatement() ILabelledStatementContext
  • func (s *StatementContext) ReturnStatement() IReturnStatementContext
  • func (s *StatementContext) SwitchStatement() ISwitchStatementContext
  • func (s *StatementContext) ThrowStatement() IThrowStatementContext
  • func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *StatementContext) TryStatement() ITryStatementContext
  • func (s *StatementContext) VariableStatement() IVariableStatementContext
  • func (s *StatementContext) WithStatement() IWithStatementContext
  • func (s *StatementContext) YieldStatement() IYieldStatementContext
• type StatementListContext
  • func NewEmptyStatementListContext() *StatementListContext
  • func NewStatementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementListContext
  • func (s *StatementListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StatementListContext) AllStatement() []IStatementContext
  • func (s *StatementListContext) GetParser() antlr.Parser
  • func (s *StatementListContext) GetRuleContext() antlr.RuleContext
  • func (*StatementListContext) IsStatementListContext()
  • func (s *StatementListContext) Statement(i int) IStatementContext
  • func (s *StatementListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type SuperExpressionContext
  • func NewSuperExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SuperExpressionContext
  • func (s *SuperExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *SuperExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *SuperExpressionContext) Super() antlr.TerminalNode
• type SwitchStatementContext
  • func NewEmptySwitchStatementContext() *SwitchStatementContext
  • func NewSwitchStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchStatementContext
  • func (s *SwitchStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *SwitchStatementContext) CaseBlock() ICaseBlockContext
  • func (s *SwitchStatementContext) CloseParen() antlr.TerminalNode
  • func (s *SwitchStatementContext) GetParser() antlr.Parser
  • func (s *SwitchStatementContext) GetRuleContext() antlr.RuleContext
  • func (*SwitchStatementContext) IsSwitchStatementContext()
  • func (s *SwitchStatementContext) OpenParen() antlr.TerminalNode
  • func (s *SwitchStatementContext) SingleExpression() ISingleExpressionContext
  • func (s *SwitchStatementContext) Switch() antlr.TerminalNode
  • func (s *SwitchStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type TemplateStringAtomContext
  • func NewEmptyTemplateStringAtomContext() *TemplateStringAtomContext
  • func NewTemplateStringAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemplateStringAtomContext
  • func (s *TemplateStringAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TemplateStringAtomContext) GetParser() antlr.Parser
  • func (s *TemplateStringAtomContext) GetRuleContext() antlr.RuleContext
  • func (*TemplateStringAtomContext) IsTemplateStringAtomContext()
  • func (s *TemplateStringAtomContext) SingleExpression() ISingleExpressionContext
  • func (s *TemplateStringAtomContext) TemplateCloseBrace() antlr.TerminalNode
  • func (s *TemplateStringAtomContext) TemplateStringAtom() antlr.TerminalNode
  • func (s *TemplateStringAtomContext) TemplateStringStartExpression() antlr.TerminalNode
  • func (s *TemplateStringAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type TemplateStringExpressionContext
  • func NewTemplateStringExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TemplateStringExpressionContext
  • func (s *TemplateStringExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TemplateStringExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *TemplateStringExpressionContext) SingleExpression() ISingleExpressionContext
  • func (s *TemplateStringExpressionContext) TemplateStringLiteral() ITemplateStringLiteralContext
• type TemplateStringLiteralContext
  • func NewEmptyTemplateStringLiteralContext() *TemplateStringLiteralContext
  • func NewTemplateStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemplateStringLiteralContext
  • func (s *TemplateStringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TemplateStringLiteralContext) AllBackTick() []antlr.TerminalNode
  • func (s *TemplateStringLiteralContext) AllTemplateStringAtom() []ITemplateStringAtomContext
  • func (s *TemplateStringLiteralContext) BackTick(i int) antlr.TerminalNode
  • func (s *TemplateStringLiteralContext) GetParser() antlr.Parser
  • func (s *TemplateStringLiteralContext) GetRuleContext() antlr.RuleContext
  • func (*TemplateStringLiteralContext) IsTemplateStringLiteralContext()
  • func (s *TemplateStringLiteralContext) TemplateStringAtom(i int) ITemplateStringAtomContext
  • func (s *TemplateStringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type TernaryExpressionContext
  • func NewTernaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TernaryExpressionContext
  • func (s *TernaryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TernaryExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *TernaryExpressionContext) Colon() antlr.TerminalNode
  • func (s *TernaryExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *TernaryExpressionContext) QuestionMark() antlr.TerminalNode
  • func (s *TernaryExpressionContext) SingleExpression(i int) ISingleExpressionContext
• type ThisExpressionContext
  • func NewThisExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ThisExpressionContext
  • func (s *ThisExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ThisExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *ThisExpressionContext) This() antlr.TerminalNode
• type ThrowStatementContext
  • func NewEmptyThrowStatementContext() *ThrowStatementContext
  • func NewThrowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThrowStatementContext
  • func (s *ThrowStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ThrowStatementContext) Eos() IEosContext
  • func (s *ThrowStatementContext) ExpressionSequence() IExpressionSequenceContext
  • func (s *ThrowStatementContext) GetParser() antlr.Parser
  • func (s *ThrowStatementContext) GetRuleContext() antlr.RuleContext
  • func (*ThrowStatementContext) IsThrowStatementContext()
  • func (s *ThrowStatementContext) Throw() antlr.TerminalNode
  • func (s *ThrowStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type TryStatementContext
  • func NewEmptyTryStatementContext() *TryStatementContext
  • func NewTryStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TryStatementContext
  • func (s *TryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TryStatementContext) Block() IBlockContext
  • func (s *TryStatementContext) CatchProduction() ICatchProductionContext
  • func (s *TryStatementContext) FinallyProduction() IFinallyProductionContext
  • func (s *TryStatementContext) GetParser() antlr.Parser
  • func (s *TryStatementContext) GetRuleContext() antlr.RuleContext
  • func (*TryStatementContext) IsTryStatementContext()
  • func (s *TryStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *TryStatementContext) Try() antlr.TerminalNode
• type TypeofExpressionContext
  • func NewTypeofExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeofExpressionContext
  • func (s *TypeofExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *TypeofExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *TypeofExpressionContext) SingleExpression() ISingleExpressionContext
  • func (s *TypeofExpressionContext) Typeof() antlr.TerminalNode
• type UnaryMinusExpressionContext
  • func NewUnaryMinusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryMinusExpressionContext
  • func (s *UnaryMinusExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *UnaryMinusExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *UnaryMinusExpressionContext) Minus() antlr.TerminalNode
  • func (s *UnaryMinusExpressionContext) SingleExpression() ISingleExpressionContext
• type UnaryPlusExpressionContext
  • func NewUnaryPlusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryPlusExpressionContext
  • func (s *UnaryPlusExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *UnaryPlusExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *UnaryPlusExpressionContext) Plus() antlr.TerminalNode
  • func (s *UnaryPlusExpressionContext) SingleExpression() ISingleExpressionContext
• type VarModifierContext
  • func NewEmptyVarModifierContext() *VarModifierContext
  • func NewVarModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VarModifierContext
  • func (s *VarModifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *VarModifierContext) Const() antlr.TerminalNode
  • func (s *VarModifierContext) GetParser() antlr.Parser
  • func (s *VarModifierContext) GetRuleContext() antlr.RuleContext
  • func (*VarModifierContext) IsVarModifierContext()
  • func (s *VarModifierContext) Let_() ILet_Context
  • func (s *VarModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *VarModifierContext) Var() antlr.TerminalNode
• type VariableDeclarationContext
  • func NewEmptyVariableDeclarationContext() *VariableDeclarationContext
  • func NewVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationContext
  • func (s *VariableDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *VariableDeclarationContext) Assign() antlr.TerminalNode
  • func (s *VariableDeclarationContext) Assignable() IAssignableContext
  • func (s *VariableDeclarationContext) GetParser() antlr.Parser
  • func (s *VariableDeclarationContext) GetRuleContext() antlr.RuleContext
  • func (*VariableDeclarationContext) IsVariableDeclarationContext()
  • func (s *VariableDeclarationContext) SingleExpression() ISingleExpressionContext
  • func (s *VariableDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• type VariableDeclarationListContext
  • func NewEmptyVariableDeclarationListContext() *VariableDeclarationListContext
  • func NewVariableDeclarationListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationListContext
  • func (s *VariableDeclarationListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *VariableDeclarationListContext) AllComma() []antlr.TerminalNode
  • func (s *VariableDeclarationListContext) AllVariableDeclaration() []IVariableDeclarationContext
  • func (s *VariableDeclarationListContext) Comma(i int) antlr.TerminalNode
  • func (s *VariableDeclarationListContext) GetParser() antlr.Parser
  • func (s *VariableDeclarationListContext) GetRuleContext() antlr.RuleContext
  • func (*VariableDeclarationListContext) IsVariableDeclarationListContext()
  • func (s *VariableDeclarationListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *VariableDeclarationListContext) VarModifier() IVarModifierContext
  • func (s *VariableDeclarationListContext) VariableDeclaration(i int) IVariableDeclarationContext
• type VariableStatementContext
  • func NewEmptyVariableStatementContext() *VariableStatementContext
  • func NewVariableStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableStatementContext
  • func (s *VariableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *VariableStatementContext) Eos() IEosContext
  • func (s *VariableStatementContext) GetParser() antlr.Parser
  • func (s *VariableStatementContext) GetRuleContext() antlr.RuleContext
  • func (*VariableStatementContext) IsVariableStatementContext()
  • func (s *VariableStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *VariableStatementContext) VariableDeclarationList() IVariableDeclarationListContext
• type VoidExpressionContext
  • func NewVoidExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VoidExpressionContext
  • func (s *VoidExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *VoidExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *VoidExpressionContext) SingleExpression() ISingleExpressionContext
  • func (s *VoidExpressionContext) Void() antlr.TerminalNode
• type WhileStatementContext
  • func NewWhileStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhileStatementContext
  • func (s *WhileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *WhileStatementContext) CloseParen() antlr.TerminalNode
  • func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *WhileStatementContext) OpenParen() antlr.TerminalNode
  • func (s *WhileStatementContext) SingleExpression() ISingleExpressionContext
  • func (s *WhileStatementContext) Statement() IStatementContext
  • func (s *WhileStatementContext) While() antlr.TerminalNode
• type WithStatementContext
  • func NewEmptyWithStatementContext() *WithStatementContext
  • func NewWithStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithStatementContext
  • func (s *WithStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *WithStatementContext) CloseParen() antlr.TerminalNode
  • func (s *WithStatementContext) ExpressionSequence() IExpressionSequenceContext
  • func (s *WithStatementContext) GetParser() antlr.Parser
  • func (s *WithStatementContext) GetRuleContext() antlr.RuleContext
  • func (*WithStatementContext) IsWithStatementContext()
  • func (s *WithStatementContext) OpenParen() antlr.TerminalNode
  • func (s *WithStatementContext) Statement() IStatementContext
  • func (s *WithStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *WithStatementContext) With() antlr.TerminalNode
• type YieldExpressionContext
  • func NewYieldExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *YieldExpressionContext
  • func (s *YieldExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *YieldExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *YieldExpressionContext) YieldStatement() IYieldStatementContext
• type YieldStatementContext
  • func NewEmptyYieldStatementContext() *YieldStatementContext
  • func NewYieldStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *YieldStatementContext
  • func (s *YieldStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *YieldStatementContext) Eos() IEosContext
  • func (s *YieldStatementContext) ExpressionSequence() IExpressionSequenceContext
  • func (s *YieldStatementContext) GetParser() antlr.Parser
  • func (s *YieldStatementContext) GetRuleContext() antlr.RuleContext
  • func (*YieldStatementContext) IsYieldStatementContext()
  • func (s *YieldStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *YieldStatementContext) Yield() antlr.TerminalNode

Constants

const (
	JavaScriptLexerHashBangLine                  = 1
	JavaScriptLexerMultiLineComment              = 2
	JavaScriptLexerSingleLineComment             = 3
	JavaScriptLexerRegularExpressionLiteral      = 4
	JavaScriptLexerOpenBracket                   = 5
	JavaScriptLexerCloseBracket                  = 6
	JavaScriptLexerOpenParen                     = 7
	JavaScriptLexerCloseParen                    = 8
	JavaScriptLexerOpenBrace                     = 9
	JavaScriptLexerTemplateCloseBrace            = 10
	JavaScriptLexerCloseBrace                    = 11
	JavaScriptLexerSemiColon                     = 12
	JavaScriptLexerComma                         = 13
	JavaScriptLexerAssign                        = 14
	JavaScriptLexerQuestionMark                  = 15
	JavaScriptLexerQuestionMarkDot               = 16
	JavaScriptLexerColon                         = 17
	JavaScriptLexerEllipsis                      = 18
	JavaScriptLexerDot                           = 19
	JavaScriptLexerPlusPlus                      = 20
	JavaScriptLexerMinusMinus                    = 21
	JavaScriptLexerPlus                          = 22
	JavaScriptLexerMinus                         = 23
	JavaScriptLexerBitNot                        = 24
	JavaScriptLexerNot                           = 25
	JavaScriptLexerMultiply                      = 26
	JavaScriptLexerDivide                        = 27
	JavaScriptLexerModulus                       = 28
	JavaScriptLexerPower                         = 29
	JavaScriptLexerNullCoalesce                  = 30
	JavaScriptLexerHashtag                       = 31
	JavaScriptLexerRightShiftArithmetic          = 32
	JavaScriptLexerLeftShiftArithmetic           = 33
	JavaScriptLexerRightShiftLogical             = 34
	JavaScriptLexerLessThan                      = 35
	JavaScriptLexerMoreThan                      = 36
	JavaScriptLexerLessThanEquals                = 37
	JavaScriptLexerGreaterThanEquals             = 38
	JavaScriptLexerEquals_                       = 39
	JavaScriptLexerNotEquals                     = 40
	JavaScriptLexerIdentityEquals                = 41
	JavaScriptLexerIdentityNotEquals             = 42
	JavaScriptLexerBitAnd                        = 43
	JavaScriptLexerBitXOr                        = 44
	JavaScriptLexerBitOr                         = 45
	JavaScriptLexerAnd                           = 46
	JavaScriptLexerOr                            = 47
	JavaScriptLexerMultiplyAssign                = 48
	JavaScriptLexerDivideAssign                  = 49
	JavaScriptLexerModulusAssign                 = 50
	JavaScriptLexerPlusAssign                    = 51
	JavaScriptLexerMinusAssign                   = 52
	JavaScriptLexerLeftShiftArithmeticAssign     = 53
	JavaScriptLexerRightShiftArithmeticAssign    = 54
	JavaScriptLexerRightShiftLogicalAssign       = 55
	JavaScriptLexerBitAndAssign                  = 56
	JavaScriptLexerBitXorAssign                  = 57
	JavaScriptLexerBitOrAssign                   = 58
	JavaScriptLexerPowerAssign                   = 59
	JavaScriptLexerARROW                         = 60
	JavaScriptLexerNullLiteral                   = 61
	JavaScriptLexerBooleanLiteral                = 62
	JavaScriptLexerDecimalLiteral                = 63
	JavaScriptLexerHexIntegerLiteral             = 64
	JavaScriptLexerOctalIntegerLiteral           = 65
	JavaScriptLexerOctalIntegerLiteral2          = 66
	JavaScriptLexerBinaryIntegerLiteral          = 67
	JavaScriptLexerBigHexIntegerLiteral          = 68
	JavaScriptLexerBigOctalIntegerLiteral        = 69
	JavaScriptLexerBigBinaryIntegerLiteral       = 70
	JavaScriptLexerBigDecimalIntegerLiteral      = 71
	JavaScriptLexerBreak                         = 72
	JavaScriptLexerDo                            = 73
	JavaScriptLexerInstanceof                    = 74
	JavaScriptLexerTypeof                        = 75
	JavaScriptLexerCase                          = 76
	JavaScriptLexerElse                          = 77
	JavaScriptLexerNew                           = 78
	JavaScriptLexerVar                           = 79
	JavaScriptLexerCatch                         = 80
	JavaScriptLexerFinally                       = 81
	JavaScriptLexerReturn                        = 82
	JavaScriptLexerVoid                          = 83
	JavaScriptLexerContinue                      = 84
	JavaScriptLexerFor                           = 85
	JavaScriptLexerSwitch                        = 86
	JavaScriptLexerWhile                         = 87
	JavaScriptLexerDebugger                      = 88
	JavaScriptLexerFunction_                     = 89
	JavaScriptLexerThis                          = 90
	JavaScriptLexerWith                          = 91
	JavaScriptLexerDefault                       = 92
	JavaScriptLexerIf                            = 93
	JavaScriptLexerThrow                         = 94
	JavaScriptLexerDelete                        = 95
	JavaScriptLexerIn                            = 96
	JavaScriptLexerTry                           = 97
	JavaScriptLexerAs                            = 98
	JavaScriptLexerFrom                          = 99
	JavaScriptLexerClass                         = 100
	JavaScriptLexerEnum                          = 101
	JavaScriptLexerExtends                       = 102
	JavaScriptLexerSuper                         = 103
	JavaScriptLexerConst                         = 104
	JavaScriptLexerExport                        = 105
	JavaScriptLexerImport                        = 106
	JavaScriptLexerAsync                         = 107
	JavaScriptLexerAwait                         = 108
	JavaScriptLexerYield                         = 109
	JavaScriptLexerImplements                    = 110
	JavaScriptLexerStrictLet                     = 111
	JavaScriptLexerNonStrictLet                  = 112
	JavaScriptLexerPrivate                       = 113
	JavaScriptLexerPublic                        = 114
	JavaScriptLexerInterface                     = 115
	JavaScriptLexerPackage                       = 116
	JavaScriptLexerProtected                     = 117
	JavaScriptLexerStatic                        = 118
	JavaScriptLexerIdentifier                    = 119
	JavaScriptLexerStringLiteral                 = 120
	JavaScriptLexerBackTick                      = 121
	JavaScriptLexerWhiteSpaces                   = 122
	JavaScriptLexerLineTerminator                = 123
	JavaScriptLexerHtmlComment                   = 124
	JavaScriptLexerCDataComment                  = 125
	JavaScriptLexerUnexpectedCharacter           = 126
	JavaScriptLexerTemplateStringStartExpression = 127
	JavaScriptLexerTemplateStringAtom            = 128
)

JavaScriptLexer tokens.

const (
	JavaScriptParserEOF                           = antlr.TokenEOF
	JavaScriptParserHashBangLine                  = 1
	JavaScriptParserMultiLineComment              = 2
	JavaScriptParserSingleLineComment             = 3
	JavaScriptParserRegularExpressionLiteral      = 4
	JavaScriptParserOpenBracket                   = 5
	JavaScriptParserCloseBracket                  = 6
	JavaScriptParserOpenParen                     = 7
	JavaScriptParserCloseParen                    = 8
	JavaScriptParserOpenBrace                     = 9
	JavaScriptParserTemplateCloseBrace            = 10
	JavaScriptParserCloseBrace                    = 11
	JavaScriptParserSemiColon                     = 12
	JavaScriptParserComma                         = 13
	JavaScriptParserAssign                        = 14
	JavaScriptParserQuestionMark                  = 15
	JavaScriptParserQuestionMarkDot               = 16
	JavaScriptParserColon                         = 17
	JavaScriptParserEllipsis                      = 18
	JavaScriptParserDot                           = 19
	JavaScriptParserPlusPlus                      = 20
	JavaScriptParserMinusMinus                    = 21
	JavaScriptParserPlus                          = 22
	JavaScriptParserMinus                         = 23
	JavaScriptParserBitNot                        = 24
	JavaScriptParserNot                           = 25
	JavaScriptParserMultiply                      = 26
	JavaScriptParserDivide                        = 27
	JavaScriptParserModulus                       = 28
	JavaScriptParserPower                         = 29
	JavaScriptParserNullCoalesce                  = 30
	JavaScriptParserHashtag                       = 31
	JavaScriptParserRightShiftArithmetic          = 32
	JavaScriptParserLeftShiftArithmetic           = 33
	JavaScriptParserRightShiftLogical             = 34
	JavaScriptParserLessThan                      = 35
	JavaScriptParserMoreThan                      = 36
	JavaScriptParserLessThanEquals                = 37
	JavaScriptParserGreaterThanEquals             = 38
	JavaScriptParserEquals_                       = 39
	JavaScriptParserNotEquals                     = 40
	JavaScriptParserIdentityEquals                = 41
	JavaScriptParserIdentityNotEquals             = 42
	JavaScriptParserBitAnd                        = 43
	JavaScriptParserBitXOr                        = 44
	JavaScriptParserBitOr                         = 45
	JavaScriptParserAnd                           = 46
	JavaScriptParserOr                            = 47
	JavaScriptParserMultiplyAssign                = 48
	JavaScriptParserDivideAssign                  = 49
	JavaScriptParserModulusAssign                 = 50
	JavaScriptParserPlusAssign                    = 51
	JavaScriptParserMinusAssign                   = 52
	JavaScriptParserLeftShiftArithmeticAssign     = 53
	JavaScriptParserRightShiftArithmeticAssign    = 54
	JavaScriptParserRightShiftLogicalAssign       = 55
	JavaScriptParserBitAndAssign                  = 56
	JavaScriptParserBitXorAssign                  = 57
	JavaScriptParserBitOrAssign                   = 58
	JavaScriptParserPowerAssign                   = 59
	JavaScriptParserARROW                         = 60
	JavaScriptParserNullLiteral                   = 61
	JavaScriptParserBooleanLiteral                = 62
	JavaScriptParserDecimalLiteral                = 63
	JavaScriptParserHexIntegerLiteral             = 64
	JavaScriptParserOctalIntegerLiteral           = 65
	JavaScriptParserOctalIntegerLiteral2          = 66
	JavaScriptParserBinaryIntegerLiteral          = 67
	JavaScriptParserBigHexIntegerLiteral          = 68
	JavaScriptParserBigOctalIntegerLiteral        = 69
	JavaScriptParserBigBinaryIntegerLiteral       = 70
	JavaScriptParserBigDecimalIntegerLiteral      = 71
	JavaScriptParserBreak                         = 72
	JavaScriptParserDo                            = 73
	JavaScriptParserInstanceof                    = 74
	JavaScriptParserTypeof                        = 75
	JavaScriptParserCase                          = 76
	JavaScriptParserElse                          = 77
	JavaScriptParserNew                           = 78
	JavaScriptParserVar                           = 79
	JavaScriptParserCatch                         = 80
	JavaScriptParserFinally                       = 81
	JavaScriptParserReturn                        = 82
	JavaScriptParserVoid                          = 83
	JavaScriptParserContinue                      = 84
	JavaScriptParserFor                           = 85
	JavaScriptParserSwitch                        = 86
	JavaScriptParserWhile                         = 87
	JavaScriptParserDebugger                      = 88
	JavaScriptParserFunction_                     = 89
	JavaScriptParserThis                          = 90
	JavaScriptParserWith                          = 91
	JavaScriptParserDefault                       = 92
	JavaScriptParserIf                            = 93
	JavaScriptParserThrow                         = 94
	JavaScriptParserDelete                        = 95
	JavaScriptParserIn                            = 96
	JavaScriptParserTry                           = 97
	JavaScriptParserAs                            = 98
	JavaScriptParserFrom                          = 99
	JavaScriptParserClass                         = 100
	JavaScriptParserEnum                          = 101
	JavaScriptParserExtends                       = 102
	JavaScriptParserSuper                         = 103
	JavaScriptParserConst                         = 104
	JavaScriptParserExport                        = 105
	JavaScriptParserImport                        = 106
	JavaScriptParserAsync                         = 107
	JavaScriptParserAwait                         = 108
	JavaScriptParserYield                         = 109
	JavaScriptParserImplements                    = 110
	JavaScriptParserStrictLet                     = 111
	JavaScriptParserNonStrictLet                  = 112
	JavaScriptParserPrivate                       = 113
	JavaScriptParserPublic                        = 114
	JavaScriptParserInterface                     = 115
	JavaScriptParserPackage                       = 116
	JavaScriptParserProtected                     = 117
	JavaScriptParserStatic                        = 118
	JavaScriptParserIdentifier                    = 119
	JavaScriptParserStringLiteral                 = 120
	JavaScriptParserBackTick                      = 121
	JavaScriptParserWhiteSpaces                   = 122
	JavaScriptParserLineTerminator                = 123
	JavaScriptParserHtmlComment                   = 124
	JavaScriptParserCDataComment                  = 125
	JavaScriptParserUnexpectedCharacter           = 126
	JavaScriptParserTemplateStringStartExpression = 127
	JavaScriptParserTemplateStringAtom            = 128
)

JavaScriptParser tokens.

const (
	JavaScriptParserRULE_program                 = 0
	JavaScriptParserRULE_sourceElement           = 1
	JavaScriptParserRULE_statement               = 2
	JavaScriptParserRULE_block                   = 3
	JavaScriptParserRULE_statementList           = 4
	JavaScriptParserRULE_importStatement         = 5
	JavaScriptParserRULE_importFromBlock         = 6
	JavaScriptParserRULE_importModuleItems       = 7
	JavaScriptParserRULE_importAliasName         = 8
	JavaScriptParserRULE_moduleExportName        = 9
	JavaScriptParserRULE_importedBinding         = 10
	JavaScriptParserRULE_importDefault           = 11
	JavaScriptParserRULE_importNamespace         = 12
	JavaScriptParserRULE_importFrom              = 13
	JavaScriptParserRULE_aliasName               = 14
	JavaScriptParserRULE_exportStatement         = 15
	JavaScriptParserRULE_exportFromBlock         = 16
	JavaScriptParserRULE_exportModuleItems       = 17
	JavaScriptParserRULE_exportAliasName         = 18
	JavaScriptParserRULE_declaration             = 19
	JavaScriptParserRULE_variableStatement       = 20
	JavaScriptParserRULE_variableDeclarationList = 21
	JavaScriptParserRULE_variableDeclaration     = 22
	JavaScriptParserRULE_emptyStatement_         = 23
	JavaScriptParserRULE_expressionStatement     = 24
	JavaScriptParserRULE_ifStatement             = 25
	JavaScriptParserRULE_elseBlock               = 26
	JavaScriptParserRULE_forFirst                = 27
	JavaScriptParserRULE_forSecond               = 28
	JavaScriptParserRULE_forThird                = 29
	JavaScriptParserRULE_iterationStatement      = 30
	JavaScriptParserRULE_varModifier             = 31
	JavaScriptParserRULE_continueStatement       = 32
	JavaScriptParserRULE_breakStatement          = 33
	JavaScriptParserRULE_returnStatement         = 34
	JavaScriptParserRULE_yieldStatement          = 35
	JavaScriptParserRULE_withStatement           = 36
	JavaScriptParserRULE_switchStatement         = 37
	JavaScriptParserRULE_caseBlock               = 38
	JavaScriptParserRULE_caseClauses             = 39
	JavaScriptParserRULE_caseClause              = 40
	JavaScriptParserRULE_defaultClause           = 41
	JavaScriptParserRULE_labelledStatement       = 42
	JavaScriptParserRULE_throwStatement          = 43
	JavaScriptParserRULE_tryStatement            = 44
	JavaScriptParserRULE_catchProduction         = 45
	JavaScriptParserRULE_finallyProduction       = 46
	JavaScriptParserRULE_debuggerStatement       = 47
	JavaScriptParserRULE_functionDeclaration     = 48
	JavaScriptParserRULE_classDeclaration        = 49
	JavaScriptParserRULE_classTail               = 50
	JavaScriptParserRULE_classElement            = 51
	JavaScriptParserRULE_methodDefinition        = 52
	JavaScriptParserRULE_fieldDefinition         = 53
	JavaScriptParserRULE_classElementName        = 54
	JavaScriptParserRULE_privateIdentifier       = 55
	JavaScriptParserRULE_formalParameterList     = 56
	JavaScriptParserRULE_formalParameterArg      = 57
	JavaScriptParserRULE_lastFormalParameterArg  = 58
	JavaScriptParserRULE_functionBody            = 59
	JavaScriptParserRULE_sourceElements          = 60
	JavaScriptParserRULE_arrayLiteral            = 61
	JavaScriptParserRULE_elementList             = 62
	JavaScriptParserRULE_arrayElement            = 63
	JavaScriptParserRULE_propertyAssignment      = 64
	JavaScriptParserRULE_propertyName            = 65
	JavaScriptParserRULE_arguments               = 66
	JavaScriptParserRULE_argument                = 67
	JavaScriptParserRULE_expressionSequence      = 68
	JavaScriptParserRULE_singleExpression        = 69
	JavaScriptParserRULE_initializer             = 70
	JavaScriptParserRULE_assignable              = 71
	JavaScriptParserRULE_objectLiteral           = 72
	JavaScriptParserRULE_anonymousFunction       = 73
	JavaScriptParserRULE_arrowFunctionParameters = 74
	JavaScriptParserRULE_arrowFunctionBody       = 75
	JavaScriptParserRULE_assignmentOperator      = 76
	JavaScriptParserRULE_literal                 = 77
	JavaScriptParserRULE_templateStringLiteral   = 78
	JavaScriptParserRULE_templateStringAtom      = 79
	JavaScriptParserRULE_numericLiteral          = 80
	JavaScriptParserRULE_bigintLiteral           = 81
	JavaScriptParserRULE_getter                  = 82
	JavaScriptParserRULE_setter                  = 83
	JavaScriptParserRULE_identifierName          = 84
	JavaScriptParserRULE_identifier              = 85
	JavaScriptParserRULE_reservedWord            = 86
	JavaScriptParserRULE_keyword                 = 87
	JavaScriptParserRULE_let_                    = 88
	JavaScriptParserRULE_eos                     = 89
)

JavaScriptParser rules.

const JavaScriptLexerERROR = 2

JavaScriptLexerERROR is the JavaScriptLexer channel.

const JavaScriptLexerTEMPLATE = 1

JavaScriptLexerTEMPLATE is the JavaScriptLexer mode.

Variables

var JavaScriptLexerLexerStaticData struct {
	ChannelNames           []string
	ModeNames              []string
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	// contains filtered or unexported fields
}

var JavaScriptParserParserStaticData struct {
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	// contains filtered or unexported fields
}

Functions

func InitEmptyAliasNameContext

func InitEmptyAliasNameContext(p *AliasNameContext)

func InitEmptyAnonymousFunctionContext

func InitEmptyAnonymousFunctionContext(p *AnonymousFunctionContext)

func InitEmptyArgumentContext

func InitEmptyArgumentContext(p *ArgumentContext)

func InitEmptyArgumentsContext

func InitEmptyArgumentsContext(p *ArgumentsContext)

func InitEmptyArrayElementContext

func InitEmptyArrayElementContext(p *ArrayElementContext)

func InitEmptyArrayLiteralContext

func InitEmptyArrayLiteralContext(p *ArrayLiteralContext)

func InitEmptyArrowFunctionBodyContext

func InitEmptyArrowFunctionBodyContext(p *ArrowFunctionBodyContext)

func InitEmptyArrowFunctionParametersContext

func InitEmptyArrowFunctionParametersContext(p *ArrowFunctionParametersContext)

func InitEmptyAssignableContext

func InitEmptyAssignableContext(p *AssignableContext)

func InitEmptyAssignmentOperatorContext

func InitEmptyAssignmentOperatorContext(p *AssignmentOperatorContext)

func InitEmptyBigintLiteralContext

func InitEmptyBigintLiteralContext(p *BigintLiteralContext)

func InitEmptyBlockContext

func InitEmptyBlockContext(p *BlockContext)

func InitEmptyBreakStatementContext

func InitEmptyBreakStatementContext(p *BreakStatementContext)

func InitEmptyCaseBlockContext

func InitEmptyCaseBlockContext(p *CaseBlockContext)

func InitEmptyCaseClauseContext

func InitEmptyCaseClauseContext(p *CaseClauseContext)

func InitEmptyCaseClausesContext

func InitEmptyCaseClausesContext(p *CaseClausesContext)

func InitEmptyCatchProductionContext

func InitEmptyCatchProductionContext(p *CatchProductionContext)

func InitEmptyClassDeclarationContext

func InitEmptyClassDeclarationContext(p *ClassDeclarationContext)

func InitEmptyClassElementContext

func InitEmptyClassElementContext(p *ClassElementContext)

func InitEmptyClassElementNameContext

func InitEmptyClassElementNameContext(p *ClassElementNameContext)

func InitEmptyClassTailContext

func InitEmptyClassTailContext(p *ClassTailContext)

func InitEmptyContinueStatementContext

func InitEmptyContinueStatementContext(p *ContinueStatementContext)

func InitEmptyDebuggerStatementContext

func InitEmptyDebuggerStatementContext(p *DebuggerStatementContext)

func InitEmptyDeclarationContext

func InitEmptyDeclarationContext(p *DeclarationContext)

func InitEmptyDefaultClauseContext

func InitEmptyDefaultClauseContext(p *DefaultClauseContext)

func InitEmptyElementListContext

func InitEmptyElementListContext(p *ElementListContext)

func InitEmptyElseBlockContext

func InitEmptyElseBlockContext(p *ElseBlockContext)

func InitEmptyEmptyStatement_Context

func InitEmptyEmptyStatement_Context(p *EmptyStatement_Context)

func InitEmptyEosContext

func InitEmptyEosContext(p *EosContext)

func InitEmptyExportAliasNameContext

func InitEmptyExportAliasNameContext(p *ExportAliasNameContext)

func InitEmptyExportFromBlockContext

func InitEmptyExportFromBlockContext(p *ExportFromBlockContext)

func InitEmptyExportModuleItemsContext

func InitEmptyExportModuleItemsContext(p *ExportModuleItemsContext)

func InitEmptyExportStatementContext

func InitEmptyExportStatementContext(p *ExportStatementContext)

func InitEmptyExpressionSequenceContext

func InitEmptyExpressionSequenceContext(p *ExpressionSequenceContext)

func InitEmptyExpressionStatementContext

func InitEmptyExpressionStatementContext(p *ExpressionStatementContext)

func InitEmptyFieldDefinitionContext

func InitEmptyFieldDefinitionContext(p *FieldDefinitionContext)

func InitEmptyFinallyProductionContext

func InitEmptyFinallyProductionContext(p *FinallyProductionContext)

func InitEmptyForFirstContext

func InitEmptyForFirstContext(p *ForFirstContext)

func InitEmptyForSecondContext

func InitEmptyForSecondContext(p *ForSecondContext)

func InitEmptyForThirdContext

func InitEmptyForThirdContext(p *ForThirdContext)

func InitEmptyFormalParameterArgContext

func InitEmptyFormalParameterArgContext(p *FormalParameterArgContext)

func InitEmptyFormalParameterListContext

func InitEmptyFormalParameterListContext(p *FormalParameterListContext)

func InitEmptyFunctionBodyContext

func InitEmptyFunctionBodyContext(p *FunctionBodyContext)

func InitEmptyFunctionDeclarationContext

func InitEmptyFunctionDeclarationContext(p *FunctionDeclarationContext)

func InitEmptyGetterContext

func InitEmptyGetterContext(p *GetterContext)

func InitEmptyIdentifierContext

func InitEmptyIdentifierContext(p *IdentifierContext)

func InitEmptyIdentifierNameContext

func InitEmptyIdentifierNameContext(p *IdentifierNameContext)

func InitEmptyIfStatementContext

func InitEmptyIfStatementContext(p *IfStatementContext)

func InitEmptyImportAliasNameContext

func InitEmptyImportAliasNameContext(p *ImportAliasNameContext)

func InitEmptyImportDefaultContext

func InitEmptyImportDefaultContext(p *ImportDefaultContext)

func InitEmptyImportFromBlockContext

func InitEmptyImportFromBlockContext(p *ImportFromBlockContext)

func InitEmptyImportFromContext

func InitEmptyImportFromContext(p *ImportFromContext)

func InitEmptyImportModuleItemsContext

func InitEmptyImportModuleItemsContext(p *ImportModuleItemsContext)

func InitEmptyImportNamespaceContext

func InitEmptyImportNamespaceContext(p *ImportNamespaceContext)

func InitEmptyImportStatementContext

func InitEmptyImportStatementContext(p *ImportStatementContext)

func InitEmptyImportedBindingContext

func InitEmptyImportedBindingContext(p *ImportedBindingContext)

func InitEmptyInitializerContext

func InitEmptyInitializerContext(p *InitializerContext)

func InitEmptyIterationStatementContext

func InitEmptyIterationStatementContext(p *IterationStatementContext)

func InitEmptyKeywordContext

func InitEmptyKeywordContext(p *KeywordContext)

func InitEmptyLabelledStatementContext

func InitEmptyLabelledStatementContext(p *LabelledStatementContext)

func InitEmptyLastFormalParameterArgContext

func InitEmptyLastFormalParameterArgContext(p *LastFormalParameterArgContext)

func InitEmptyLet_Context

func InitEmptyLet_Context(p *Let_Context)

func InitEmptyLiteralContext

func InitEmptyLiteralContext(p *LiteralContext)

func InitEmptyMethodDefinitionContext

func InitEmptyMethodDefinitionContext(p *MethodDefinitionContext)

func InitEmptyModuleExportNameContext

func InitEmptyModuleExportNameContext(p *ModuleExportNameContext)

func InitEmptyNumericLiteralContext

func InitEmptyNumericLiteralContext(p *NumericLiteralContext)

func InitEmptyObjectLiteralContext

func InitEmptyObjectLiteralContext(p *ObjectLiteralContext)

func InitEmptyPrivateIdentifierContext

func InitEmptyPrivateIdentifierContext(p *PrivateIdentifierContext)

func InitEmptyProgramContext

func InitEmptyProgramContext(p *ProgramContext)

func InitEmptyPropertyAssignmentContext

func InitEmptyPropertyAssignmentContext(p *PropertyAssignmentContext)

func InitEmptyPropertyNameContext

func InitEmptyPropertyNameContext(p *PropertyNameContext)

func InitEmptyReservedWordContext

func InitEmptyReservedWordContext(p *ReservedWordContext)

func InitEmptyReturnStatementContext

func InitEmptyReturnStatementContext(p *ReturnStatementContext)

func InitEmptySetterContext

func InitEmptySetterContext(p *SetterContext)

func InitEmptySingleExpressionContext

func InitEmptySingleExpressionContext(p *SingleExpressionContext)

func InitEmptySourceElementContext

func InitEmptySourceElementContext(p *SourceElementContext)

func InitEmptySourceElementsContext

func InitEmptySourceElementsContext(p *SourceElementsContext)

func InitEmptyStatementContext

func InitEmptyStatementContext(p *StatementContext)

func InitEmptyStatementListContext

func InitEmptyStatementListContext(p *StatementListContext)

func InitEmptySwitchStatementContext

func InitEmptySwitchStatementContext(p *SwitchStatementContext)

func InitEmptyTemplateStringAtomContext

func InitEmptyTemplateStringAtomContext(p *TemplateStringAtomContext)

func InitEmptyTemplateStringLiteralContext

func InitEmptyTemplateStringLiteralContext(p *TemplateStringLiteralContext)

func InitEmptyThrowStatementContext

func InitEmptyThrowStatementContext(p *ThrowStatementContext)

func InitEmptyTryStatementContext

func InitEmptyTryStatementContext(p *TryStatementContext)

func InitEmptyVarModifierContext

func InitEmptyVarModifierContext(p *VarModifierContext)

func InitEmptyVariableDeclarationContext

func InitEmptyVariableDeclarationContext(p *VariableDeclarationContext)

func InitEmptyVariableDeclarationListContext

func InitEmptyVariableDeclarationListContext(p *VariableDeclarationListContext)

func InitEmptyVariableStatementContext

func InitEmptyVariableStatementContext(p *VariableStatementContext)

func InitEmptyWithStatementContext

func InitEmptyWithStatementContext(p *WithStatementContext)

func InitEmptyYieldStatementContext

func InitEmptyYieldStatementContext(p *YieldStatementContext)

func JavaScriptLexerInit

func JavaScriptLexerInit()

JavaScriptLexerInit initializes any static state used to implement JavaScriptLexer. By default the static state used to implement the lexer is lazily initialized during the first call to NewJavaScriptLexer(). You can call this function if you wish to initialize the static state ahead of time.

func JavaScriptParserInit

func JavaScriptParserInit()

JavaScriptParserInit initializes any static state used to implement JavaScriptParser. By default the static state used to implement the parser is lazily initialized during the first call to NewJavaScriptParser(). You can call this function if you wish to initialize the static state ahead of time.

Types

type AdditiveExpressionContext

type AdditiveExpressionContext struct {
	SingleExpressionContext
}

func NewAdditiveExpressionContext

func NewAdditiveExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdditiveExpressionContext

func (*AdditiveExpressionContext) Accept

func (s *AdditiveExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AdditiveExpressionContext) AllSingleExpression

func (s *AdditiveExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*AdditiveExpressionContext) GetRuleContext

func (s *AdditiveExpressionContext) GetRuleContext() antlr.RuleContext

func (*AdditiveExpressionContext) Minus

func (s *AdditiveExpressionContext) Minus() antlr.TerminalNode

func (*AdditiveExpressionContext) Plus

func (s *AdditiveExpressionContext) Plus() antlr.TerminalNode

func (*AdditiveExpressionContext) SingleExpression

func (s *AdditiveExpressionContext) SingleExpression(i int) ISingleExpressionContext

type AliasNameContext

type AliasNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAliasNameContext

func NewAliasNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AliasNameContext

func NewEmptyAliasNameContext

func NewEmptyAliasNameContext() *AliasNameContext

func (*AliasNameContext) Accept

func (s *AliasNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AliasNameContext) AllIdentifierName

func (s *AliasNameContext) AllIdentifierName() []IIdentifierNameContext

func (*AliasNameContext) As

func (s *AliasNameContext) As() antlr.TerminalNode

func (*AliasNameContext) GetParser

func (s *AliasNameContext) GetParser() antlr.Parser

func (*AliasNameContext) GetRuleContext

func (s *AliasNameContext) GetRuleContext() antlr.RuleContext

func (*AliasNameContext) IdentifierName

func (s *AliasNameContext) IdentifierName(i int) IIdentifierNameContext

func (*AliasNameContext) IsAliasNameContext

func (*AliasNameContext) IsAliasNameContext()

func (*AliasNameContext) ToStringTree

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

type AnonymousFunctionContext

type AnonymousFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAnonymousFunctionContext

func NewAnonymousFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnonymousFunctionContext

func NewEmptyAnonymousFunctionContext

func NewEmptyAnonymousFunctionContext() *AnonymousFunctionContext

func (*AnonymousFunctionContext) CopyAll

func (s *AnonymousFunctionContext) CopyAll(ctx *AnonymousFunctionContext)

func (*AnonymousFunctionContext) GetParser

func (s *AnonymousFunctionContext) GetParser() antlr.Parser

func (*AnonymousFunctionContext) GetRuleContext

func (s *AnonymousFunctionContext) GetRuleContext() antlr.RuleContext

func (*AnonymousFunctionContext) IsAnonymousFunctionContext

func (*AnonymousFunctionContext) IsAnonymousFunctionContext()

func (*AnonymousFunctionContext) ToStringTree

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

type AnonymousFunctionDeclContext

type AnonymousFunctionDeclContext struct {
	AnonymousFunctionContext
}

func NewAnonymousFunctionDeclContext

func NewAnonymousFunctionDeclContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AnonymousFunctionDeclContext

func (*AnonymousFunctionDeclContext) Accept

func (s *AnonymousFunctionDeclContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AnonymousFunctionDeclContext) Async

func (s *AnonymousFunctionDeclContext) Async() antlr.TerminalNode

func (*AnonymousFunctionDeclContext) CloseParen

func (s *AnonymousFunctionDeclContext) CloseParen() antlr.TerminalNode

func (*AnonymousFunctionDeclContext) FormalParameterList

func (s *AnonymousFunctionDeclContext) FormalParameterList() IFormalParameterListContext

func (*AnonymousFunctionDeclContext) FunctionBody

func (s *AnonymousFunctionDeclContext) FunctionBody() IFunctionBodyContext

func (*AnonymousFunctionDeclContext) Function_

func (s *AnonymousFunctionDeclContext) Function_() antlr.TerminalNode

func (*AnonymousFunctionDeclContext) GetRuleContext

func (s *AnonymousFunctionDeclContext) GetRuleContext() antlr.RuleContext

func (*AnonymousFunctionDeclContext) Multiply

func (s *AnonymousFunctionDeclContext) Multiply() antlr.TerminalNode

func (*AnonymousFunctionDeclContext) OpenParen

func (s *AnonymousFunctionDeclContext) OpenParen() antlr.TerminalNode

type ArgumentContext

type ArgumentContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArgumentContext

func NewArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentContext

func NewEmptyArgumentContext

func NewEmptyArgumentContext() *ArgumentContext

func (*ArgumentContext) Accept

func (s *ArgumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArgumentContext) Ellipsis

func (s *ArgumentContext) Ellipsis() antlr.TerminalNode

func (*ArgumentContext) GetParser

func (s *ArgumentContext) GetParser() antlr.Parser

func (*ArgumentContext) GetRuleContext

func (s *ArgumentContext) GetRuleContext() antlr.RuleContext

func (*ArgumentContext) Identifier

func (s *ArgumentContext) Identifier() IIdentifierContext

func (*ArgumentContext) IsArgumentContext

func (*ArgumentContext) IsArgumentContext()

func (*ArgumentContext) SingleExpression

func (s *ArgumentContext) SingleExpression() ISingleExpressionContext

func (*ArgumentContext) ToStringTree

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

type ArgumentsContext

type ArgumentsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArgumentsContext

func NewArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentsContext

func NewEmptyArgumentsContext

func NewEmptyArgumentsContext() *ArgumentsContext

func (*ArgumentsContext) Accept

func (s *ArgumentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArgumentsContext) AllArgument

func (s *ArgumentsContext) AllArgument() []IArgumentContext

func (*ArgumentsContext) AllComma

func (s *ArgumentsContext) AllComma() []antlr.TerminalNode

func (*ArgumentsContext) Argument

func (s *ArgumentsContext) Argument(i int) IArgumentContext

func (*ArgumentsContext) CloseParen

func (s *ArgumentsContext) CloseParen() antlr.TerminalNode

func (*ArgumentsContext) Comma

func (s *ArgumentsContext) Comma(i int) antlr.TerminalNode

func (*ArgumentsContext) GetParser

func (s *ArgumentsContext) GetParser() antlr.Parser

func (*ArgumentsContext) GetRuleContext

func (s *ArgumentsContext) GetRuleContext() antlr.RuleContext

func (*ArgumentsContext) IsArgumentsContext

func (*ArgumentsContext) IsArgumentsContext()

func (*ArgumentsContext) OpenParen

func (s *ArgumentsContext) OpenParen() antlr.TerminalNode

func (*ArgumentsContext) ToStringTree

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

type ArgumentsExpressionContext

type ArgumentsExpressionContext struct {
	SingleExpressionContext
}

func NewArgumentsExpressionContext

func NewArgumentsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArgumentsExpressionContext

func (*ArgumentsExpressionContext) Accept

func (s *ArgumentsExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArgumentsExpressionContext) Arguments

func (s *ArgumentsExpressionContext) Arguments() IArgumentsContext

func (*ArgumentsExpressionContext) GetRuleContext

func (s *ArgumentsExpressionContext) GetRuleContext() antlr.RuleContext

func (*ArgumentsExpressionContext) SingleExpression

func (s *ArgumentsExpressionContext) SingleExpression() ISingleExpressionContext

type ArrayElementContext

type ArrayElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayElementContext

func NewArrayElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayElementContext

func NewEmptyArrayElementContext

func NewEmptyArrayElementContext() *ArrayElementContext

func (*ArrayElementContext) Accept

func (s *ArrayElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayElementContext) Ellipsis

func (s *ArrayElementContext) Ellipsis() antlr.TerminalNode

func (*ArrayElementContext) GetParser

func (s *ArrayElementContext) GetParser() antlr.Parser

func (*ArrayElementContext) GetRuleContext

func (s *ArrayElementContext) GetRuleContext() antlr.RuleContext

func (*ArrayElementContext) IsArrayElementContext

func (*ArrayElementContext) IsArrayElementContext()

func (*ArrayElementContext) SingleExpression

func (s *ArrayElementContext) SingleExpression() ISingleExpressionContext

func (*ArrayElementContext) ToStringTree

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

type ArrayLiteralContext

type ArrayLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayLiteralContext

func NewArrayLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayLiteralContext

func NewEmptyArrayLiteralContext

func NewEmptyArrayLiteralContext() *ArrayLiteralContext

func (*ArrayLiteralContext) Accept

func (s *ArrayLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayLiteralContext) CloseBracket

func (s *ArrayLiteralContext) CloseBracket() antlr.TerminalNode

func (*ArrayLiteralContext) ElementList

func (s *ArrayLiteralContext) ElementList() IElementListContext

func (*ArrayLiteralContext) GetParser

func (s *ArrayLiteralContext) GetParser() antlr.Parser

func (*ArrayLiteralContext) GetRuleContext

func (s *ArrayLiteralContext) GetRuleContext() antlr.RuleContext

func (*ArrayLiteralContext) IsArrayLiteralContext

func (*ArrayLiteralContext) IsArrayLiteralContext()

func (*ArrayLiteralContext) OpenBracket

func (s *ArrayLiteralContext) OpenBracket() antlr.TerminalNode

func (*ArrayLiteralContext) ToStringTree

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

type ArrayLiteralExpressionContext

type ArrayLiteralExpressionContext struct {
	SingleExpressionContext
}

func NewArrayLiteralExpressionContext

func NewArrayLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayLiteralExpressionContext

func (*ArrayLiteralExpressionContext) Accept

func (s *ArrayLiteralExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayLiteralExpressionContext) ArrayLiteral

func (s *ArrayLiteralExpressionContext) ArrayLiteral() IArrayLiteralContext

func (*ArrayLiteralExpressionContext) GetRuleContext

func (s *ArrayLiteralExpressionContext) GetRuleContext() antlr.RuleContext

type ArrowFunctionBodyContext

type ArrowFunctionBodyContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrowFunctionBodyContext

func NewArrowFunctionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrowFunctionBodyContext

func NewEmptyArrowFunctionBodyContext

func NewEmptyArrowFunctionBodyContext() *ArrowFunctionBodyContext

func (*ArrowFunctionBodyContext) Accept

func (s *ArrowFunctionBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrowFunctionBodyContext) FunctionBody

func (s *ArrowFunctionBodyContext) FunctionBody() IFunctionBodyContext

func (*ArrowFunctionBodyContext) GetParser

func (s *ArrowFunctionBodyContext) GetParser() antlr.Parser

func (*ArrowFunctionBodyContext) GetRuleContext

func (s *ArrowFunctionBodyContext) GetRuleContext() antlr.RuleContext

func (*ArrowFunctionBodyContext) IsArrowFunctionBodyContext

func (*ArrowFunctionBodyContext) IsArrowFunctionBodyContext()

func (*ArrowFunctionBodyContext) SingleExpression

func (s *ArrowFunctionBodyContext) SingleExpression() ISingleExpressionContext

func (*ArrowFunctionBodyContext) ToStringTree

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

type ArrowFunctionContext

type ArrowFunctionContext struct {
	AnonymousFunctionContext
}

func NewArrowFunctionContext

func NewArrowFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrowFunctionContext

func (*ArrowFunctionContext) ARROW

func (s *ArrowFunctionContext) ARROW() antlr.TerminalNode

func (*ArrowFunctionContext) Accept

func (s *ArrowFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrowFunctionContext) ArrowFunctionBody

func (s *ArrowFunctionContext) ArrowFunctionBody() IArrowFunctionBodyContext

func (*ArrowFunctionContext) ArrowFunctionParameters

func (s *ArrowFunctionContext) ArrowFunctionParameters() IArrowFunctionParametersContext

func (*ArrowFunctionContext) Async

func (s *ArrowFunctionContext) Async() antlr.TerminalNode

func (*ArrowFunctionContext) GetRuleContext

func (s *ArrowFunctionContext) GetRuleContext() antlr.RuleContext

type ArrowFunctionParametersContext

type ArrowFunctionParametersContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrowFunctionParametersContext

func NewArrowFunctionParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrowFunctionParametersContext

func NewEmptyArrowFunctionParametersContext

func NewEmptyArrowFunctionParametersContext() *ArrowFunctionParametersContext

func (*ArrowFunctionParametersContext) Accept

func (s *ArrowFunctionParametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrowFunctionParametersContext) CloseParen

func (s *ArrowFunctionParametersContext) CloseParen() antlr.TerminalNode

func (*ArrowFunctionParametersContext) FormalParameterList

func (s *ArrowFunctionParametersContext) FormalParameterList() IFormalParameterListContext

func (*ArrowFunctionParametersContext) GetParser

func (s *ArrowFunctionParametersContext) GetParser() antlr.Parser

func (*ArrowFunctionParametersContext) GetRuleContext

func (s *ArrowFunctionParametersContext) GetRuleContext() antlr.RuleContext

func (*ArrowFunctionParametersContext) Identifier

func (s *ArrowFunctionParametersContext) Identifier() IIdentifierContext

func (*ArrowFunctionParametersContext) IsArrowFunctionParametersContext

func (*ArrowFunctionParametersContext) IsArrowFunctionParametersContext()

func (*ArrowFunctionParametersContext) OpenParen

func (s *ArrowFunctionParametersContext) OpenParen() antlr.TerminalNode

func (*ArrowFunctionParametersContext) ToStringTree

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

type AssignableContext

type AssignableContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAssignableContext

func NewAssignableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignableContext

func NewEmptyAssignableContext

func NewEmptyAssignableContext() *AssignableContext

func (*AssignableContext) Accept

func (s *AssignableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AssignableContext) ArrayLiteral

func (s *AssignableContext) ArrayLiteral() IArrayLiteralContext

func (*AssignableContext) GetParser

func (s *AssignableContext) GetParser() antlr.Parser

func (*AssignableContext) GetRuleContext

func (s *AssignableContext) GetRuleContext() antlr.RuleContext

func (*AssignableContext) Identifier

func (s *AssignableContext) Identifier() IIdentifierContext

func (*AssignableContext) IsAssignableContext

func (*AssignableContext) IsAssignableContext()

func (*AssignableContext) ObjectLiteral

func (s *AssignableContext) ObjectLiteral() IObjectLiteralContext

func (*AssignableContext) ToStringTree

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

type AssignmentExpressionContext

type AssignmentExpressionContext struct {
	SingleExpressionContext
}

func NewAssignmentExpressionContext

func NewAssignmentExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignmentExpressionContext

func (*AssignmentExpressionContext) Accept

func (s *AssignmentExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AssignmentExpressionContext) AllSingleExpression

func (s *AssignmentExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*AssignmentExpressionContext) Assign

func (s *AssignmentExpressionContext) Assign() antlr.TerminalNode

func (*AssignmentExpressionContext) GetRuleContext

func (s *AssignmentExpressionContext) GetRuleContext() antlr.RuleContext

func (*AssignmentExpressionContext) SingleExpression

func (s *AssignmentExpressionContext) SingleExpression(i int) ISingleExpressionContext

type AssignmentOperatorContext

type AssignmentOperatorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAssignmentOperatorContext

func NewAssignmentOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentOperatorContext

func NewEmptyAssignmentOperatorContext

func NewEmptyAssignmentOperatorContext() *AssignmentOperatorContext

func (*AssignmentOperatorContext) Accept

func (s *AssignmentOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AssignmentOperatorContext) BitAndAssign

func (s *AssignmentOperatorContext) BitAndAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) BitOrAssign

func (s *AssignmentOperatorContext) BitOrAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) BitXorAssign

func (s *AssignmentOperatorContext) BitXorAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) DivideAssign

func (s *AssignmentOperatorContext) DivideAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) GetParser

func (s *AssignmentOperatorContext) GetParser() antlr.Parser

func (*AssignmentOperatorContext) GetRuleContext

func (s *AssignmentOperatorContext) GetRuleContext() antlr.RuleContext

func (*AssignmentOperatorContext) IsAssignmentOperatorContext

func (*AssignmentOperatorContext) IsAssignmentOperatorContext()

func (*AssignmentOperatorContext) LeftShiftArithmeticAssign

func (s *AssignmentOperatorContext) LeftShiftArithmeticAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) MinusAssign

func (s *AssignmentOperatorContext) MinusAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) ModulusAssign

func (s *AssignmentOperatorContext) ModulusAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) MultiplyAssign

func (s *AssignmentOperatorContext) MultiplyAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) PlusAssign

func (s *AssignmentOperatorContext) PlusAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) PowerAssign

func (s *AssignmentOperatorContext) PowerAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) RightShiftArithmeticAssign

func (s *AssignmentOperatorContext) RightShiftArithmeticAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) RightShiftLogicalAssign

func (s *AssignmentOperatorContext) RightShiftLogicalAssign() antlr.TerminalNode

func (*AssignmentOperatorContext) ToStringTree

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

type AssignmentOperatorExpressionContext

type AssignmentOperatorExpressionContext struct {
	SingleExpressionContext
}

func NewAssignmentOperatorExpressionContext

func NewAssignmentOperatorExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignmentOperatorExpressionContext

func (*AssignmentOperatorExpressionContext) Accept

func (s *AssignmentOperatorExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AssignmentOperatorExpressionContext) AllSingleExpression

func (s *AssignmentOperatorExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*AssignmentOperatorExpressionContext) AssignmentOperator

func (s *AssignmentOperatorExpressionContext) AssignmentOperator() IAssignmentOperatorContext

func (*AssignmentOperatorExpressionContext) GetRuleContext

func (s *AssignmentOperatorExpressionContext) GetRuleContext() antlr.RuleContext

func (*AssignmentOperatorExpressionContext) SingleExpression

func (s *AssignmentOperatorExpressionContext) SingleExpression(i int) ISingleExpressionContext

type AwaitExpressionContext

type AwaitExpressionContext struct {
	SingleExpressionContext
}

func NewAwaitExpressionContext

func NewAwaitExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AwaitExpressionContext

func (*AwaitExpressionContext) Accept

func (s *AwaitExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AwaitExpressionContext) Await

func (s *AwaitExpressionContext) Await() antlr.TerminalNode

func (*AwaitExpressionContext) GetRuleContext

func (s *AwaitExpressionContext) GetRuleContext() antlr.RuleContext

func (*AwaitExpressionContext) SingleExpression

func (s *AwaitExpressionContext) SingleExpression() ISingleExpressionContext

type BaseJavaScriptParserVisitor

type BaseJavaScriptParserVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseJavaScriptParserVisitor) VisitAdditiveExpression

func (v *BaseJavaScriptParserVisitor) VisitAdditiveExpression(ctx *AdditiveExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitAliasName

func (v *BaseJavaScriptParserVisitor) VisitAliasName(ctx *AliasNameContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitAnonymousFunctionDecl

func (v *BaseJavaScriptParserVisitor) VisitAnonymousFunctionDecl(ctx *AnonymousFunctionDeclContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArgument

func (v *BaseJavaScriptParserVisitor) VisitArgument(ctx *ArgumentContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArguments

func (v *BaseJavaScriptParserVisitor) VisitArguments(ctx *ArgumentsContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArgumentsExpression

func (v *BaseJavaScriptParserVisitor) VisitArgumentsExpression(ctx *ArgumentsExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArrayElement

func (v *BaseJavaScriptParserVisitor) VisitArrayElement(ctx *ArrayElementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArrayLiteral

func (v *BaseJavaScriptParserVisitor) VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArrayLiteralExpression

func (v *BaseJavaScriptParserVisitor) VisitArrayLiteralExpression(ctx *ArrayLiteralExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArrowFunction

func (v *BaseJavaScriptParserVisitor) VisitArrowFunction(ctx *ArrowFunctionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArrowFunctionBody

func (v *BaseJavaScriptParserVisitor) VisitArrowFunctionBody(ctx *ArrowFunctionBodyContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitArrowFunctionParameters

func (v *BaseJavaScriptParserVisitor) VisitArrowFunctionParameters(ctx *ArrowFunctionParametersContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitAssignable

func (v *BaseJavaScriptParserVisitor) VisitAssignable(ctx *AssignableContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitAssignmentExpression

func (v *BaseJavaScriptParserVisitor) VisitAssignmentExpression(ctx *AssignmentExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitAssignmentOperator

func (v *BaseJavaScriptParserVisitor) VisitAssignmentOperator(ctx *AssignmentOperatorContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitAssignmentOperatorExpression

func (v *BaseJavaScriptParserVisitor) VisitAssignmentOperatorExpression(ctx *AssignmentOperatorExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitAwaitExpression

func (v *BaseJavaScriptParserVisitor) VisitAwaitExpression(ctx *AwaitExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBigintLiteral

func (v *BaseJavaScriptParserVisitor) VisitBigintLiteral(ctx *BigintLiteralContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBitAndExpression

func (v *BaseJavaScriptParserVisitor) VisitBitAndExpression(ctx *BitAndExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBitNotExpression

func (v *BaseJavaScriptParserVisitor) VisitBitNotExpression(ctx *BitNotExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBitOrExpression

func (v *BaseJavaScriptParserVisitor) VisitBitOrExpression(ctx *BitOrExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBitShiftExpression

func (v *BaseJavaScriptParserVisitor) VisitBitShiftExpression(ctx *BitShiftExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBitXOrExpression

func (v *BaseJavaScriptParserVisitor) VisitBitXOrExpression(ctx *BitXOrExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBlock

func (v *BaseJavaScriptParserVisitor) VisitBlock(ctx *BlockContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBreakStatement

func (v *BaseJavaScriptParserVisitor) VisitBreakStatement(ctx *BreakStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitCaseBlock

func (v *BaseJavaScriptParserVisitor) VisitCaseBlock(ctx *CaseBlockContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitCaseClause

func (v *BaseJavaScriptParserVisitor) VisitCaseClause(ctx *CaseClauseContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitCaseClauses

func (v *BaseJavaScriptParserVisitor) VisitCaseClauses(ctx *CaseClausesContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitCatchProduction

func (v *BaseJavaScriptParserVisitor) VisitCatchProduction(ctx *CatchProductionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitClassDeclaration

func (v *BaseJavaScriptParserVisitor) VisitClassDeclaration(ctx *ClassDeclarationContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitClassElement

func (v *BaseJavaScriptParserVisitor) VisitClassElement(ctx *ClassElementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitClassElementName

func (v *BaseJavaScriptParserVisitor) VisitClassElementName(ctx *ClassElementNameContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitClassExpression

func (v *BaseJavaScriptParserVisitor) VisitClassExpression(ctx *ClassExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitClassTail

func (v *BaseJavaScriptParserVisitor) VisitClassTail(ctx *ClassTailContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitCoalesceExpression

func (v *BaseJavaScriptParserVisitor) VisitCoalesceExpression(ctx *CoalesceExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitComputedPropertyExpressionAssignment

func (v *BaseJavaScriptParserVisitor) VisitComputedPropertyExpressionAssignment(ctx *ComputedPropertyExpressionAssignmentContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitContinueStatement

func (v *BaseJavaScriptParserVisitor) VisitContinueStatement(ctx *ContinueStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitDebuggerStatement

func (v *BaseJavaScriptParserVisitor) VisitDebuggerStatement(ctx *DebuggerStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitDeclaration

func (v *BaseJavaScriptParserVisitor) VisitDeclaration(ctx *DeclarationContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitDefaultClause

func (v *BaseJavaScriptParserVisitor) VisitDefaultClause(ctx *DefaultClauseContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitDeleteExpression

func (v *BaseJavaScriptParserVisitor) VisitDeleteExpression(ctx *DeleteExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitDoStatement

func (v *BaseJavaScriptParserVisitor) VisitDoStatement(ctx *DoStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitElementList

func (v *BaseJavaScriptParserVisitor) VisitElementList(ctx *ElementListContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitElseBlock

func (v *BaseJavaScriptParserVisitor) VisitElseBlock(ctx *ElseBlockContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitEmptyStatement_

func (v *BaseJavaScriptParserVisitor) VisitEmptyStatement_(ctx *EmptyStatement_Context) interface{}

func (*BaseJavaScriptParserVisitor) VisitEos

func (v *BaseJavaScriptParserVisitor) VisitEos(ctx *EosContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitEqualityExpression

func (v *BaseJavaScriptParserVisitor) VisitEqualityExpression(ctx *EqualityExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitExportAliasName

func (v *BaseJavaScriptParserVisitor) VisitExportAliasName(ctx *ExportAliasNameContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitExportDeclaration

func (v *BaseJavaScriptParserVisitor) VisitExportDeclaration(ctx *ExportDeclarationContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitExportDefaultDeclaration

func (v *BaseJavaScriptParserVisitor) VisitExportDefaultDeclaration(ctx *ExportDefaultDeclarationContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitExportFromBlock

func (v *BaseJavaScriptParserVisitor) VisitExportFromBlock(ctx *ExportFromBlockContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitExportModuleItems

func (v *BaseJavaScriptParserVisitor) VisitExportModuleItems(ctx *ExportModuleItemsContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitExpressionSequence

func (v *BaseJavaScriptParserVisitor) VisitExpressionSequence(ctx *ExpressionSequenceContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitExpressionStatement

func (v *BaseJavaScriptParserVisitor) VisitExpressionStatement(ctx *ExpressionStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitFieldDefinition

func (v *BaseJavaScriptParserVisitor) VisitFieldDefinition(ctx *FieldDefinitionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitFinallyProduction

func (v *BaseJavaScriptParserVisitor) VisitFinallyProduction(ctx *FinallyProductionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitForFirst

func (v *BaseJavaScriptParserVisitor) VisitForFirst(ctx *ForFirstContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitForInStatement

func (v *BaseJavaScriptParserVisitor) VisitForInStatement(ctx *ForInStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitForOfStatement

func (v *BaseJavaScriptParserVisitor) VisitForOfStatement(ctx *ForOfStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitForSecond

func (v *BaseJavaScriptParserVisitor) VisitForSecond(ctx *ForSecondContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitForStatement

func (v *BaseJavaScriptParserVisitor) VisitForStatement(ctx *ForStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitForThird

func (v *BaseJavaScriptParserVisitor) VisitForThird(ctx *ForThirdContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitFormalParameterArg

func (v *BaseJavaScriptParserVisitor) VisitFormalParameterArg(ctx *FormalParameterArgContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitFormalParameterList

func (v *BaseJavaScriptParserVisitor) VisitFormalParameterList(ctx *FormalParameterListContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitFunctionBody

func (v *BaseJavaScriptParserVisitor) VisitFunctionBody(ctx *FunctionBodyContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitFunctionDeclaration

func (v *BaseJavaScriptParserVisitor) VisitFunctionDeclaration(ctx *FunctionDeclarationContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitFunctionExpression

func (v *BaseJavaScriptParserVisitor) VisitFunctionExpression(ctx *FunctionExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitFunctionProperty

func (v *BaseJavaScriptParserVisitor) VisitFunctionProperty(ctx *FunctionPropertyContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitGetter

func (v *BaseJavaScriptParserVisitor) VisitGetter(ctx *GetterContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitIdentifier

func (v *BaseJavaScriptParserVisitor) VisitIdentifier(ctx *IdentifierContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitIdentifierExpression

func (v *BaseJavaScriptParserVisitor) VisitIdentifierExpression(ctx *IdentifierExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitIdentifierName

func (v *BaseJavaScriptParserVisitor) VisitIdentifierName(ctx *IdentifierNameContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitIfStatement

func (v *BaseJavaScriptParserVisitor) VisitIfStatement(ctx *IfStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportAliasName

func (v *BaseJavaScriptParserVisitor) VisitImportAliasName(ctx *ImportAliasNameContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportDefault

func (v *BaseJavaScriptParserVisitor) VisitImportDefault(ctx *ImportDefaultContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportExpression

func (v *BaseJavaScriptParserVisitor) VisitImportExpression(ctx *ImportExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportFrom

func (v *BaseJavaScriptParserVisitor) VisitImportFrom(ctx *ImportFromContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportFromBlock

func (v *BaseJavaScriptParserVisitor) VisitImportFromBlock(ctx *ImportFromBlockContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportModuleItems

func (v *BaseJavaScriptParserVisitor) VisitImportModuleItems(ctx *ImportModuleItemsContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportNamespace

func (v *BaseJavaScriptParserVisitor) VisitImportNamespace(ctx *ImportNamespaceContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportStatement

func (v *BaseJavaScriptParserVisitor) VisitImportStatement(ctx *ImportStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitImportedBinding

func (v *BaseJavaScriptParserVisitor) VisitImportedBinding(ctx *ImportedBindingContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitInExpression

func (v *BaseJavaScriptParserVisitor) VisitInExpression(ctx *InExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitInitializer

func (v *BaseJavaScriptParserVisitor) VisitInitializer(ctx *InitializerContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitInstanceofExpression

func (v *BaseJavaScriptParserVisitor) VisitInstanceofExpression(ctx *InstanceofExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitKeyword

func (v *BaseJavaScriptParserVisitor) VisitKeyword(ctx *KeywordContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitLabelledStatement

func (v *BaseJavaScriptParserVisitor) VisitLabelledStatement(ctx *LabelledStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitLastFormalParameterArg

func (v *BaseJavaScriptParserVisitor) VisitLastFormalParameterArg(ctx *LastFormalParameterArgContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitLet_

func (v *BaseJavaScriptParserVisitor) VisitLet_(ctx *Let_Context) interface{}

func (*BaseJavaScriptParserVisitor) VisitLiteral

func (v *BaseJavaScriptParserVisitor) VisitLiteral(ctx *LiteralContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitLiteralExpression

func (v *BaseJavaScriptParserVisitor) VisitLiteralExpression(ctx *LiteralExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitLogicalAndExpression

func (v *BaseJavaScriptParserVisitor) VisitLogicalAndExpression(ctx *LogicalAndExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitLogicalOrExpression

func (v *BaseJavaScriptParserVisitor) VisitLogicalOrExpression(ctx *LogicalOrExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitMemberDotExpression

func (v *BaseJavaScriptParserVisitor) VisitMemberDotExpression(ctx *MemberDotExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitMemberIndexExpression

func (v *BaseJavaScriptParserVisitor) VisitMemberIndexExpression(ctx *MemberIndexExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitMetaExpression

func (v *BaseJavaScriptParserVisitor) VisitMetaExpression(ctx *MetaExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitMethodDefinition

func (v *BaseJavaScriptParserVisitor) VisitMethodDefinition(ctx *MethodDefinitionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitModuleExportName

func (v *BaseJavaScriptParserVisitor) VisitModuleExportName(ctx *ModuleExportNameContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitMultiplicativeExpression

func (v *BaseJavaScriptParserVisitor) VisitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitNewExpression

func (v *BaseJavaScriptParserVisitor) VisitNewExpression(ctx *NewExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitNotExpression

func (v *BaseJavaScriptParserVisitor) VisitNotExpression(ctx *NotExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitNumericLiteral

func (v *BaseJavaScriptParserVisitor) VisitNumericLiteral(ctx *NumericLiteralContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitObjectLiteral

func (v *BaseJavaScriptParserVisitor) VisitObjectLiteral(ctx *ObjectLiteralContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitObjectLiteralExpression

func (v *BaseJavaScriptParserVisitor) VisitObjectLiteralExpression(ctx *ObjectLiteralExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitOptionalChainExpression

func (v *BaseJavaScriptParserVisitor) VisitOptionalChainExpression(ctx *OptionalChainExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitParenthesizedExpression

func (v *BaseJavaScriptParserVisitor) VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPostDecreaseExpression

func (v *BaseJavaScriptParserVisitor) VisitPostDecreaseExpression(ctx *PostDecreaseExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPostIncrementExpression

func (v *BaseJavaScriptParserVisitor) VisitPostIncrementExpression(ctx *PostIncrementExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPowerExpression

func (v *BaseJavaScriptParserVisitor) VisitPowerExpression(ctx *PowerExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPreDecreaseExpression

func (v *BaseJavaScriptParserVisitor) VisitPreDecreaseExpression(ctx *PreDecreaseExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPreIncrementExpression

func (v *BaseJavaScriptParserVisitor) VisitPreIncrementExpression(ctx *PreIncrementExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPrivateIdentifier

func (v *BaseJavaScriptParserVisitor) VisitPrivateIdentifier(ctx *PrivateIdentifierContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitProgram

func (v *BaseJavaScriptParserVisitor) VisitProgram(ctx *ProgramContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPropertyExpressionAssignment

func (v *BaseJavaScriptParserVisitor) VisitPropertyExpressionAssignment(ctx *PropertyExpressionAssignmentContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPropertyGetter

func (v *BaseJavaScriptParserVisitor) VisitPropertyGetter(ctx *PropertyGetterContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPropertyName

func (v *BaseJavaScriptParserVisitor) VisitPropertyName(ctx *PropertyNameContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPropertySetter

func (v *BaseJavaScriptParserVisitor) VisitPropertySetter(ctx *PropertySetterContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPropertyShorthand

func (v *BaseJavaScriptParserVisitor) VisitPropertyShorthand(ctx *PropertyShorthandContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitRelationalExpression

func (v *BaseJavaScriptParserVisitor) VisitRelationalExpression(ctx *RelationalExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitReservedWord

func (v *BaseJavaScriptParserVisitor) VisitReservedWord(ctx *ReservedWordContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitReturnStatement

func (v *BaseJavaScriptParserVisitor) VisitReturnStatement(ctx *ReturnStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitSetter

func (v *BaseJavaScriptParserVisitor) VisitSetter(ctx *SetterContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitSourceElement

func (v *BaseJavaScriptParserVisitor) VisitSourceElement(ctx *SourceElementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitSourceElements

func (v *BaseJavaScriptParserVisitor) VisitSourceElements(ctx *SourceElementsContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitStatement

func (v *BaseJavaScriptParserVisitor) VisitStatement(ctx *StatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitStatementList

func (v *BaseJavaScriptParserVisitor) VisitStatementList(ctx *StatementListContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitSuperExpression

func (v *BaseJavaScriptParserVisitor) VisitSuperExpression(ctx *SuperExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitSwitchStatement

func (v *BaseJavaScriptParserVisitor) VisitSwitchStatement(ctx *SwitchStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitTemplateStringAtom

func (v *BaseJavaScriptParserVisitor) VisitTemplateStringAtom(ctx *TemplateStringAtomContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitTemplateStringExpression

func (v *BaseJavaScriptParserVisitor) VisitTemplateStringExpression(ctx *TemplateStringExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitTemplateStringLiteral

func (v *BaseJavaScriptParserVisitor) VisitTemplateStringLiteral(ctx *TemplateStringLiteralContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitTernaryExpression

func (v *BaseJavaScriptParserVisitor) VisitTernaryExpression(ctx *TernaryExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitThisExpression

func (v *BaseJavaScriptParserVisitor) VisitThisExpression(ctx *ThisExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitThrowStatement

func (v *BaseJavaScriptParserVisitor) VisitThrowStatement(ctx *ThrowStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitTryStatement

func (v *BaseJavaScriptParserVisitor) VisitTryStatement(ctx *TryStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitTypeofExpression

func (v *BaseJavaScriptParserVisitor) VisitTypeofExpression(ctx *TypeofExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitUnaryMinusExpression

func (v *BaseJavaScriptParserVisitor) VisitUnaryMinusExpression(ctx *UnaryMinusExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitUnaryPlusExpression

func (v *BaseJavaScriptParserVisitor) VisitUnaryPlusExpression(ctx *UnaryPlusExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitVarModifier

func (v *BaseJavaScriptParserVisitor) VisitVarModifier(ctx *VarModifierContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitVariableDeclaration

func (v *BaseJavaScriptParserVisitor) VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitVariableDeclarationList

func (v *BaseJavaScriptParserVisitor) VisitVariableDeclarationList(ctx *VariableDeclarationListContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitVariableStatement

func (v *BaseJavaScriptParserVisitor) VisitVariableStatement(ctx *VariableStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitVoidExpression

func (v *BaseJavaScriptParserVisitor) VisitVoidExpression(ctx *VoidExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitWhileStatement

func (v *BaseJavaScriptParserVisitor) VisitWhileStatement(ctx *WhileStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitWithStatement

func (v *BaseJavaScriptParserVisitor) VisitWithStatement(ctx *WithStatementContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitYieldExpression

func (v *BaseJavaScriptParserVisitor) VisitYieldExpression(ctx *YieldExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitYieldStatement

func (v *BaseJavaScriptParserVisitor) VisitYieldStatement(ctx *YieldStatementContext) interface{}

type BigintLiteralContext

type BigintLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBigintLiteralContext

func NewBigintLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BigintLiteralContext

func NewEmptyBigintLiteralContext

func NewEmptyBigintLiteralContext() *BigintLiteralContext

func (*BigintLiteralContext) Accept

func (s *BigintLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BigintLiteralContext) BigBinaryIntegerLiteral

func (s *BigintLiteralContext) BigBinaryIntegerLiteral() antlr.TerminalNode

func (*BigintLiteralContext) BigDecimalIntegerLiteral

func (s *BigintLiteralContext) BigDecimalIntegerLiteral() antlr.TerminalNode

func (*BigintLiteralContext) BigHexIntegerLiteral

func (s *BigintLiteralContext) BigHexIntegerLiteral() antlr.TerminalNode

func (*BigintLiteralContext) BigOctalIntegerLiteral

func (s *BigintLiteralContext) BigOctalIntegerLiteral() antlr.TerminalNode

func (*BigintLiteralContext) GetParser

func (s *BigintLiteralContext) GetParser() antlr.Parser

func (*BigintLiteralContext) GetRuleContext

func (s *BigintLiteralContext) GetRuleContext() antlr.RuleContext

func (*BigintLiteralContext) IsBigintLiteralContext

func (*BigintLiteralContext) IsBigintLiteralContext()

func (*BigintLiteralContext) ToStringTree

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

type BitAndExpressionContext

type BitAndExpressionContext struct {
	SingleExpressionContext
}

func NewBitAndExpressionContext

func NewBitAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitAndExpressionContext

func (*BitAndExpressionContext) Accept

func (s *BitAndExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitAndExpressionContext) AllSingleExpression

func (s *BitAndExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*BitAndExpressionContext) BitAnd

func (s *BitAndExpressionContext) BitAnd() antlr.TerminalNode

func (*BitAndExpressionContext) GetRuleContext

func (s *BitAndExpressionContext) GetRuleContext() antlr.RuleContext

func (*BitAndExpressionContext) SingleExpression

func (s *BitAndExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BitNotExpressionContext

type BitNotExpressionContext struct {
	SingleExpressionContext
}

func NewBitNotExpressionContext

func NewBitNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitNotExpressionContext

func (*BitNotExpressionContext) Accept

func (s *BitNotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitNotExpressionContext) BitNot

func (s *BitNotExpressionContext) BitNot() antlr.TerminalNode

func (*BitNotExpressionContext) GetRuleContext

func (s *BitNotExpressionContext) GetRuleContext() antlr.RuleContext

func (*BitNotExpressionContext) SingleExpression

func (s *BitNotExpressionContext) SingleExpression() ISingleExpressionContext

type BitOrExpressionContext

type BitOrExpressionContext struct {
	SingleExpressionContext
}

func NewBitOrExpressionContext

func NewBitOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitOrExpressionContext

func (*BitOrExpressionContext) Accept

func (s *BitOrExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitOrExpressionContext) AllSingleExpression

func (s *BitOrExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*BitOrExpressionContext) BitOr

func (s *BitOrExpressionContext) BitOr() antlr.TerminalNode

func (*BitOrExpressionContext) GetRuleContext

func (s *BitOrExpressionContext) GetRuleContext() antlr.RuleContext

func (*BitOrExpressionContext) SingleExpression

func (s *BitOrExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BitShiftExpressionContext

type BitShiftExpressionContext struct {
	SingleExpressionContext
}

func NewBitShiftExpressionContext

func NewBitShiftExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitShiftExpressionContext

func (*BitShiftExpressionContext) Accept

func (s *BitShiftExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitShiftExpressionContext) AllSingleExpression

func (s *BitShiftExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*BitShiftExpressionContext) GetRuleContext

func (s *BitShiftExpressionContext) GetRuleContext() antlr.RuleContext

func (*BitShiftExpressionContext) LeftShiftArithmetic

func (s *BitShiftExpressionContext) LeftShiftArithmetic() antlr.TerminalNode

func (*BitShiftExpressionContext) RightShiftArithmetic

func (s *BitShiftExpressionContext) RightShiftArithmetic() antlr.TerminalNode

func (*BitShiftExpressionContext) RightShiftLogical

func (s *BitShiftExpressionContext) RightShiftLogical() antlr.TerminalNode

func (*BitShiftExpressionContext) SingleExpression

func (s *BitShiftExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BitXOrExpressionContext

type BitXOrExpressionContext struct {
	SingleExpressionContext
}

func NewBitXOrExpressionContext

func NewBitXOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitXOrExpressionContext

func (*BitXOrExpressionContext) Accept

func (s *BitXOrExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitXOrExpressionContext) AllSingleExpression

func (s *BitXOrExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*BitXOrExpressionContext) BitXOr

func (s *BitXOrExpressionContext) BitXOr() antlr.TerminalNode

func (*BitXOrExpressionContext) GetRuleContext

func (s *BitXOrExpressionContext) GetRuleContext() antlr.RuleContext

func (*BitXOrExpressionContext) SingleExpression

func (s *BitXOrExpressionContext) SingleExpression(i int) ISingleExpressionContext

type BlockContext

type BlockContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBlockContext

func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext

func NewEmptyBlockContext

func NewEmptyBlockContext() *BlockContext

func (*BlockContext) Accept

func (s *BlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BlockContext) CloseBrace

func (s *BlockContext) CloseBrace() antlr.TerminalNode

func (*BlockContext) GetParser

func (s *BlockContext) GetParser() antlr.Parser

func (*BlockContext) GetRuleContext

func (s *BlockContext) GetRuleContext() antlr.RuleContext

func (*BlockContext) IsBlockContext

func (*BlockContext) IsBlockContext()

func (*BlockContext) OpenBrace

func (s *BlockContext) OpenBrace() antlr.TerminalNode

func (*BlockContext) StatementList

func (s *BlockContext) StatementList() IStatementListContext

func (*BlockContext) ToStringTree

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

type BreakStatementContext

type BreakStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBreakStatementContext

func NewBreakStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BreakStatementContext

func NewEmptyBreakStatementContext

func NewEmptyBreakStatementContext() *BreakStatementContext

func (*BreakStatementContext) Accept

func (s *BreakStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BreakStatementContext) Break

func (s *BreakStatementContext) Break() antlr.TerminalNode

func (*BreakStatementContext) Eos

func (s *BreakStatementContext) Eos() IEosContext

func (*BreakStatementContext) GetParser

func (s *BreakStatementContext) GetParser() antlr.Parser

func (*BreakStatementContext) GetRuleContext

func (s *BreakStatementContext) GetRuleContext() antlr.RuleContext

func (*BreakStatementContext) Identifier

func (s *BreakStatementContext) Identifier() IIdentifierContext

func (*BreakStatementContext) IsBreakStatementContext

func (*BreakStatementContext) IsBreakStatementContext()

func (*BreakStatementContext) ToStringTree

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

type CaseBlockContext

type CaseBlockContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCaseBlockContext

func NewCaseBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseBlockContext

func NewEmptyCaseBlockContext

func NewEmptyCaseBlockContext() *CaseBlockContext

func (*CaseBlockContext) Accept

func (s *CaseBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CaseBlockContext) AllCaseClauses

func (s *CaseBlockContext) AllCaseClauses() []ICaseClausesContext

func (*CaseBlockContext) CaseClauses

func (s *CaseBlockContext) CaseClauses(i int) ICaseClausesContext

func (*CaseBlockContext) CloseBrace

func (s *CaseBlockContext) CloseBrace() antlr.TerminalNode

func (*CaseBlockContext) DefaultClause

func (s *CaseBlockContext) DefaultClause() IDefaultClauseContext

func (*CaseBlockContext) GetParser

func (s *CaseBlockContext) GetParser() antlr.Parser

func (*CaseBlockContext) GetRuleContext

func (s *CaseBlockContext) GetRuleContext() antlr.RuleContext

func (*CaseBlockContext) IsCaseBlockContext

func (*CaseBlockContext) IsCaseBlockContext()

func (*CaseBlockContext) OpenBrace

func (s *CaseBlockContext) OpenBrace() antlr.TerminalNode

func (*CaseBlockContext) ToStringTree

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

type CaseClauseContext

type CaseClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCaseClauseContext

func NewCaseClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseClauseContext

func NewEmptyCaseClauseContext

func NewEmptyCaseClauseContext() *CaseClauseContext

func (*CaseClauseContext) Accept

func (s *CaseClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CaseClauseContext) Case

func (s *CaseClauseContext) Case() antlr.TerminalNode

func (*CaseClauseContext) Colon

func (s *CaseClauseContext) Colon() antlr.TerminalNode

func (*CaseClauseContext) GetParser

func (s *CaseClauseContext) GetParser() antlr.Parser

func (*CaseClauseContext) GetRuleContext

func (s *CaseClauseContext) GetRuleContext() antlr.RuleContext

func (*CaseClauseContext) IsCaseClauseContext

func (*CaseClauseContext) IsCaseClauseContext()

func (*CaseClauseContext) SingleExpression

func (s *CaseClauseContext) SingleExpression() ISingleExpressionContext

func (*CaseClauseContext) StatementList

func (s *CaseClauseContext) StatementList() IStatementListContext

func (*CaseClauseContext) ToStringTree

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

type CaseClausesContext

type CaseClausesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCaseClausesContext

func NewCaseClausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseClausesContext

func NewEmptyCaseClausesContext

func NewEmptyCaseClausesContext() *CaseClausesContext

func (*CaseClausesContext) Accept

func (s *CaseClausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CaseClausesContext) AllCaseClause

func (s *CaseClausesContext) AllCaseClause() []ICaseClauseContext

func (*CaseClausesContext) CaseClause

func (s *CaseClausesContext) CaseClause(i int) ICaseClauseContext

func (*CaseClausesContext) GetParser

func (s *CaseClausesContext) GetParser() antlr.Parser

func (*CaseClausesContext) GetRuleContext

func (s *CaseClausesContext) GetRuleContext() antlr.RuleContext

func (*CaseClausesContext) IsCaseClausesContext

func (*CaseClausesContext) IsCaseClausesContext()

func (*CaseClausesContext) ToStringTree

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

type CatchProductionContext

type CatchProductionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCatchProductionContext

func NewCatchProductionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchProductionContext

func NewEmptyCatchProductionContext

func NewEmptyCatchProductionContext() *CatchProductionContext

func (*CatchProductionContext) Accept

func (s *CatchProductionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CatchProductionContext) Assignable

func (s *CatchProductionContext) Assignable() IAssignableContext

func (*CatchProductionContext) Block

func (s *CatchProductionContext) Block() IBlockContext

func (*CatchProductionContext) Catch

func (s *CatchProductionContext) Catch() antlr.TerminalNode

func (*CatchProductionContext) CloseParen

func (s *CatchProductionContext) CloseParen() antlr.TerminalNode

func (*CatchProductionContext) GetParser

func (s *CatchProductionContext) GetParser() antlr.Parser

func (*CatchProductionContext) GetRuleContext

func (s *CatchProductionContext) GetRuleContext() antlr.RuleContext

func (*CatchProductionContext) IsCatchProductionContext

func (*CatchProductionContext) IsCatchProductionContext()

func (*CatchProductionContext) OpenParen

func (s *CatchProductionContext) OpenParen() antlr.TerminalNode

func (*CatchProductionContext) ToStringTree

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

type ClassDeclarationContext

type ClassDeclarationContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewClassDeclarationContext

func NewClassDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassDeclarationContext

func NewEmptyClassDeclarationContext

func NewEmptyClassDeclarationContext() *ClassDeclarationContext

func (*ClassDeclarationContext) Accept

func (s *ClassDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ClassDeclarationContext) Class

func (s *ClassDeclarationContext) Class() antlr.TerminalNode

func (*ClassDeclarationContext) ClassTail

func (s *ClassDeclarationContext) ClassTail() IClassTailContext

func (*ClassDeclarationContext) GetParser

func (s *ClassDeclarationContext) GetParser() antlr.Parser

func (*ClassDeclarationContext) GetRuleContext

func (s *ClassDeclarationContext) GetRuleContext() antlr.RuleContext

func (*ClassDeclarationContext) Identifier

func (s *ClassDeclarationContext) Identifier() IIdentifierContext

func (*ClassDeclarationContext) IsClassDeclarationContext

func (*ClassDeclarationContext) IsClassDeclarationContext()

func (*ClassDeclarationContext) ToStringTree

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

type ClassElementContext

type ClassElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewClassElementContext

func NewClassElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassElementContext

func NewEmptyClassElementContext

func NewEmptyClassElementContext() *ClassElementContext

func (*ClassElementContext) Accept

func (s *ClassElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ClassElementContext) Block

func (s *ClassElementContext) Block() IBlockContext

func (*ClassElementContext) EmptyStatement_

func (s *ClassElementContext) EmptyStatement_() IEmptyStatement_Context

func (*ClassElementContext) FieldDefinition

func (s *ClassElementContext) FieldDefinition() IFieldDefinitionContext

func (*ClassElementContext) GetParser

func (s *ClassElementContext) GetParser() antlr.Parser

func (*ClassElementContext) GetRuleContext

func (s *ClassElementContext) GetRuleContext() antlr.RuleContext

func (*ClassElementContext) Identifier

func (s *ClassElementContext) Identifier() IIdentifierContext

func (*ClassElementContext) IsClassElementContext

func (*ClassElementContext) IsClassElementContext()

func (*ClassElementContext) MethodDefinition

func (s *ClassElementContext) MethodDefinition() IMethodDefinitionContext

func (*ClassElementContext) Static

func (s *ClassElementContext) Static() antlr.TerminalNode

func (*ClassElementContext) ToStringTree

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

type ClassElementNameContext

type ClassElementNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewClassElementNameContext

func NewClassElementNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassElementNameContext

func NewEmptyClassElementNameContext

func NewEmptyClassElementNameContext() *ClassElementNameContext

func (*ClassElementNameContext) Accept

func (s *ClassElementNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ClassElementNameContext) GetParser

func (s *ClassElementNameContext) GetParser() antlr.Parser

func (*ClassElementNameContext) GetRuleContext

func (s *ClassElementNameContext) GetRuleContext() antlr.RuleContext

func (*ClassElementNameContext) IsClassElementNameContext

func (*ClassElementNameContext) IsClassElementNameContext()

func (*ClassElementNameContext) PrivateIdentifier

func (s *ClassElementNameContext) PrivateIdentifier() IPrivateIdentifierContext

func (*ClassElementNameContext) PropertyName

func (s *ClassElementNameContext) PropertyName() IPropertyNameContext

func (*ClassElementNameContext) ToStringTree

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

type ClassExpressionContext

type ClassExpressionContext struct {
	SingleExpressionContext
}

func NewClassExpressionContext

func NewClassExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ClassExpressionContext

func (*ClassExpressionContext) Accept

func (s *ClassExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ClassExpressionContext) Class

func (s *ClassExpressionContext) Class() antlr.TerminalNode

func (*ClassExpressionContext) ClassTail

func (s *ClassExpressionContext) ClassTail() IClassTailContext

func (*ClassExpressionContext) GetRuleContext

func (s *ClassExpressionContext) GetRuleContext() antlr.RuleContext

func (*ClassExpressionContext) Identifier

func (s *ClassExpressionContext) Identifier() IIdentifierContext

type ClassTailContext

type ClassTailContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewClassTailContext

func NewClassTailContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassTailContext

func NewEmptyClassTailContext

func NewEmptyClassTailContext() *ClassTailContext

func (*ClassTailContext) Accept

func (s *ClassTailContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ClassTailContext) AllClassElement

func (s *ClassTailContext) AllClassElement() []IClassElementContext

func (*ClassTailContext) ClassElement

func (s *ClassTailContext) ClassElement(i int) IClassElementContext

func (*ClassTailContext) CloseBrace

func (s *ClassTailContext) CloseBrace() antlr.TerminalNode

func (*ClassTailContext) Extends

func (s *ClassTailContext) Extends() antlr.TerminalNode

func (*ClassTailContext) GetParser

func (s *ClassTailContext) GetParser() antlr.Parser

func (*ClassTailContext) GetRuleContext

func (s *ClassTailContext) GetRuleContext() antlr.RuleContext

func (*ClassTailContext) IsClassTailContext

func (*ClassTailContext) IsClassTailContext()

func (*ClassTailContext) OpenBrace

func (s *ClassTailContext) OpenBrace() antlr.TerminalNode

func (*ClassTailContext) SingleExpression

func (s *ClassTailContext) SingleExpression() ISingleExpressionContext

func (*ClassTailContext) ToStringTree

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

type CoalesceExpressionContext

type CoalesceExpressionContext struct {
	SingleExpressionContext
}

func NewCoalesceExpressionContext

func NewCoalesceExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CoalesceExpressionContext

func (*CoalesceExpressionContext) Accept

func (s *CoalesceExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CoalesceExpressionContext) AllSingleExpression

func (s *CoalesceExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*CoalesceExpressionContext) GetRuleContext

func (s *CoalesceExpressionContext) GetRuleContext() antlr.RuleContext

func (*CoalesceExpressionContext) NullCoalesce

func (s *CoalesceExpressionContext) NullCoalesce() antlr.TerminalNode

func (*CoalesceExpressionContext) SingleExpression

func (s *CoalesceExpressionContext) SingleExpression(i int) ISingleExpressionContext

type ComputedPropertyExpressionAssignmentContext

type ComputedPropertyExpressionAssignmentContext struct {
	PropertyAssignmentContext
}

func NewComputedPropertyExpressionAssignmentContext

func NewComputedPropertyExpressionAssignmentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ComputedPropertyExpressionAssignmentContext

func (*ComputedPropertyExpressionAssignmentContext) Accept

func (s *ComputedPropertyExpressionAssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ComputedPropertyExpressionAssignmentContext) AllSingleExpression

func (s *ComputedPropertyExpressionAssignmentContext) AllSingleExpression() []ISingleExpressionContext

func (*ComputedPropertyExpressionAssignmentContext) CloseBracket

func (s *ComputedPropertyExpressionAssignmentContext) CloseBracket() antlr.TerminalNode

func (*ComputedPropertyExpressionAssignmentContext) Colon

func (s *ComputedPropertyExpressionAssignmentContext) Colon() antlr.TerminalNode

func (*ComputedPropertyExpressionAssignmentContext) GetRuleContext

func (s *ComputedPropertyExpressionAssignmentContext) GetRuleContext() antlr.RuleContext

func (*ComputedPropertyExpressionAssignmentContext) OpenBracket

func (s *ComputedPropertyExpressionAssignmentContext) OpenBracket() antlr.TerminalNode

func (*ComputedPropertyExpressionAssignmentContext) SingleExpression

func (s *ComputedPropertyExpressionAssignmentContext) SingleExpression(i int) ISingleExpressionContext

type ContinueStatementContext

type ContinueStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewContinueStatementContext

func NewContinueStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContinueStatementContext

func NewEmptyContinueStatementContext

func NewEmptyContinueStatementContext() *ContinueStatementContext

func (*ContinueStatementContext) Accept

func (s *ContinueStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ContinueStatementContext) Continue

func (s *ContinueStatementContext) Continue() antlr.TerminalNode

func (*ContinueStatementContext) Eos

func (s *ContinueStatementContext) Eos() IEosContext

func (*ContinueStatementContext) GetParser

func (s *ContinueStatementContext) GetParser() antlr.Parser

func (*ContinueStatementContext) GetRuleContext

func (s *ContinueStatementContext) GetRuleContext() antlr.RuleContext

func (*ContinueStatementContext) Identifier

func (s *ContinueStatementContext) Identifier() IIdentifierContext

func (*ContinueStatementContext) IsContinueStatementContext

func (*ContinueStatementContext) IsContinueStatementContext()

func (*ContinueStatementContext) ToStringTree

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

type DebuggerStatementContext

type DebuggerStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDebuggerStatementContext

func NewDebuggerStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DebuggerStatementContext

func NewEmptyDebuggerStatementContext

func NewEmptyDebuggerStatementContext() *DebuggerStatementContext

func (*DebuggerStatementContext) Accept

func (s *DebuggerStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DebuggerStatementContext) Debugger

func (s *DebuggerStatementContext) Debugger() antlr.TerminalNode

func (*DebuggerStatementContext) Eos

func (s *DebuggerStatementContext) Eos() IEosContext

func (*DebuggerStatementContext) GetParser

func (s *DebuggerStatementContext) GetParser() antlr.Parser

func (*DebuggerStatementContext) GetRuleContext

func (s *DebuggerStatementContext) GetRuleContext() antlr.RuleContext

func (*DebuggerStatementContext) IsDebuggerStatementContext

func (*DebuggerStatementContext) IsDebuggerStatementContext()

func (*DebuggerStatementContext) ToStringTree

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

type DeclarationContext

type DeclarationContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeclarationContext

func NewDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclarationContext

func NewEmptyDeclarationContext

func NewEmptyDeclarationContext() *DeclarationContext

func (*DeclarationContext) Accept

func (s *DeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DeclarationContext) ClassDeclaration

func (s *DeclarationContext) ClassDeclaration() IClassDeclarationContext

func (*DeclarationContext) FunctionDeclaration

func (s *DeclarationContext) FunctionDeclaration() IFunctionDeclarationContext

func (*DeclarationContext) GetParser

func (s *DeclarationContext) GetParser() antlr.Parser

func (*DeclarationContext) GetRuleContext

func (s *DeclarationContext) GetRuleContext() antlr.RuleContext

func (*DeclarationContext) IsDeclarationContext

func (*DeclarationContext) IsDeclarationContext()

func (*DeclarationContext) ToStringTree

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

func (*DeclarationContext) VariableStatement

func (s *DeclarationContext) VariableStatement() IVariableStatementContext

type DefaultClauseContext

type DefaultClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDefaultClauseContext

func NewDefaultClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultClauseContext

func NewEmptyDefaultClauseContext

func NewEmptyDefaultClauseContext() *DefaultClauseContext

func (*DefaultClauseContext) Accept

func (s *DefaultClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DefaultClauseContext) Colon

func (s *DefaultClauseContext) Colon() antlr.TerminalNode

func (*DefaultClauseContext) Default

func (s *DefaultClauseContext) Default() antlr.TerminalNode

func (*DefaultClauseContext) GetParser

func (s *DefaultClauseContext) GetParser() antlr.Parser

func (*DefaultClauseContext) GetRuleContext

func (s *DefaultClauseContext) GetRuleContext() antlr.RuleContext

func (*DefaultClauseContext) IsDefaultClauseContext

func (*DefaultClauseContext) IsDefaultClauseContext()

func (*DefaultClauseContext) StatementList

func (s *DefaultClauseContext) StatementList() IStatementListContext

func (*DefaultClauseContext) ToStringTree

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

type DeleteExpressionContext

type DeleteExpressionContext struct {
	SingleExpressionContext
}

func NewDeleteExpressionContext

func NewDeleteExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DeleteExpressionContext

func (*DeleteExpressionContext) Accept

func (s *DeleteExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DeleteExpressionContext) Delete

func (s *DeleteExpressionContext) Delete() antlr.TerminalNode

func (*DeleteExpressionContext) GetRuleContext

func (s *DeleteExpressionContext) GetRuleContext() antlr.RuleContext

func (*DeleteExpressionContext) SingleExpression

func (s *DeleteExpressionContext) SingleExpression() ISingleExpressionContext

type DoStatementContext

type DoStatementContext struct {
	IterationStatementContext
}

func NewDoStatementContext

func NewDoStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoStatementContext

func (*DoStatementContext) Accept

func (s *DoStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DoStatementContext) CloseParen

func (s *DoStatementContext) CloseParen() antlr.TerminalNode

func (*DoStatementContext) Do

func (s *DoStatementContext) Do() antlr.TerminalNode

func (*DoStatementContext) Eos

func (s *DoStatementContext) Eos() IEosContext

func (*DoStatementContext) GetRuleContext

func (s *DoStatementContext) GetRuleContext() antlr.RuleContext

func (*DoStatementContext) OpenParen

func (s *DoStatementContext) OpenParen() antlr.TerminalNode

func (*DoStatementContext) SingleExpression

func (s *DoStatementContext) SingleExpression() ISingleExpressionContext

func (*DoStatementContext) Statement

func (s *DoStatementContext) Statement() IStatementContext

func (*DoStatementContext) While

func (s *DoStatementContext) While() antlr.TerminalNode

type ElementListContext

type ElementListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewElementListContext

func NewElementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementListContext

func NewEmptyElementListContext

func NewEmptyElementListContext() *ElementListContext

func (*ElementListContext) Accept

func (s *ElementListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ElementListContext) AllArrayElement

func (s *ElementListContext) AllArrayElement() []IArrayElementContext

func (*ElementListContext) AllComma

func (s *ElementListContext) AllComma() []antlr.TerminalNode

func (*ElementListContext) ArrayElement

func (s *ElementListContext) ArrayElement(i int) IArrayElementContext

func (*ElementListContext) Comma

func (s *ElementListContext) Comma(i int) antlr.TerminalNode

func (*ElementListContext) GetParser

func (s *ElementListContext) GetParser() antlr.Parser

func (*ElementListContext) GetRuleContext

func (s *ElementListContext) GetRuleContext() antlr.RuleContext

func (*ElementListContext) IsElementListContext

func (*ElementListContext) IsElementListContext()

func (*ElementListContext) ToStringTree

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

type ElseBlockContext

type ElseBlockContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewElseBlockContext

func NewElseBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElseBlockContext

func NewEmptyElseBlockContext

func NewEmptyElseBlockContext() *ElseBlockContext

func (*ElseBlockContext) Accept

func (s *ElseBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ElseBlockContext) Else

func (s *ElseBlockContext) Else() antlr.TerminalNode

func (*ElseBlockContext) GetParser

func (s *ElseBlockContext) GetParser() antlr.Parser

func (*ElseBlockContext) GetRuleContext

func (s *ElseBlockContext) GetRuleContext() antlr.RuleContext

func (*ElseBlockContext) IsElseBlockContext

func (*ElseBlockContext) IsElseBlockContext()

func (*ElseBlockContext) Statement

func (s *ElseBlockContext) Statement() IStatementContext

func (*ElseBlockContext) ToStringTree

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

type EmptyStatement_Context

type EmptyStatement_Context struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEmptyStatement_Context

func NewEmptyEmptyStatement_Context() *EmptyStatement_Context

func NewEmptyStatement_Context

func NewEmptyStatement_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EmptyStatement_Context

func (*EmptyStatement_Context) Accept

func (s *EmptyStatement_Context) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EmptyStatement_Context) GetParser

func (s *EmptyStatement_Context) GetParser() antlr.Parser

func (*EmptyStatement_Context) GetRuleContext

func (s *EmptyStatement_Context) GetRuleContext() antlr.RuleContext

func (*EmptyStatement_Context) IsEmptyStatement_Context

func (*EmptyStatement_Context) IsEmptyStatement_Context()

func (*EmptyStatement_Context) SemiColon

func (s *EmptyStatement_Context) SemiColon() antlr.TerminalNode

func (*EmptyStatement_Context) ToStringTree

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

type EosContext

type EosContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEosContext

func NewEmptyEosContext() *EosContext

func NewEosContext

func NewEosContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EosContext

func (*EosContext) Accept

func (s *EosContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EosContext) EOF

func (s *EosContext) EOF() antlr.TerminalNode

func (*EosContext) GetParser

func (s *EosContext) GetParser() antlr.Parser

func (*EosContext) GetRuleContext

func (s *EosContext) GetRuleContext() antlr.RuleContext

func (*EosContext) IsEosContext

func (*EosContext) IsEosContext()

func (*EosContext) SemiColon

func (s *EosContext) SemiColon() antlr.TerminalNode

func (*EosContext) ToStringTree

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

type EqualityExpressionContext

type EqualityExpressionContext struct {
	SingleExpressionContext
}

func NewEqualityExpressionContext

func NewEqualityExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqualityExpressionContext

func (*EqualityExpressionContext) Accept

func (s *EqualityExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EqualityExpressionContext) AllSingleExpression

func (s *EqualityExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*EqualityExpressionContext) Equals_

func (s *EqualityExpressionContext) Equals_() antlr.TerminalNode

func (*EqualityExpressionContext) GetRuleContext

func (s *EqualityExpressionContext) GetRuleContext() antlr.RuleContext

func (*EqualityExpressionContext) IdentityEquals

func (s *EqualityExpressionContext) IdentityEquals() antlr.TerminalNode

func (*EqualityExpressionContext) IdentityNotEquals

func (s *EqualityExpressionContext) IdentityNotEquals() antlr.TerminalNode

func (*EqualityExpressionContext) NotEquals

func (s *EqualityExpressionContext) NotEquals() antlr.TerminalNode

func (*EqualityExpressionContext) SingleExpression

func (s *EqualityExpressionContext) SingleExpression(i int) ISingleExpressionContext

type ExportAliasNameContext

type ExportAliasNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExportAliasNameContext

func NewEmptyExportAliasNameContext() *ExportAliasNameContext

func NewExportAliasNameContext

func NewExportAliasNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExportAliasNameContext

func (*ExportAliasNameContext) Accept

func (s *ExportAliasNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExportAliasNameContext) AllModuleExportName

func (s *ExportAliasNameContext) AllModuleExportName() []IModuleExportNameContext

func (*ExportAliasNameContext) As

func (s *ExportAliasNameContext) As() antlr.TerminalNode

func (*ExportAliasNameContext) GetParser

func (s *ExportAliasNameContext) GetParser() antlr.Parser

func (*ExportAliasNameContext) GetRuleContext

func (s *ExportAliasNameContext) GetRuleContext() antlr.RuleContext

func (*ExportAliasNameContext) IsExportAliasNameContext

func (*ExportAliasNameContext) IsExportAliasNameContext()

func (*ExportAliasNameContext) ModuleExportName

func (s *ExportAliasNameContext) ModuleExportName(i int) IModuleExportNameContext

func (*ExportAliasNameContext) ToStringTree

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

type ExportDeclarationContext

type ExportDeclarationContext struct {
	ExportStatementContext
}

func NewExportDeclarationContext

func NewExportDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExportDeclarationContext

func (*ExportDeclarationContext) Accept

func (s *ExportDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExportDeclarationContext) Declaration

func (s *ExportDeclarationContext) Declaration() IDeclarationContext

func (*ExportDeclarationContext) Default

func (s *ExportDeclarationContext) Default() antlr.TerminalNode

func (*ExportDeclarationContext) Eos

func (s *ExportDeclarationContext) Eos() IEosContext

func (*ExportDeclarationContext) Export

func (s *ExportDeclarationContext) Export() antlr.TerminalNode

func (*ExportDeclarationContext) ExportFromBlock

func (s *ExportDeclarationContext) ExportFromBlock() IExportFromBlockContext

func (*ExportDeclarationContext) GetRuleContext

func (s *ExportDeclarationContext) GetRuleContext() antlr.RuleContext

type ExportDefaultDeclarationContext

type ExportDefaultDeclarationContext struct {
	ExportStatementContext
}

func NewExportDefaultDeclarationContext

func NewExportDefaultDeclarationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExportDefaultDeclarationContext

func (*ExportDefaultDeclarationContext) Accept

func (s *ExportDefaultDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExportDefaultDeclarationContext) Default

func (s *ExportDefaultDeclarationContext) Default() antlr.TerminalNode

func (*ExportDefaultDeclarationContext) Eos

func (s *ExportDefaultDeclarationContext) Eos() IEosContext

func (*ExportDefaultDeclarationContext) Export

func (s *ExportDefaultDeclarationContext) Export() antlr.TerminalNode

func (*ExportDefaultDeclarationContext) GetRuleContext

func (s *ExportDefaultDeclarationContext) GetRuleContext() antlr.RuleContext

func (*ExportDefaultDeclarationContext) SingleExpression

func (s *ExportDefaultDeclarationContext) SingleExpression() ISingleExpressionContext

type ExportFromBlockContext

type ExportFromBlockContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExportFromBlockContext

func NewEmptyExportFromBlockContext() *ExportFromBlockContext

func NewExportFromBlockContext

func NewExportFromBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExportFromBlockContext

func (*ExportFromBlockContext) Accept

func (s *ExportFromBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExportFromBlockContext) Eos

func (s *ExportFromBlockContext) Eos() IEosContext

func (*ExportFromBlockContext) ExportModuleItems

func (s *ExportFromBlockContext) ExportModuleItems() IExportModuleItemsContext

func (*ExportFromBlockContext) GetParser

func (s *ExportFromBlockContext) GetParser() antlr.Parser

func (*ExportFromBlockContext) GetRuleContext

func (s *ExportFromBlockContext) GetRuleContext() antlr.RuleContext

func (*ExportFromBlockContext) ImportFrom

func (s *ExportFromBlockContext) ImportFrom() IImportFromContext

func (*ExportFromBlockContext) ImportNamespace

func (s *ExportFromBlockContext) ImportNamespace() IImportNamespaceContext

func (*ExportFromBlockContext) IsExportFromBlockContext

func (*ExportFromBlockContext) IsExportFromBlockContext()

func (*ExportFromBlockContext) ToStringTree

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

type ExportModuleItemsContext

type ExportModuleItemsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExportModuleItemsContext

func NewEmptyExportModuleItemsContext() *ExportModuleItemsContext

func NewExportModuleItemsContext

func NewExportModuleItemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExportModuleItemsContext

func (*ExportModuleItemsContext) Accept

func (s *ExportModuleItemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExportModuleItemsContext) AllComma

func (s *ExportModuleItemsContext) AllComma() []antlr.TerminalNode

func (*ExportModuleItemsContext) AllExportAliasName

func (s *ExportModuleItemsContext) AllExportAliasName() []IExportAliasNameContext

func (*ExportModuleItemsContext) CloseBrace

func (s *ExportModuleItemsContext) CloseBrace() antlr.TerminalNode

func (*ExportModuleItemsContext) Comma

func (s *ExportModuleItemsContext) Comma(i int) antlr.TerminalNode

func (*ExportModuleItemsContext) ExportAliasName

func (s *ExportModuleItemsContext) ExportAliasName(i int) IExportAliasNameContext

func (*ExportModuleItemsContext) GetParser

func (s *ExportModuleItemsContext) GetParser() antlr.Parser

func (*ExportModuleItemsContext) GetRuleContext

func (s *ExportModuleItemsContext) GetRuleContext() antlr.RuleContext

func (*ExportModuleItemsContext) IsExportModuleItemsContext

func (*ExportModuleItemsContext) IsExportModuleItemsContext()

func (*ExportModuleItemsContext) OpenBrace

func (s *ExportModuleItemsContext) OpenBrace() antlr.TerminalNode

func (*ExportModuleItemsContext) ToStringTree

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

type ExportStatementContext

type ExportStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExportStatementContext

func NewEmptyExportStatementContext() *ExportStatementContext

func NewExportStatementContext

func NewExportStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExportStatementContext

func (*ExportStatementContext) CopyAll

func (s *ExportStatementContext) CopyAll(ctx *ExportStatementContext)

func (*ExportStatementContext) GetParser

func (s *ExportStatementContext) GetParser() antlr.Parser

func (*ExportStatementContext) GetRuleContext

func (s *ExportStatementContext) GetRuleContext() antlr.RuleContext

func (*ExportStatementContext) IsExportStatementContext

func (*ExportStatementContext) IsExportStatementContext()

func (*ExportStatementContext) ToStringTree

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

type ExpressionSequenceContext

type ExpressionSequenceContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionSequenceContext

func NewEmptyExpressionSequenceContext() *ExpressionSequenceContext

func NewExpressionSequenceContext

func NewExpressionSequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionSequenceContext

func (*ExpressionSequenceContext) Accept

func (s *ExpressionSequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExpressionSequenceContext) AllComma

func (s *ExpressionSequenceContext) AllComma() []antlr.TerminalNode

func (*ExpressionSequenceContext) AllSingleExpression

func (s *ExpressionSequenceContext) AllSingleExpression() []ISingleExpressionContext

func (*ExpressionSequenceContext) Comma

func (s *ExpressionSequenceContext) Comma(i int) antlr.TerminalNode

func (*ExpressionSequenceContext) GetParser

func (s *ExpressionSequenceContext) GetParser() antlr.Parser

func (*ExpressionSequenceContext) GetRuleContext

func (s *ExpressionSequenceContext) GetRuleContext() antlr.RuleContext

func (*ExpressionSequenceContext) IsExpressionSequenceContext

func (*ExpressionSequenceContext) IsExpressionSequenceContext()

func (*ExpressionSequenceContext) SingleExpression

func (s *ExpressionSequenceContext) SingleExpression(i int) ISingleExpressionContext

func (*ExpressionSequenceContext) ToStringTree

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

type ExpressionStatementContext

type ExpressionStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionStatementContext

func NewEmptyExpressionStatementContext() *ExpressionStatementContext

func NewExpressionStatementContext

func NewExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionStatementContext

func (*ExpressionStatementContext) Accept

func (s *ExpressionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExpressionStatementContext) Eos

func (s *ExpressionStatementContext) Eos() IEosContext

func (*ExpressionStatementContext) ExpressionSequence

func (s *ExpressionStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ExpressionStatementContext) GetParser

func (s *ExpressionStatementContext) GetParser() antlr.Parser

func (*ExpressionStatementContext) GetRuleContext

func (s *ExpressionStatementContext) GetRuleContext() antlr.RuleContext

func (*ExpressionStatementContext) IsExpressionStatementContext

func (*ExpressionStatementContext) IsExpressionStatementContext()

func (*ExpressionStatementContext) ToStringTree

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

type FieldDefinitionContext

type FieldDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldDefinitionContext

func NewEmptyFieldDefinitionContext() *FieldDefinitionContext

func NewFieldDefinitionContext

func NewFieldDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldDefinitionContext

func (*FieldDefinitionContext) Accept

func (s *FieldDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FieldDefinitionContext) ClassElementName

func (s *FieldDefinitionContext) ClassElementName() IClassElementNameContext

func (*FieldDefinitionContext) GetParser

func (s *FieldDefinitionContext) GetParser() antlr.Parser

func (*FieldDefinitionContext) GetRuleContext

func (s *FieldDefinitionContext) GetRuleContext() antlr.RuleContext

func (*FieldDefinitionContext) Initializer

func (s *FieldDefinitionContext) Initializer() IInitializerContext

func (*FieldDefinitionContext) IsFieldDefinitionContext

func (*FieldDefinitionContext) IsFieldDefinitionContext()

func (*FieldDefinitionContext) ToStringTree

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

type FinallyProductionContext

type FinallyProductionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFinallyProductionContext

func NewEmptyFinallyProductionContext() *FinallyProductionContext

func NewFinallyProductionContext

func NewFinallyProductionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FinallyProductionContext

func (*FinallyProductionContext) Accept

func (s *FinallyProductionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FinallyProductionContext) Block

func (s *FinallyProductionContext) Block() IBlockContext

func (*FinallyProductionContext) Finally

func (s *FinallyProductionContext) Finally() antlr.TerminalNode

func (*FinallyProductionContext) GetParser

func (s *FinallyProductionContext) GetParser() antlr.Parser

func (*FinallyProductionContext) GetRuleContext

func (s *FinallyProductionContext) GetRuleContext() antlr.RuleContext

func (*FinallyProductionContext) IsFinallyProductionContext

func (*FinallyProductionContext) IsFinallyProductionContext()

func (*FinallyProductionContext) ToStringTree

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

type ForFirstContext

type ForFirstContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForFirstContext

func NewEmptyForFirstContext() *ForFirstContext

func NewForFirstContext

func NewForFirstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForFirstContext

func (*ForFirstContext) Accept

func (s *ForFirstContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForFirstContext) GetParser

func (s *ForFirstContext) GetParser() antlr.Parser

func (*ForFirstContext) GetRuleContext

func (s *ForFirstContext) GetRuleContext() antlr.RuleContext

func (*ForFirstContext) IsForFirstContext

func (*ForFirstContext) IsForFirstContext()

func (*ForFirstContext) SingleExpression

func (s *ForFirstContext) SingleExpression() ISingleExpressionContext

func (*ForFirstContext) ToStringTree

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

func (*ForFirstContext) VariableDeclarationList

func (s *ForFirstContext) VariableDeclarationList() IVariableDeclarationListContext

type ForInStatementContext

type ForInStatementContext struct {
	IterationStatementContext
}

func NewForInStatementContext

func NewForInStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForInStatementContext

func (*ForInStatementContext) Accept

func (s *ForInStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForInStatementContext) AllSingleExpression

func (s *ForInStatementContext) AllSingleExpression() []ISingleExpressionContext

func (*ForInStatementContext) CloseParen

func (s *ForInStatementContext) CloseParen() antlr.TerminalNode

func (*ForInStatementContext) For

func (s *ForInStatementContext) For() antlr.TerminalNode

func (*ForInStatementContext) GetRuleContext

func (s *ForInStatementContext) GetRuleContext() antlr.RuleContext

func (*ForInStatementContext) In

func (s *ForInStatementContext) In() antlr.TerminalNode

func (*ForInStatementContext) OpenParen

func (s *ForInStatementContext) OpenParen() antlr.TerminalNode

func (*ForInStatementContext) SingleExpression

func (s *ForInStatementContext) SingleExpression(i int) ISingleExpressionContext

func (*ForInStatementContext) Statement

func (s *ForInStatementContext) Statement() IStatementContext

func (*ForInStatementContext) VariableDeclaration

func (s *ForInStatementContext) VariableDeclaration() IVariableDeclarationContext

type ForOfStatementContext

type ForOfStatementContext struct {
	IterationStatementContext
}

func NewForOfStatementContext

func NewForOfStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForOfStatementContext

func (*ForOfStatementContext) Accept

func (s *ForOfStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForOfStatementContext) AllSingleExpression

func (s *ForOfStatementContext) AllSingleExpression() []ISingleExpressionContext

func (*ForOfStatementContext) Await

func (s *ForOfStatementContext) Await() antlr.TerminalNode

func (*ForOfStatementContext) CloseParen

func (s *ForOfStatementContext) CloseParen() antlr.TerminalNode

func (*ForOfStatementContext) For

func (s *ForOfStatementContext) For() antlr.TerminalNode

func (*ForOfStatementContext) GetRuleContext

func (s *ForOfStatementContext) GetRuleContext() antlr.RuleContext

func (*ForOfStatementContext) Identifier

func (s *ForOfStatementContext) Identifier() IIdentifierContext

func (*ForOfStatementContext) OpenParen

func (s *ForOfStatementContext) OpenParen() antlr.TerminalNode

func (*ForOfStatementContext) SingleExpression

func (s *ForOfStatementContext) SingleExpression(i int) ISingleExpressionContext

func (*ForOfStatementContext) Statement

func (s *ForOfStatementContext) Statement() IStatementContext

func (*ForOfStatementContext) VariableDeclaration

func (s *ForOfStatementContext) VariableDeclaration() IVariableDeclarationContext

type ForSecondContext

type ForSecondContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForSecondContext

func NewEmptyForSecondContext() *ForSecondContext

func NewForSecondContext

func NewForSecondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForSecondContext

func (*ForSecondContext) Accept

func (s *ForSecondContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForSecondContext) GetParser

func (s *ForSecondContext) GetParser() antlr.Parser

func (*ForSecondContext) GetRuleContext

func (s *ForSecondContext) GetRuleContext() antlr.RuleContext

func (*ForSecondContext) IsForSecondContext

func (*ForSecondContext) IsForSecondContext()

func (*ForSecondContext) SingleExpression

func (s *ForSecondContext) SingleExpression() ISingleExpressionContext

func (*ForSecondContext) ToStringTree

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

type ForStatementContext

type ForStatementContext struct {
	IterationStatementContext
}

func NewForStatementContext

func NewForStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForStatementContext

func (*ForStatementContext) Accept

func (s *ForStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForStatementContext) AllSemiColon

func (s *ForStatementContext) AllSemiColon() []antlr.TerminalNode

func (*ForStatementContext) CloseParen

func (s *ForStatementContext) CloseParen() antlr.TerminalNode

func (*ForStatementContext) For

func (s *ForStatementContext) For() antlr.TerminalNode

func (*ForStatementContext) ForFirst

func (s *ForStatementContext) ForFirst() IForFirstContext

func (*ForStatementContext) ForSecond

func (s *ForStatementContext) ForSecond() IForSecondContext

func (*ForStatementContext) ForThird

func (s *ForStatementContext) ForThird() IForThirdContext

func (*ForStatementContext) GetRuleContext

func (s *ForStatementContext) GetRuleContext() antlr.RuleContext

func (*ForStatementContext) OpenParen

func (s *ForStatementContext) OpenParen() antlr.TerminalNode

func (*ForStatementContext) SemiColon

func (s *ForStatementContext) SemiColon(i int) antlr.TerminalNode

func (*ForStatementContext) Statement

func (s *ForStatementContext) Statement() IStatementContext

type ForThirdContext

type ForThirdContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForThirdContext

func NewEmptyForThirdContext() *ForThirdContext

func NewForThirdContext

func NewForThirdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForThirdContext

func (*ForThirdContext) Accept

func (s *ForThirdContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForThirdContext) GetParser

func (s *ForThirdContext) GetParser() antlr.Parser

func (*ForThirdContext) GetRuleContext

func (s *ForThirdContext) GetRuleContext() antlr.RuleContext

func (*ForThirdContext) IsForThirdContext

func (*ForThirdContext) IsForThirdContext()

func (*ForThirdContext) SingleExpression

func (s *ForThirdContext) SingleExpression() ISingleExpressionContext

func (*ForThirdContext) ToStringTree

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

type FormalParameterArgContext

type FormalParameterArgContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFormalParameterArgContext

func NewEmptyFormalParameterArgContext() *FormalParameterArgContext

func NewFormalParameterArgContext

func NewFormalParameterArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParameterArgContext

func (*FormalParameterArgContext) Accept

func (s *FormalParameterArgContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FormalParameterArgContext) Assign

func (s *FormalParameterArgContext) Assign() antlr.TerminalNode

func (*FormalParameterArgContext) Assignable

func (s *FormalParameterArgContext) Assignable() IAssignableContext

func (*FormalParameterArgContext) GetParser

func (s *FormalParameterArgContext) GetParser() antlr.Parser

func (*FormalParameterArgContext) GetRuleContext

func (s *FormalParameterArgContext) GetRuleContext() antlr.RuleContext

func (*FormalParameterArgContext) IsFormalParameterArgContext

func (*FormalParameterArgContext) IsFormalParameterArgContext()

func (*FormalParameterArgContext) SingleExpression

func (s *FormalParameterArgContext) SingleExpression() ISingleExpressionContext

func (*FormalParameterArgContext) ToStringTree

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

type FormalParameterListContext

type FormalParameterListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFormalParameterListContext

func NewEmptyFormalParameterListContext() *FormalParameterListContext

func NewFormalParameterListContext

func NewFormalParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParameterListContext

func (*FormalParameterListContext) Accept

func (s *FormalParameterListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FormalParameterListContext) AllComma

func (s *FormalParameterListContext) AllComma() []antlr.TerminalNode

func (*FormalParameterListContext) AllFormalParameterArg

func (s *FormalParameterListContext) AllFormalParameterArg() []IFormalParameterArgContext

func (*FormalParameterListContext) Comma

func (s *FormalParameterListContext) Comma(i int) antlr.TerminalNode

func (*FormalParameterListContext) FormalParameterArg

func (s *FormalParameterListContext) FormalParameterArg(i int) IFormalParameterArgContext

func (*FormalParameterListContext) GetParser

func (s *FormalParameterListContext) GetParser() antlr.Parser

func (*FormalParameterListContext) GetRuleContext

func (s *FormalParameterListContext) GetRuleContext() antlr.RuleContext

func (*FormalParameterListContext) IsFormalParameterListContext

func (*FormalParameterListContext) IsFormalParameterListContext()

func (*FormalParameterListContext) LastFormalParameterArg

func (s *FormalParameterListContext) LastFormalParameterArg() ILastFormalParameterArgContext

func (*FormalParameterListContext) ToStringTree

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

type FunctionBodyContext

type FunctionBodyContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionBodyContext

func NewEmptyFunctionBodyContext() *FunctionBodyContext

func NewFunctionBodyContext

func NewFunctionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionBodyContext

func (*FunctionBodyContext) Accept

func (s *FunctionBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionBodyContext) CloseBrace

func (s *FunctionBodyContext) CloseBrace() antlr.TerminalNode

func (*FunctionBodyContext) GetParser

func (s *FunctionBodyContext) GetParser() antlr.Parser

func (*FunctionBodyContext) GetRuleContext

func (s *FunctionBodyContext) GetRuleContext() antlr.RuleContext

func (*FunctionBodyContext) IsFunctionBodyContext

func (*FunctionBodyContext) IsFunctionBodyContext()

func (*FunctionBodyContext) OpenBrace

func (s *FunctionBodyContext) OpenBrace() antlr.TerminalNode

func (*FunctionBodyContext) SourceElements

func (s *FunctionBodyContext) SourceElements() ISourceElementsContext

func (*FunctionBodyContext) ToStringTree

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

type FunctionDeclarationContext

type FunctionDeclarationContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionDeclarationContext

func NewEmptyFunctionDeclarationContext() *FunctionDeclarationContext

func NewFunctionDeclarationContext

func NewFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionDeclarationContext

func (*FunctionDeclarationContext) Accept

func (s *FunctionDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionDeclarationContext) Async

func (s *FunctionDeclarationContext) Async() antlr.TerminalNode

func (*FunctionDeclarationContext) CloseParen

func (s *FunctionDeclarationContext) CloseParen() antlr.TerminalNode

func (*FunctionDeclarationContext) FormalParameterList

func (s *FunctionDeclarationContext) FormalParameterList() IFormalParameterListContext

func (*FunctionDeclarationContext) FunctionBody

func (s *FunctionDeclarationContext) FunctionBody() IFunctionBodyContext

func (*FunctionDeclarationContext) Function_

func (s *FunctionDeclarationContext) Function_() antlr.TerminalNode

func (*FunctionDeclarationContext) GetParser

func (s *FunctionDeclarationContext) GetParser() antlr.Parser

func (*FunctionDeclarationContext) GetRuleContext

func (s *FunctionDeclarationContext) GetRuleContext() antlr.RuleContext

func (*FunctionDeclarationContext) Identifier

func (s *FunctionDeclarationContext) Identifier() IIdentifierContext

func (*FunctionDeclarationContext) IsFunctionDeclarationContext

func (*FunctionDeclarationContext) IsFunctionDeclarationContext()

func (*FunctionDeclarationContext) Multiply

func (s *FunctionDeclarationContext) Multiply() antlr.TerminalNode

func (*FunctionDeclarationContext) OpenParen

func (s *FunctionDeclarationContext) OpenParen() antlr.TerminalNode

func (*FunctionDeclarationContext) ToStringTree

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

type FunctionExpressionContext

type FunctionExpressionContext struct {
	SingleExpressionContext
}

func NewFunctionExpressionContext

func NewFunctionExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionExpressionContext

func (*FunctionExpressionContext) Accept

func (s *FunctionExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionExpressionContext) AnonymousFunction

func (s *FunctionExpressionContext) AnonymousFunction() IAnonymousFunctionContext

func (*FunctionExpressionContext) GetRuleContext

func (s *FunctionExpressionContext) GetRuleContext() antlr.RuleContext

type FunctionPropertyContext

type FunctionPropertyContext struct {
	PropertyAssignmentContext
}

func NewFunctionPropertyContext

func NewFunctionPropertyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionPropertyContext

func (*FunctionPropertyContext) Accept

func (s *FunctionPropertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionPropertyContext) Async

func (s *FunctionPropertyContext) Async() antlr.TerminalNode

func (*FunctionPropertyContext) CloseParen

func (s *FunctionPropertyContext) CloseParen() antlr.TerminalNode

func (*FunctionPropertyContext) FormalParameterList

func (s *FunctionPropertyContext) FormalParameterList() IFormalParameterListContext

func (*FunctionPropertyContext) FunctionBody

func (s *FunctionPropertyContext) FunctionBody() IFunctionBodyContext

func (*FunctionPropertyContext) GetRuleContext

func (s *FunctionPropertyContext) GetRuleContext() antlr.RuleContext

func (*FunctionPropertyContext) Multiply

func (s *FunctionPropertyContext) Multiply() antlr.TerminalNode

func (*FunctionPropertyContext) OpenParen

func (s *FunctionPropertyContext) OpenParen() antlr.TerminalNode

func (*FunctionPropertyContext) PropertyName

func (s *FunctionPropertyContext) PropertyName() IPropertyNameContext

type GetterContext

type GetterContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGetterContext

func NewEmptyGetterContext() *GetterContext

func NewGetterContext

func NewGetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GetterContext

func (*GetterContext) Accept

func (s *GetterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*GetterContext) ClassElementName

func (s *GetterContext) ClassElementName() IClassElementNameContext

func (*GetterContext) GetParser

func (s *GetterContext) GetParser() antlr.Parser

func (*GetterContext) GetRuleContext

func (s *GetterContext) GetRuleContext() antlr.RuleContext

func (*GetterContext) Identifier

func (s *GetterContext) Identifier() IIdentifierContext

func (*GetterContext) IsGetterContext

func (*GetterContext) IsGetterContext()

func (*GetterContext) ToStringTree

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

type IAliasNameContext

type IAliasNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllIdentifierName() []IIdentifierNameContext
	IdentifierName(i int) IIdentifierNameContext
	As() antlr.TerminalNode

	// IsAliasNameContext differentiates from other interfaces.
	IsAliasNameContext()
}

IAliasNameContext is an interface to support dynamic dispatch.

type IAnonymousFunctionContext

type IAnonymousFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsAnonymousFunctionContext differentiates from other interfaces.
	IsAnonymousFunctionContext()
}

IAnonymousFunctionContext is an interface to support dynamic dispatch.

type IArgumentContext

type IArgumentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SingleExpression() ISingleExpressionContext
	Identifier() IIdentifierContext
	Ellipsis() antlr.TerminalNode

	// IsArgumentContext differentiates from other interfaces.
	IsArgumentContext()
}

IArgumentContext is an interface to support dynamic dispatch.

type IArgumentsContext

type IArgumentsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenParen() antlr.TerminalNode
	CloseParen() antlr.TerminalNode
	AllArgument() []IArgumentContext
	Argument(i int) IArgumentContext
	AllComma() []antlr.TerminalNode
	Comma(i int) antlr.TerminalNode

	// IsArgumentsContext differentiates from other interfaces.
	IsArgumentsContext()
}

IArgumentsContext is an interface to support dynamic dispatch.

type IArrayElementContext

type IArrayElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SingleExpression() ISingleExpressionContext
	Ellipsis() antlr.TerminalNode

	// IsArrayElementContext differentiates from other interfaces.
	IsArrayElementContext()
}

IArrayElementContext is an interface to support dynamic dispatch.

type IArrayLiteralContext

type IArrayLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenBracket() antlr.TerminalNode
	ElementList() IElementListContext
	CloseBracket() antlr.TerminalNode

	// IsArrayLiteralContext differentiates from other interfaces.
	IsArrayLiteralContext()
}

IArrayLiteralContext is an interface to support dynamic dispatch.

type IArrowFunctionBodyContext

type IArrowFunctionBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FunctionBody() IFunctionBodyContext
	SingleExpression() ISingleExpressionContext

	// IsArrowFunctionBodyContext differentiates from other interfaces.
	IsArrowFunctionBodyContext()
}

IArrowFunctionBodyContext is an interface to support dynamic dispatch.

type IArrowFunctionParametersContext

type IArrowFunctionParametersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	OpenParen() antlr.TerminalNode
	CloseParen() antlr.TerminalNode
	FormalParameterList() IFormalParameterListContext

	// IsArrowFunctionParametersContext differentiates from other interfaces.
	IsArrowFunctionParametersContext()
}

IArrowFunctionParametersContext is an interface to support dynamic dispatch.

type IAssignableContext

type IAssignableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	ArrayLiteral() IArrayLiteralContext
	ObjectLiteral() IObjectLiteralContext

	// IsAssignableContext differentiates from other interfaces.
	IsAssignableContext()
}

IAssignableContext is an interface to support dynamic dispatch.

type IAssignmentOperatorContext

type IAssignmentOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	MultiplyAssign() antlr.TerminalNode
	DivideAssign() antlr.TerminalNode
	ModulusAssign() antlr.TerminalNode
	PlusAssign() antlr.TerminalNode
	MinusAssign() antlr.TerminalNode
	LeftShiftArithmeticAssign() antlr.TerminalNode
	RightShiftArithmeticAssign() antlr.TerminalNode
	RightShiftLogicalAssign() antlr.TerminalNode
	BitAndAssign() antlr.TerminalNode
	BitXorAssign() antlr.TerminalNode
	BitOrAssign() antlr.TerminalNode
	PowerAssign() antlr.TerminalNode

	// IsAssignmentOperatorContext differentiates from other interfaces.
	IsAssignmentOperatorContext()
}

IAssignmentOperatorContext is an interface to support dynamic dispatch.

type IBigintLiteralContext

type IBigintLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BigDecimalIntegerLiteral() antlr.TerminalNode
	BigHexIntegerLiteral() antlr.TerminalNode
	BigOctalIntegerLiteral() antlr.TerminalNode
	BigBinaryIntegerLiteral() antlr.TerminalNode

	// IsBigintLiteralContext differentiates from other interfaces.
	IsBigintLiteralContext()
}

IBigintLiteralContext is an interface to support dynamic dispatch.

type IBlockContext

type IBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenBrace() antlr.TerminalNode
	CloseBrace() antlr.TerminalNode
	StatementList() IStatementListContext

	// IsBlockContext differentiates from other interfaces.
	IsBlockContext()
}

IBlockContext is an interface to support dynamic dispatch.

type IBreakStatementContext

type IBreakStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Break() antlr.TerminalNode
	Eos() IEosContext
	Identifier() IIdentifierContext

	// IsBreakStatementContext differentiates from other interfaces.
	IsBreakStatementContext()
}

IBreakStatementContext is an interface to support dynamic dispatch.

type ICaseBlockContext

type ICaseBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenBrace() antlr.TerminalNode
	CloseBrace() antlr.TerminalNode
	AllCaseClauses() []ICaseClausesContext
	CaseClauses(i int) ICaseClausesContext
	DefaultClause() IDefaultClauseContext

	// IsCaseBlockContext differentiates from other interfaces.
	IsCaseBlockContext()
}

ICaseBlockContext is an interface to support dynamic dispatch.

type ICaseClauseContext

type ICaseClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Case() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext
	Colon() antlr.TerminalNode
	StatementList() IStatementListContext

	// IsCaseClauseContext differentiates from other interfaces.
	IsCaseClauseContext()
}

ICaseClauseContext is an interface to support dynamic dispatch.

type ICaseClausesContext

type ICaseClausesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCaseClause() []ICaseClauseContext
	CaseClause(i int) ICaseClauseContext

	// IsCaseClausesContext differentiates from other interfaces.
	IsCaseClausesContext()
}

ICaseClausesContext is an interface to support dynamic dispatch.

type ICatchProductionContext

type ICatchProductionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Catch() antlr.TerminalNode
	Block() IBlockContext
	OpenParen() antlr.TerminalNode
	CloseParen() antlr.TerminalNode
	Assignable() IAssignableContext

	// IsCatchProductionContext differentiates from other interfaces.
	IsCatchProductionContext()
}

ICatchProductionContext is an interface to support dynamic dispatch.

type IClassDeclarationContext

type IClassDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Class() antlr.TerminalNode
	Identifier() IIdentifierContext
	ClassTail() IClassTailContext

	// IsClassDeclarationContext differentiates from other interfaces.
	IsClassDeclarationContext()
}

IClassDeclarationContext is an interface to support dynamic dispatch.

type IClassElementContext

type IClassElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	MethodDefinition() IMethodDefinitionContext
	Static() antlr.TerminalNode
	Identifier() IIdentifierContext
	FieldDefinition() IFieldDefinitionContext
	Block() IBlockContext
	EmptyStatement_() IEmptyStatement_Context

	// IsClassElementContext differentiates from other interfaces.
	IsClassElementContext()
}

IClassElementContext is an interface to support dynamic dispatch.

type IClassElementNameContext

type IClassElementNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PropertyName() IPropertyNameContext
	PrivateIdentifier() IPrivateIdentifierContext

	// IsClassElementNameContext differentiates from other interfaces.
	IsClassElementNameContext()
}

IClassElementNameContext is an interface to support dynamic dispatch.

type IClassTailContext

type IClassTailContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenBrace() antlr.TerminalNode
	CloseBrace() antlr.TerminalNode
	Extends() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext
	AllClassElement() []IClassElementContext
	ClassElement(i int) IClassElementContext

	// IsClassTailContext differentiates from other interfaces.
	IsClassTailContext()
}

IClassTailContext is an interface to support dynamic dispatch.

type IContinueStatementContext

type IContinueStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Continue() antlr.TerminalNode
	Eos() IEosContext
	Identifier() IIdentifierContext

	// IsContinueStatementContext differentiates from other interfaces.
	IsContinueStatementContext()
}

IContinueStatementContext is an interface to support dynamic dispatch.

type IDebuggerStatementContext

type IDebuggerStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Debugger() antlr.TerminalNode
	Eos() IEosContext

	// IsDebuggerStatementContext differentiates from other interfaces.
	IsDebuggerStatementContext()
}

IDebuggerStatementContext is an interface to support dynamic dispatch.

type IDeclarationContext

type IDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VariableStatement() IVariableStatementContext
	ClassDeclaration() IClassDeclarationContext
	FunctionDeclaration() IFunctionDeclarationContext

	// IsDeclarationContext differentiates from other interfaces.
	IsDeclarationContext()
}

IDeclarationContext is an interface to support dynamic dispatch.

type IDefaultClauseContext

type IDefaultClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Default() antlr.TerminalNode
	Colon() antlr.TerminalNode
	StatementList() IStatementListContext

	// IsDefaultClauseContext differentiates from other interfaces.
	IsDefaultClauseContext()
}

IDefaultClauseContext is an interface to support dynamic dispatch.

type IElementListContext

type IElementListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllComma() []antlr.TerminalNode
	Comma(i int) antlr.TerminalNode
	AllArrayElement() []IArrayElementContext
	ArrayElement(i int) IArrayElementContext

	// IsElementListContext differentiates from other interfaces.
	IsElementListContext()
}

IElementListContext is an interface to support dynamic dispatch.

type IElseBlockContext

type IElseBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Else() antlr.TerminalNode
	Statement() IStatementContext

	// IsElseBlockContext differentiates from other interfaces.
	IsElseBlockContext()
}

IElseBlockContext is an interface to support dynamic dispatch.

type IEmptyStatement_Context

type IEmptyStatement_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SemiColon() antlr.TerminalNode

	// IsEmptyStatement_Context differentiates from other interfaces.
	IsEmptyStatement_Context()
}

IEmptyStatement_Context is an interface to support dynamic dispatch.

type IEosContext

type IEosContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SemiColon() antlr.TerminalNode
	EOF() antlr.TerminalNode

	// IsEosContext differentiates from other interfaces.
	IsEosContext()
}

IEosContext is an interface to support dynamic dispatch.

type IExportAliasNameContext

type IExportAliasNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllModuleExportName() []IModuleExportNameContext
	ModuleExportName(i int) IModuleExportNameContext
	As() antlr.TerminalNode

	// IsExportAliasNameContext differentiates from other interfaces.
	IsExportAliasNameContext()
}

IExportAliasNameContext is an interface to support dynamic dispatch.

type IExportFromBlockContext

type IExportFromBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ImportNamespace() IImportNamespaceContext
	ImportFrom() IImportFromContext
	Eos() IEosContext
	ExportModuleItems() IExportModuleItemsContext

	// IsExportFromBlockContext differentiates from other interfaces.
	IsExportFromBlockContext()
}

IExportFromBlockContext is an interface to support dynamic dispatch.

type IExportModuleItemsContext

type IExportModuleItemsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenBrace() antlr.TerminalNode
	CloseBrace() antlr.TerminalNode
	AllExportAliasName() []IExportAliasNameContext
	ExportAliasName(i int) IExportAliasNameContext
	AllComma() []antlr.TerminalNode
	Comma(i int) antlr.TerminalNode

	// IsExportModuleItemsContext differentiates from other interfaces.
	IsExportModuleItemsContext()
}

IExportModuleItemsContext is an interface to support dynamic dispatch.

type IExportStatementContext

type IExportStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsExportStatementContext differentiates from other interfaces.
	IsExportStatementContext()
}

IExportStatementContext is an interface to support dynamic dispatch.

type IExpressionSequenceContext

type IExpressionSequenceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSingleExpression() []ISingleExpressionContext
	SingleExpression(i int) ISingleExpressionContext
	AllComma() []antlr.TerminalNode
	Comma(i int) antlr.TerminalNode

	// IsExpressionSequenceContext differentiates from other interfaces.
	IsExpressionSequenceContext()
}

IExpressionSequenceContext is an interface to support dynamic dispatch.

type IExpressionStatementContext

type IExpressionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ExpressionSequence() IExpressionSequenceContext
	Eos() IEosContext

	// IsExpressionStatementContext differentiates from other interfaces.
	IsExpressionStatementContext()
}

IExpressionStatementContext is an interface to support dynamic dispatch.

type IFieldDefinitionContext

type IFieldDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ClassElementName() IClassElementNameContext
	Initializer() IInitializerContext

	// IsFieldDefinitionContext differentiates from other interfaces.
	IsFieldDefinitionContext()
}

IFieldDefinitionContext is an interface to support dynamic dispatch.

type IFinallyProductionContext

type IFinallyProductionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Finally() antlr.TerminalNode
	Block() IBlockContext

	// IsFinallyProductionContext differentiates from other interfaces.
	IsFinallyProductionContext()
}

IFinallyProductionContext is an interface to support dynamic dispatch.

type IForFirstContext

type IForFirstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SingleExpression() ISingleExpressionContext
	VariableDeclarationList() IVariableDeclarationListContext

	// IsForFirstContext differentiates from other interfaces.
	IsForFirstContext()
}

IForFirstContext is an interface to support dynamic dispatch.

type IForSecondContext

type IForSecondContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SingleExpression() ISingleExpressionContext

	// IsForSecondContext differentiates from other interfaces.
	IsForSecondContext()
}

IForSecondContext is an interface to support dynamic dispatch.

type IForThirdContext

type IForThirdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SingleExpression() ISingleExpressionContext

	// IsForThirdContext differentiates from other interfaces.
	IsForThirdContext()
}

IForThirdContext is an interface to support dynamic dispatch.

type IFormalParameterArgContext

type IFormalParameterArgContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Assignable() IAssignableContext
	Assign() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext

	// IsFormalParameterArgContext differentiates from other interfaces.
	IsFormalParameterArgContext()
}

IFormalParameterArgContext is an interface to support dynamic dispatch.

type IFormalParameterListContext

type IFormalParameterListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFormalParameterArg() []IFormalParameterArgContext
	FormalParameterArg(i int) IFormalParameterArgContext
	AllComma() []antlr.TerminalNode
	Comma(i int) antlr.TerminalNode
	LastFormalParameterArg() ILastFormalParameterArgContext

	// IsFormalParameterListContext differentiates from other interfaces.
	IsFormalParameterListContext()
}

IFormalParameterListContext is an interface to support dynamic dispatch.

type IFunctionBodyContext

type IFunctionBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenBrace() antlr.TerminalNode
	CloseBrace() antlr.TerminalNode
	SourceElements() ISourceElementsContext

	// IsFunctionBodyContext differentiates from other interfaces.
	IsFunctionBodyContext()
}

IFunctionBodyContext is an interface to support dynamic dispatch.

type IFunctionDeclarationContext

type IFunctionDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Function_() antlr.TerminalNode
	Identifier() IIdentifierContext
	OpenParen() antlr.TerminalNode
	CloseParen() antlr.TerminalNode
	FunctionBody() IFunctionBodyContext
	Async() antlr.TerminalNode
	Multiply() antlr.TerminalNode
	FormalParameterList() IFormalParameterListContext

	// IsFunctionDeclarationContext differentiates from other interfaces.
	IsFunctionDeclarationContext()
}

IFunctionDeclarationContext is an interface to support dynamic dispatch.

type IGetterContext

type IGetterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	ClassElementName() IClassElementNameContext

	// IsGetterContext differentiates from other interfaces.
	IsGetterContext()
}

IGetterContext is an interface to support dynamic dispatch.

type IIdentifierContext

type IIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() antlr.TerminalNode
	NonStrictLet() antlr.TerminalNode
	Async() antlr.TerminalNode
	As() antlr.TerminalNode
	From() antlr.TerminalNode

	// IsIdentifierContext differentiates from other interfaces.
	IsIdentifierContext()
}

IIdentifierContext is an interface to support dynamic dispatch.

type IIdentifierNameContext

type IIdentifierNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	ReservedWord() IReservedWordContext

	// IsIdentifierNameContext differentiates from other interfaces.
	IsIdentifierNameContext()
}

IIdentifierNameContext is an interface to support dynamic dispatch.

type IIfStatementContext

type IIfStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllIf() []antlr.TerminalNode
	If(i int) antlr.TerminalNode
	AllOpenParen() []antlr.TerminalNode
	OpenParen(i int) antlr.TerminalNode
	AllSingleExpression() []ISingleExpressionContext
	SingleExpression(i int) ISingleExpressionContext
	AllCloseParen() []antlr.TerminalNode
	CloseParen(i int) antlr.TerminalNode
	AllStatement() []IStatementContext
	Statement(i int) IStatementContext
	AllElse() []antlr.TerminalNode
	Else(i int) antlr.TerminalNode
	ElseBlock() IElseBlockContext

	// IsIfStatementContext differentiates from other interfaces.
	IsIfStatementContext()
}

IIfStatementContext is an interface to support dynamic dispatch.

type IImportAliasNameContext

type IImportAliasNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ModuleExportName() IModuleExportNameContext
	As() antlr.TerminalNode
	ImportedBinding() IImportedBindingContext

	// IsImportAliasNameContext differentiates from other interfaces.
	IsImportAliasNameContext()
}

IImportAliasNameContext is an interface to support dynamic dispatch.

type IImportDefaultContext

type IImportDefaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AliasName() IAliasNameContext
	Comma() antlr.TerminalNode

	// IsImportDefaultContext differentiates from other interfaces.
	IsImportDefaultContext()
}

IImportDefaultContext is an interface to support dynamic dispatch.

type IImportFromBlockContext

type IImportFromBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ImportFrom() IImportFromContext
	Eos() IEosContext
	ImportNamespace() IImportNamespaceContext
	ImportModuleItems() IImportModuleItemsContext
	ImportDefault() IImportDefaultContext
	StringLiteral() antlr.TerminalNode

	// IsImportFromBlockContext differentiates from other interfaces.
	IsImportFromBlockContext()
}

IImportFromBlockContext is an interface to support dynamic dispatch.

type IImportFromContext

type IImportFromContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	From() antlr.TerminalNode
	StringLiteral() antlr.TerminalNode

	// IsImportFromContext differentiates from other interfaces.
	IsImportFromContext()
}

IImportFromContext is an interface to support dynamic dispatch.

type IImportModuleItemsContext

type IImportModuleItemsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenBrace() antlr.TerminalNode
	CloseBrace() antlr.TerminalNode
	AllImportAliasName() []IImportAliasNameContext
	ImportAliasName(i int) IImportAliasNameContext
	AllComma() []antlr.TerminalNode
	Comma(i int) antlr.TerminalNode

	// IsImportModuleItemsContext differentiates from other interfaces.
	IsImportModuleItemsContext()
}

IImportModuleItemsContext is an interface to support dynamic dispatch.

type IImportNamespaceContext

type IImportNamespaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Multiply() antlr.TerminalNode
	AllIdentifierName() []IIdentifierNameContext
	IdentifierName(i int) IIdentifierNameContext
	As() antlr.TerminalNode

	// IsImportNamespaceContext differentiates from other interfaces.
	IsImportNamespaceContext()
}

IImportNamespaceContext is an interface to support dynamic dispatch.

type IImportStatementContext

type IImportStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Import() antlr.TerminalNode
	ImportFromBlock() IImportFromBlockContext

	// IsImportStatementContext differentiates from other interfaces.
	IsImportStatementContext()
}

IImportStatementContext is an interface to support dynamic dispatch.

type IImportedBindingContext

type IImportedBindingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() antlr.TerminalNode
	Yield() antlr.TerminalNode
	Await() antlr.TerminalNode

	// IsImportedBindingContext differentiates from other interfaces.
	IsImportedBindingContext()
}

IImportedBindingContext is an interface to support dynamic dispatch.

type IInitializerContext

type IInitializerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Assign() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext

	// IsInitializerContext differentiates from other interfaces.
	IsInitializerContext()
}

IInitializerContext is an interface to support dynamic dispatch.

type IIterationStatementContext

type IIterationStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsIterationStatementContext differentiates from other interfaces.
	IsIterationStatementContext()
}

IIterationStatementContext is an interface to support dynamic dispatch.

type IKeywordContext

type IKeywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Break() antlr.TerminalNode
	Do() antlr.TerminalNode
	Instanceof() antlr.TerminalNode
	Typeof() antlr.TerminalNode
	Case() antlr.TerminalNode
	Else() antlr.TerminalNode
	New() antlr.TerminalNode
	Var() antlr.TerminalNode
	Catch() antlr.TerminalNode
	Finally() antlr.TerminalNode
	Return() antlr.TerminalNode
	Void() antlr.TerminalNode
	Continue() antlr.TerminalNode
	For() antlr.TerminalNode
	Switch() antlr.TerminalNode
	While() antlr.TerminalNode
	Debugger() antlr.TerminalNode
	Function_() antlr.TerminalNode
	This() antlr.TerminalNode
	With() antlr.TerminalNode
	Default() antlr.TerminalNode
	If() antlr.TerminalNode
	Throw() antlr.TerminalNode
	Delete() antlr.TerminalNode
	In() antlr.TerminalNode
	Try() antlr.TerminalNode
	Class() antlr.TerminalNode
	Enum() antlr.TerminalNode
	Extends() antlr.TerminalNode
	Super() antlr.TerminalNode
	Const() antlr.TerminalNode
	Export() antlr.TerminalNode
	Import() antlr.TerminalNode
	Implements() antlr.TerminalNode
	Let_() ILet_Context
	Private() antlr.TerminalNode
	Public() antlr.TerminalNode
	Interface() antlr.TerminalNode
	Package() antlr.TerminalNode
	Protected() antlr.TerminalNode
	Static() antlr.TerminalNode
	Yield() antlr.TerminalNode
	Async() antlr.TerminalNode
	Await() antlr.TerminalNode
	From() antlr.TerminalNode
	As() antlr.TerminalNode

	// IsKeywordContext differentiates from other interfaces.
	IsKeywordContext()
}

IKeywordContext is an interface to support dynamic dispatch.

type ILabelledStatementContext

type ILabelledStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	Colon() antlr.TerminalNode
	Statement() IStatementContext

	// IsLabelledStatementContext differentiates from other interfaces.
	IsLabelledStatementContext()
}

ILabelledStatementContext is an interface to support dynamic dispatch.

type ILastFormalParameterArgContext

type ILastFormalParameterArgContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Ellipsis() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext

	// IsLastFormalParameterArgContext differentiates from other interfaces.
	IsLastFormalParameterArgContext()
}

ILastFormalParameterArgContext is an interface to support dynamic dispatch.

type ILet_Context

type ILet_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NonStrictLet() antlr.TerminalNode
	StrictLet() antlr.TerminalNode

	// IsLet_Context differentiates from other interfaces.
	IsLet_Context()
}

ILet_Context is an interface to support dynamic dispatch.

type ILiteralContext

type ILiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NullLiteral() antlr.TerminalNode
	BooleanLiteral() antlr.TerminalNode
	StringLiteral() antlr.TerminalNode
	TemplateStringLiteral() ITemplateStringLiteralContext
	RegularExpressionLiteral() antlr.TerminalNode
	NumericLiteral() INumericLiteralContext
	BigintLiteral() IBigintLiteralContext

	// IsLiteralContext differentiates from other interfaces.
	IsLiteralContext()
}

ILiteralContext is an interface to support dynamic dispatch.

type IMethodDefinitionContext

type IMethodDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ClassElementName() IClassElementNameContext
	OpenParen() antlr.TerminalNode
	CloseParen() antlr.TerminalNode
	FunctionBody() IFunctionBodyContext
	Async() antlr.TerminalNode
	Multiply() antlr.TerminalNode
	FormalParameterList() IFormalParameterListContext
	Getter() IGetterContext
	Setter() ISetterContext

	// IsMethodDefinitionContext differentiates from other interfaces.
	IsMethodDefinitionContext()
}

IMethodDefinitionContext is an interface to support dynamic dispatch.

type IModuleExportNameContext

type IModuleExportNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IdentifierName() IIdentifierNameContext
	StringLiteral() antlr.TerminalNode

	// IsModuleExportNameContext differentiates from other interfaces.
	IsModuleExportNameContext()
}

IModuleExportNameContext is an interface to support dynamic dispatch.

type INumericLiteralContext

type INumericLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DecimalLiteral() antlr.TerminalNode
	HexIntegerLiteral() antlr.TerminalNode
	OctalIntegerLiteral() antlr.TerminalNode
	OctalIntegerLiteral2() antlr.TerminalNode
	BinaryIntegerLiteral() antlr.TerminalNode

	// IsNumericLiteralContext differentiates from other interfaces.
	IsNumericLiteralContext()
}

INumericLiteralContext is an interface to support dynamic dispatch.

type IObjectLiteralContext

type IObjectLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OpenBrace() antlr.TerminalNode
	CloseBrace() antlr.TerminalNode
	AllPropertyAssignment() []IPropertyAssignmentContext
	PropertyAssignment(i int) IPropertyAssignmentContext
	AllComma() []antlr.TerminalNode
	Comma(i int) antlr.TerminalNode

	// IsObjectLiteralContext differentiates from other interfaces.
	IsObjectLiteralContext()
}

IObjectLiteralContext is an interface to support dynamic dispatch.

type IPrivateIdentifierContext

type IPrivateIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Hashtag() antlr.TerminalNode
	IdentifierName() IIdentifierNameContext

	// IsPrivateIdentifierContext differentiates from other interfaces.
	IsPrivateIdentifierContext()
}

IPrivateIdentifierContext is an interface to support dynamic dispatch.

type IProgramContext

type IProgramContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EOF() antlr.TerminalNode
	HashBangLine() antlr.TerminalNode
	SourceElements() ISourceElementsContext

	// IsProgramContext differentiates from other interfaces.
	IsProgramContext()
}

IProgramContext is an interface to support dynamic dispatch.

type IPropertyAssignmentContext

type IPropertyAssignmentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsPropertyAssignmentContext differentiates from other interfaces.
	IsPropertyAssignmentContext()
}

IPropertyAssignmentContext is an interface to support dynamic dispatch.

type IPropertyNameContext

type IPropertyNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IdentifierName() IIdentifierNameContext
	StringLiteral() antlr.TerminalNode
	NumericLiteral() INumericLiteralContext
	OpenBracket() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext
	CloseBracket() antlr.TerminalNode

	// IsPropertyNameContext differentiates from other interfaces.
	IsPropertyNameContext()
}

IPropertyNameContext is an interface to support dynamic dispatch.

type IReservedWordContext

type IReservedWordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Keyword() IKeywordContext
	NullLiteral() antlr.TerminalNode
	BooleanLiteral() antlr.TerminalNode

	// IsReservedWordContext differentiates from other interfaces.
	IsReservedWordContext()
}

IReservedWordContext is an interface to support dynamic dispatch.

type IReturnStatementContext

type IReturnStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Return() antlr.TerminalNode
	Eos() IEosContext
	ExpressionSequence() IExpressionSequenceContext

	// IsReturnStatementContext differentiates from other interfaces.
	IsReturnStatementContext()
}

IReturnStatementContext is an interface to support dynamic dispatch.

type ISetterContext

type ISetterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	ClassElementName() IClassElementNameContext

	// IsSetterContext differentiates from other interfaces.
	IsSetterContext()
}

ISetterContext is an interface to support dynamic dispatch.

type ISingleExpressionContext

type ISingleExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsSingleExpressionContext differentiates from other interfaces.
	IsSingleExpressionContext()
}

ISingleExpressionContext is an interface to support dynamic dispatch.

type ISourceElementContext

type ISourceElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Statement() IStatementContext

	// IsSourceElementContext differentiates from other interfaces.
	IsSourceElementContext()
}

ISourceElementContext is an interface to support dynamic dispatch.

type ISourceElementsContext

type ISourceElementsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSourceElement() []ISourceElementContext
	SourceElement(i int) ISourceElementContext

	// IsSourceElementsContext differentiates from other interfaces.
	IsSourceElementsContext()
}

ISourceElementsContext is an interface to support dynamic dispatch.

type IStatementContext

type IStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Block() IBlockContext
	VariableStatement() IVariableStatementContext
	ImportStatement() IImportStatementContext
	ExportStatement() IExportStatementContext
	EmptyStatement_() IEmptyStatement_Context
	ClassDeclaration() IClassDeclarationContext
	FunctionDeclaration() IFunctionDeclarationContext
	ExpressionStatement() IExpressionStatementContext
	IfStatement() IIfStatementContext
	IterationStatement() IIterationStatementContext
	ContinueStatement() IContinueStatementContext
	BreakStatement() IBreakStatementContext
	ReturnStatement() IReturnStatementContext
	YieldStatement() IYieldStatementContext
	WithStatement() IWithStatementContext
	LabelledStatement() ILabelledStatementContext
	SwitchStatement() ISwitchStatementContext
	ThrowStatement() IThrowStatementContext
	TryStatement() ITryStatementContext
	DebuggerStatement() IDebuggerStatementContext

	// IsStatementContext differentiates from other interfaces.
	IsStatementContext()
}

IStatementContext is an interface to support dynamic dispatch.

type IStatementListContext

type IStatementListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllStatement() []IStatementContext
	Statement(i int) IStatementContext

	// IsStatementListContext differentiates from other interfaces.
	IsStatementListContext()
}

IStatementListContext is an interface to support dynamic dispatch.

type ISwitchStatementContext

type ISwitchStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Switch() antlr.TerminalNode
	OpenParen() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext
	CloseParen() antlr.TerminalNode
	CaseBlock() ICaseBlockContext

	// IsSwitchStatementContext differentiates from other interfaces.
	IsSwitchStatementContext()
}

ISwitchStatementContext is an interface to support dynamic dispatch.

type ITemplateStringAtomContext

type ITemplateStringAtomContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TemplateStringAtom() antlr.TerminalNode
	TemplateStringStartExpression() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext
	TemplateCloseBrace() antlr.TerminalNode

	// IsTemplateStringAtomContext differentiates from other interfaces.
	IsTemplateStringAtomContext()
}

ITemplateStringAtomContext is an interface to support dynamic dispatch.

type ITemplateStringLiteralContext

type ITemplateStringLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllBackTick() []antlr.TerminalNode
	BackTick(i int) antlr.TerminalNode
	AllTemplateStringAtom() []ITemplateStringAtomContext
	TemplateStringAtom(i int) ITemplateStringAtomContext

	// IsTemplateStringLiteralContext differentiates from other interfaces.
	IsTemplateStringLiteralContext()
}

ITemplateStringLiteralContext is an interface to support dynamic dispatch.

type IThrowStatementContext

type IThrowStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Throw() antlr.TerminalNode
	ExpressionSequence() IExpressionSequenceContext
	Eos() IEosContext

	// IsThrowStatementContext differentiates from other interfaces.
	IsThrowStatementContext()
}

IThrowStatementContext is an interface to support dynamic dispatch.

type ITryStatementContext

type ITryStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Try() antlr.TerminalNode
	Block() IBlockContext
	CatchProduction() ICatchProductionContext
	FinallyProduction() IFinallyProductionContext

	// IsTryStatementContext differentiates from other interfaces.
	IsTryStatementContext()
}

ITryStatementContext is an interface to support dynamic dispatch.

type IVarModifierContext

type IVarModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Var() antlr.TerminalNode
	Let_() ILet_Context
	Const() antlr.TerminalNode

	// IsVarModifierContext differentiates from other interfaces.
	IsVarModifierContext()
}

IVarModifierContext is an interface to support dynamic dispatch.

type IVariableDeclarationContext

type IVariableDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Assignable() IAssignableContext
	Assign() antlr.TerminalNode
	SingleExpression() ISingleExpressionContext

	// IsVariableDeclarationContext differentiates from other interfaces.
	IsVariableDeclarationContext()
}

IVariableDeclarationContext is an interface to support dynamic dispatch.

type IVariableDeclarationListContext

type IVariableDeclarationListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VarModifier() IVarModifierContext
	AllVariableDeclaration() []IVariableDeclarationContext
	VariableDeclaration(i int) IVariableDeclarationContext
	AllComma() []antlr.TerminalNode
	Comma(i int) antlr.TerminalNode

	// IsVariableDeclarationListContext differentiates from other interfaces.
	IsVariableDeclarationListContext()
}

IVariableDeclarationListContext is an interface to support dynamic dispatch.

type IVariableStatementContext

type IVariableStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VariableDeclarationList() IVariableDeclarationListContext
	Eos() IEosContext

	// IsVariableStatementContext differentiates from other interfaces.
	IsVariableStatementContext()
}

IVariableStatementContext is an interface to support dynamic dispatch.

type IWithStatementContext

type IWithStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	With() antlr.TerminalNode
	OpenParen() antlr.TerminalNode
	ExpressionSequence() IExpressionSequenceContext
	CloseParen() antlr.TerminalNode
	Statement() IStatementContext

	// IsWithStatementContext differentiates from other interfaces.
	IsWithStatementContext()
}

IWithStatementContext is an interface to support dynamic dispatch.

type IYieldStatementContext

type IYieldStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Yield() antlr.TerminalNode
	Eos() IEosContext
	ExpressionSequence() IExpressionSequenceContext

	// IsYieldStatementContext differentiates from other interfaces.
	IsYieldStatementContext()
}

IYieldStatementContext is an interface to support dynamic dispatch.

type IdentifierContext

type IdentifierContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIdentifierContext

func NewEmptyIdentifierContext() *IdentifierContext

func NewIdentifierContext

func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext

func (*IdentifierContext) Accept

func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IdentifierContext) As

func (s *IdentifierContext) As() antlr.TerminalNode

func (*IdentifierContext) Async

func (s *IdentifierContext) Async() antlr.TerminalNode

func (*IdentifierContext) From

func (s *IdentifierContext) From() antlr.TerminalNode

func (*IdentifierContext) GetParser

func (s *IdentifierContext) GetParser() antlr.Parser

func (*IdentifierContext) GetRuleContext

func (s *IdentifierContext) GetRuleContext() antlr.RuleContext

func (*IdentifierContext) Identifier

func (s *IdentifierContext) Identifier() antlr.TerminalNode

func (*IdentifierContext) IsIdentifierContext

func (*IdentifierContext) IsIdentifierContext()

func (*IdentifierContext) NonStrictLet

func (s *IdentifierContext) NonStrictLet() antlr.TerminalNode

func (*IdentifierContext) ToStringTree

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

type IdentifierExpressionContext

type IdentifierExpressionContext struct {
	SingleExpressionContext
}

func NewIdentifierExpressionContext

func NewIdentifierExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierExpressionContext

func (*IdentifierExpressionContext) Accept

func (s *IdentifierExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IdentifierExpressionContext) GetRuleContext

func (s *IdentifierExpressionContext) GetRuleContext() antlr.RuleContext

func (*IdentifierExpressionContext) Identifier

func (s *IdentifierExpressionContext) Identifier() IIdentifierContext

type IdentifierNameContext

type IdentifierNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIdentifierNameContext

func NewEmptyIdentifierNameContext() *IdentifierNameContext

func NewIdentifierNameContext

func NewIdentifierNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierNameContext

func (*IdentifierNameContext) Accept

func (s *IdentifierNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IdentifierNameContext) GetParser

func (s *IdentifierNameContext) GetParser() antlr.Parser

func (*IdentifierNameContext) GetRuleContext

func (s *IdentifierNameContext) GetRuleContext() antlr.RuleContext

func (*IdentifierNameContext) Identifier

func (s *IdentifierNameContext) Identifier() IIdentifierContext

func (*IdentifierNameContext) IsIdentifierNameContext

func (*IdentifierNameContext) IsIdentifierNameContext()

func (*IdentifierNameContext) ReservedWord

func (s *IdentifierNameContext) ReservedWord() IReservedWordContext

func (*IdentifierNameContext) ToStringTree

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

type IfStatementContext

type IfStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIfStatementContext

func NewEmptyIfStatementContext() *IfStatementContext

func NewIfStatementContext

func NewIfStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStatementContext

func (*IfStatementContext) Accept

func (s *IfStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IfStatementContext) AllCloseParen

func (s *IfStatementContext) AllCloseParen() []antlr.TerminalNode

func (*IfStatementContext) AllElse

func (s *IfStatementContext) AllElse() []antlr.TerminalNode

func (*IfStatementContext) AllIf

func (s *IfStatementContext) AllIf() []antlr.TerminalNode

func (*IfStatementContext) AllOpenParen

func (s *IfStatementContext) AllOpenParen() []antlr.TerminalNode

func (*IfStatementContext) AllSingleExpression

func (s *IfStatementContext) AllSingleExpression() []ISingleExpressionContext

func (*IfStatementContext) AllStatement

func (s *IfStatementContext) AllStatement() []IStatementContext

func (*IfStatementContext) CloseParen

func (s *IfStatementContext) CloseParen(i int) antlr.TerminalNode

func (*IfStatementContext) Else

func (s *IfStatementContext) Else(i int) antlr.TerminalNode

func (*IfStatementContext) ElseBlock

func (s *IfStatementContext) ElseBlock() IElseBlockContext

func (*IfStatementContext) GetParser

func (s *IfStatementContext) GetParser() antlr.Parser

func (*IfStatementContext) GetRuleContext

func (s *IfStatementContext) GetRuleContext() antlr.RuleContext

func (*IfStatementContext) If

func (s *IfStatementContext) If(i int) antlr.TerminalNode

func (*IfStatementContext) IsIfStatementContext

func (*IfStatementContext) IsIfStatementContext()

func (*IfStatementContext) OpenParen

func (s *IfStatementContext) OpenParen(i int) antlr.TerminalNode

func (*IfStatementContext) SingleExpression

func (s *IfStatementContext) SingleExpression(i int) ISingleExpressionContext

func (*IfStatementContext) Statement

func (s *IfStatementContext) Statement(i int) IStatementContext

func (*IfStatementContext) ToStringTree

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

type ImportAliasNameContext

type ImportAliasNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportAliasNameContext

func NewEmptyImportAliasNameContext() *ImportAliasNameContext

func NewImportAliasNameContext

func NewImportAliasNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportAliasNameContext

func (*ImportAliasNameContext) Accept

func (s *ImportAliasNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportAliasNameContext) As

func (s *ImportAliasNameContext) As() antlr.TerminalNode

func (*ImportAliasNameContext) GetParser

func (s *ImportAliasNameContext) GetParser() antlr.Parser

func (*ImportAliasNameContext) GetRuleContext

func (s *ImportAliasNameContext) GetRuleContext() antlr.RuleContext

func (*ImportAliasNameContext) ImportedBinding

func (s *ImportAliasNameContext) ImportedBinding() IImportedBindingContext

func (*ImportAliasNameContext) IsImportAliasNameContext

func (*ImportAliasNameContext) IsImportAliasNameContext()

func (*ImportAliasNameContext) ModuleExportName

func (s *ImportAliasNameContext) ModuleExportName() IModuleExportNameContext

func (*ImportAliasNameContext) ToStringTree

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

type ImportDefaultContext

type ImportDefaultContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportDefaultContext

func NewEmptyImportDefaultContext() *ImportDefaultContext

func NewImportDefaultContext

func NewImportDefaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportDefaultContext

func (*ImportDefaultContext) Accept

func (s *ImportDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportDefaultContext) AliasName

func (s *ImportDefaultContext) AliasName() IAliasNameContext

func (*ImportDefaultContext) Comma

func (s *ImportDefaultContext) Comma() antlr.TerminalNode

func (*ImportDefaultContext) GetParser

func (s *ImportDefaultContext) GetParser() antlr.Parser

func (*ImportDefaultContext) GetRuleContext

func (s *ImportDefaultContext) GetRuleContext() antlr.RuleContext

func (*ImportDefaultContext) IsImportDefaultContext

func (*ImportDefaultContext) IsImportDefaultContext()

func (*ImportDefaultContext) ToStringTree

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

type ImportExpressionContext

type ImportExpressionContext struct {
	SingleExpressionContext
}

func NewImportExpressionContext

func NewImportExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportExpressionContext

func (*ImportExpressionContext) Accept

func (s *ImportExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportExpressionContext) CloseParen

func (s *ImportExpressionContext) CloseParen() antlr.TerminalNode

func (*ImportExpressionContext) GetRuleContext

func (s *ImportExpressionContext) GetRuleContext() antlr.RuleContext

func (*ImportExpressionContext) Import

func (s *ImportExpressionContext) Import() antlr.TerminalNode

func (*ImportExpressionContext) OpenParen

func (s *ImportExpressionContext) OpenParen() antlr.TerminalNode

func (*ImportExpressionContext) SingleExpression

func (s *ImportExpressionContext) SingleExpression() ISingleExpressionContext

type ImportFromBlockContext

type ImportFromBlockContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportFromBlockContext

func NewEmptyImportFromBlockContext() *ImportFromBlockContext

func NewImportFromBlockContext

func NewImportFromBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportFromBlockContext

func (*ImportFromBlockContext) Accept

func (s *ImportFromBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportFromBlockContext) Eos

func (s *ImportFromBlockContext) Eos() IEosContext

func (*ImportFromBlockContext) GetParser

func (s *ImportFromBlockContext) GetParser() antlr.Parser

func (*ImportFromBlockContext) GetRuleContext

func (s *ImportFromBlockContext) GetRuleContext() antlr.RuleContext

func (*ImportFromBlockContext) ImportDefault

func (s *ImportFromBlockContext) ImportDefault() IImportDefaultContext

func (*ImportFromBlockContext) ImportFrom

func (s *ImportFromBlockContext) ImportFrom() IImportFromContext

func (*ImportFromBlockContext) ImportModuleItems

func (s *ImportFromBlockContext) ImportModuleItems() IImportModuleItemsContext

func (*ImportFromBlockContext) ImportNamespace

func (s *ImportFromBlockContext) ImportNamespace() IImportNamespaceContext

func (*ImportFromBlockContext) IsImportFromBlockContext

func (*ImportFromBlockContext) IsImportFromBlockContext()

func (*ImportFromBlockContext) StringLiteral

func (s *ImportFromBlockContext) StringLiteral() antlr.TerminalNode

func (*ImportFromBlockContext) ToStringTree

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

type ImportFromContext

type ImportFromContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportFromContext

func NewEmptyImportFromContext() *ImportFromContext

func NewImportFromContext

func NewImportFromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportFromContext

func (*ImportFromContext) Accept

func (s *ImportFromContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportFromContext) From

func (s *ImportFromContext) From() antlr.TerminalNode

func (*ImportFromContext) GetParser

func (s *ImportFromContext) GetParser() antlr.Parser

func (*ImportFromContext) GetRuleContext

func (s *ImportFromContext) GetRuleContext() antlr.RuleContext

func (*ImportFromContext) IsImportFromContext

func (*ImportFromContext) IsImportFromContext()

func (*ImportFromContext) StringLiteral

func (s *ImportFromContext) StringLiteral() antlr.TerminalNode

func (*ImportFromContext) ToStringTree

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

type ImportModuleItemsContext

type ImportModuleItemsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportModuleItemsContext

func NewEmptyImportModuleItemsContext() *ImportModuleItemsContext

func NewImportModuleItemsContext

func NewImportModuleItemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportModuleItemsContext

func (*ImportModuleItemsContext) Accept

func (s *ImportModuleItemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportModuleItemsContext) AllComma

func (s *ImportModuleItemsContext) AllComma() []antlr.TerminalNode

func (*ImportModuleItemsContext) AllImportAliasName

func (s *ImportModuleItemsContext) AllImportAliasName() []IImportAliasNameContext

func (*ImportModuleItemsContext) CloseBrace

func (s *ImportModuleItemsContext) CloseBrace() antlr.TerminalNode

func (*ImportModuleItemsContext) Comma

func (s *ImportModuleItemsContext) Comma(i int) antlr.TerminalNode

func (*ImportModuleItemsContext) GetParser

func (s *ImportModuleItemsContext) GetParser() antlr.Parser

func (*ImportModuleItemsContext) GetRuleContext

func (s *ImportModuleItemsContext) GetRuleContext() antlr.RuleContext

func (*ImportModuleItemsContext) ImportAliasName

func (s *ImportModuleItemsContext) ImportAliasName(i int) IImportAliasNameContext

func (*ImportModuleItemsContext) IsImportModuleItemsContext

func (*ImportModuleItemsContext) IsImportModuleItemsContext()

func (*ImportModuleItemsContext) OpenBrace

func (s *ImportModuleItemsContext) OpenBrace() antlr.TerminalNode

func (*ImportModuleItemsContext) ToStringTree

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

type ImportNamespaceContext

type ImportNamespaceContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportNamespaceContext

func NewEmptyImportNamespaceContext() *ImportNamespaceContext

func NewImportNamespaceContext

func NewImportNamespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportNamespaceContext

func (*ImportNamespaceContext) Accept

func (s *ImportNamespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportNamespaceContext) AllIdentifierName

func (s *ImportNamespaceContext) AllIdentifierName() []IIdentifierNameContext

func (*ImportNamespaceContext) As

func (s *ImportNamespaceContext) As() antlr.TerminalNode

func (*ImportNamespaceContext) GetParser

func (s *ImportNamespaceContext) GetParser() antlr.Parser

func (*ImportNamespaceContext) GetRuleContext

func (s *ImportNamespaceContext) GetRuleContext() antlr.RuleContext

func (*ImportNamespaceContext) IdentifierName

func (s *ImportNamespaceContext) IdentifierName(i int) IIdentifierNameContext

func (*ImportNamespaceContext) IsImportNamespaceContext

func (*ImportNamespaceContext) IsImportNamespaceContext()

func (*ImportNamespaceContext) Multiply

func (s *ImportNamespaceContext) Multiply() antlr.TerminalNode

func (*ImportNamespaceContext) ToStringTree

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

type ImportStatementContext

type ImportStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportStatementContext

func NewEmptyImportStatementContext() *ImportStatementContext

func NewImportStatementContext

func NewImportStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportStatementContext

func (*ImportStatementContext) Accept

func (s *ImportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportStatementContext) GetParser

func (s *ImportStatementContext) GetParser() antlr.Parser

func (*ImportStatementContext) GetRuleContext

func (s *ImportStatementContext) GetRuleContext() antlr.RuleContext

func (*ImportStatementContext) Import

func (s *ImportStatementContext) Import() antlr.TerminalNode

func (*ImportStatementContext) ImportFromBlock

func (s *ImportStatementContext) ImportFromBlock() IImportFromBlockContext

func (*ImportStatementContext) IsImportStatementContext

func (*ImportStatementContext) IsImportStatementContext()

func (*ImportStatementContext) ToStringTree

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

type ImportedBindingContext

type ImportedBindingContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyImportedBindingContext

func NewEmptyImportedBindingContext() *ImportedBindingContext

func NewImportedBindingContext

func NewImportedBindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportedBindingContext

func (*ImportedBindingContext) Accept

func (s *ImportedBindingContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ImportedBindingContext) Await

func (s *ImportedBindingContext) Await() antlr.TerminalNode

func (*ImportedBindingContext) GetParser

func (s *ImportedBindingContext) GetParser() antlr.Parser

func (*ImportedBindingContext) GetRuleContext

func (s *ImportedBindingContext) GetRuleContext() antlr.RuleContext

func (*ImportedBindingContext) Identifier

func (s *ImportedBindingContext) Identifier() antlr.TerminalNode

func (*ImportedBindingContext) IsImportedBindingContext

func (*ImportedBindingContext) IsImportedBindingContext()

func (*ImportedBindingContext) ToStringTree

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

func (*ImportedBindingContext) Yield

func (s *ImportedBindingContext) Yield() antlr.TerminalNode

type InExpressionContext

type InExpressionContext struct {
	SingleExpressionContext
}

func NewInExpressionContext

func NewInExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InExpressionContext

func (*InExpressionContext) Accept

func (s *InExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InExpressionContext) AllSingleExpression

func (s *InExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*InExpressionContext) GetRuleContext

func (s *InExpressionContext) GetRuleContext() antlr.RuleContext

func (*InExpressionContext) In

func (s *InExpressionContext) In() antlr.TerminalNode

func (*InExpressionContext) SingleExpression

func (s *InExpressionContext) SingleExpression(i int) ISingleExpressionContext

type InitializerContext

type InitializerContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInitializerContext

func NewEmptyInitializerContext() *InitializerContext

func NewInitializerContext

func NewInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitializerContext

func (*InitializerContext) Accept

func (s *InitializerContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InitializerContext) Assign

func (s *InitializerContext) Assign() antlr.TerminalNode

func (*InitializerContext) GetParser

func (s *InitializerContext) GetParser() antlr.Parser

func (*InitializerContext) GetRuleContext

func (s *InitializerContext) GetRuleContext() antlr.RuleContext

func (*InitializerContext) IsInitializerContext

func (*InitializerContext) IsInitializerContext()

func (*InitializerContext) SingleExpression

func (s *InitializerContext) SingleExpression() ISingleExpressionContext

func (*InitializerContext) ToStringTree

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

type InstanceofExpressionContext

type InstanceofExpressionContext struct {
	SingleExpressionContext
}

func NewInstanceofExpressionContext

func NewInstanceofExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InstanceofExpressionContext

func (*InstanceofExpressionContext) Accept

func (s *InstanceofExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InstanceofExpressionContext) AllSingleExpression

func (s *InstanceofExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*InstanceofExpressionContext) GetRuleContext

func (s *InstanceofExpressionContext) GetRuleContext() antlr.RuleContext

func (*InstanceofExpressionContext) Instanceof

func (s *InstanceofExpressionContext) Instanceof() antlr.TerminalNode

func (*InstanceofExpressionContext) SingleExpression

func (s *InstanceofExpressionContext) SingleExpression(i int) ISingleExpressionContext

type IterationStatementContext

type IterationStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIterationStatementContext

func NewEmptyIterationStatementContext() *IterationStatementContext

func NewIterationStatementContext

func NewIterationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterationStatementContext

func (*IterationStatementContext) CopyAll

func (s *IterationStatementContext) CopyAll(ctx *IterationStatementContext)

func (*IterationStatementContext) GetParser

func (s *IterationStatementContext) GetParser() antlr.Parser

func (*IterationStatementContext) GetRuleContext

func (s *IterationStatementContext) GetRuleContext() antlr.RuleContext

func (*IterationStatementContext) IsIterationStatementContext

func (*IterationStatementContext) IsIterationStatementContext()

func (*IterationStatementContext) ToStringTree

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

type JavaScriptLexer

type JavaScriptLexer struct {
	JavaScriptLexerBase
	// contains filtered or unexported fields
}

func NewJavaScriptLexer

func NewJavaScriptLexer(input antlr.CharStream) *JavaScriptLexer

NewJavaScriptLexer produces a new lexer instance for the optional input antlr.CharStream.

func (*JavaScriptLexer) Action

func (l *JavaScriptLexer) Action(localctx antlr.RuleContext, ruleIndex, actionIndex int)

func (*JavaScriptLexer) BackTickInside_Action

func (l *JavaScriptLexer) BackTickInside_Action(localctx antlr.RuleContext, actionIndex int)

func (*JavaScriptLexer) BackTick_Action

func (l *JavaScriptLexer) BackTick_Action(localctx antlr.RuleContext, actionIndex int)

func (*JavaScriptLexer) CloseBrace_Action

func (l *JavaScriptLexer) CloseBrace_Action(localctx antlr.RuleContext, actionIndex int)

func (*JavaScriptLexer) HashBangLine_Sempred

func (p *JavaScriptLexer) HashBangLine_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) Implements_Sempred

func (p *JavaScriptLexer) Implements_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) Interface_Sempred

func (p *JavaScriptLexer) Interface_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) NonStrictLet_Sempred

func (p *JavaScriptLexer) NonStrictLet_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) OctalIntegerLiteral_Sempred

func (p *JavaScriptLexer) OctalIntegerLiteral_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) OpenBrace_Action

func (l *JavaScriptLexer) OpenBrace_Action(localctx antlr.RuleContext, actionIndex int)

func (*JavaScriptLexer) Package_Sempred

func (p *JavaScriptLexer) Package_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) Private_Sempred

func (p *JavaScriptLexer) Private_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) Protected_Sempred

func (p *JavaScriptLexer) Protected_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) Public_Sempred

func (p *JavaScriptLexer) Public_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) RegularExpressionLiteral_Sempred

func (p *JavaScriptLexer) RegularExpressionLiteral_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) Sempred

func (l *JavaScriptLexer) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

func (*JavaScriptLexer) Static_Sempred

func (p *JavaScriptLexer) Static_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) StrictLet_Sempred

func (p *JavaScriptLexer) StrictLet_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptLexer) StringLiteral_Action

func (l *JavaScriptLexer) StringLiteral_Action(localctx antlr.RuleContext, actionIndex int)

func (*JavaScriptLexer) TemplateCloseBrace_Sempred

func (p *JavaScriptLexer) TemplateCloseBrace_Sempred(localctx antlr.RuleContext, predIndex int) bool

type JavaScriptLexerBase

type JavaScriptLexerBase struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

JavaScriptLexerBase state

func (*JavaScriptLexerBase) DecreaseTemplateDepth

func (l *JavaScriptLexerBase) DecreaseTemplateDepth()

func (*JavaScriptLexerBase) IncreaseTemplateDepth

func (l *JavaScriptLexerBase) IncreaseTemplateDepth()

func (*JavaScriptLexerBase) IsInTemplateString

func (l *JavaScriptLexerBase) IsInTemplateString() bool

func (*JavaScriptLexerBase) IsRegexPossible

func (l *JavaScriptLexerBase) IsRegexPossible() bool

IsRegexPossible returns true if the lexer can match a regex literal.

func (*JavaScriptLexerBase) IsStartOfFile

func (l *JavaScriptLexerBase) IsStartOfFile() bool

func (*JavaScriptLexerBase) IsStrictMode

func (l *JavaScriptLexerBase) IsStrictMode() bool

IsStrictMode is self explanatory.

func (*JavaScriptLexerBase) NextToken

func (l *JavaScriptLexerBase) NextToken() antlr.Token

NextToken from the character stream.

func (*JavaScriptLexerBase) ProcessCloseBrace

func (l *JavaScriptLexerBase) ProcessCloseBrace()

ProcessCloseBrace is called when a } is encountered during lexing, we pop a scope unless we're inside global scope.

func (*JavaScriptLexerBase) ProcessOpenBrace

func (l *JavaScriptLexerBase) ProcessOpenBrace()

ProcessOpenBrace is called when a { is encountered during lexing, we push a new scope everytime.

func (*JavaScriptLexerBase) ProcessStringLiteral

func (l *JavaScriptLexerBase) ProcessStringLiteral()

ProcessStringLiteral is called when lexing a string literal.

func (*JavaScriptLexerBase) Reset

func (l *JavaScriptLexerBase) Reset()

type JavaScriptParser

type JavaScriptParser struct {
	JavaScriptParserBase
}

func NewJavaScriptParser

func NewJavaScriptParser(input antlr.TokenStream) *JavaScriptParser

NewJavaScriptParser produces a new parser instance for the optional input antlr.TokenStream.

func (*JavaScriptParser) AliasName

func (p *JavaScriptParser) AliasName() (localctx IAliasNameContext)

func (*JavaScriptParser) AnonymousFunction

func (p *JavaScriptParser) AnonymousFunction() (localctx IAnonymousFunctionContext)

func (*JavaScriptParser) Argument

func (p *JavaScriptParser) Argument() (localctx IArgumentContext)

func (*JavaScriptParser) Arguments

func (p *JavaScriptParser) Arguments() (localctx IArgumentsContext)

func (*JavaScriptParser) ArrayElement

func (p *JavaScriptParser) ArrayElement() (localctx IArrayElementContext)

func (*JavaScriptParser) ArrayLiteral

func (p *JavaScriptParser) ArrayLiteral() (localctx IArrayLiteralContext)

func (*JavaScriptParser) ArrowFunctionBody

func (p *JavaScriptParser) ArrowFunctionBody() (localctx IArrowFunctionBodyContext)

func (*JavaScriptParser) ArrowFunctionParameters

func (p *JavaScriptParser) ArrowFunctionParameters() (localctx IArrowFunctionParametersContext)

func (*JavaScriptParser) Assignable

func (p *JavaScriptParser) Assignable() (localctx IAssignableContext)

func (*JavaScriptParser) AssignmentOperator

func (p *JavaScriptParser) AssignmentOperator() (localctx IAssignmentOperatorContext)

func (*JavaScriptParser) BigintLiteral

func (p *JavaScriptParser) BigintLiteral() (localctx IBigintLiteralContext)

func (*JavaScriptParser) Block

func (p *JavaScriptParser) Block() (localctx IBlockContext)

func (*JavaScriptParser) BreakStatement

func (p *JavaScriptParser) BreakStatement() (localctx IBreakStatementContext)

func (*JavaScriptParser) BreakStatement_Sempred

func (p *JavaScriptParser) BreakStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) CaseBlock

func (p *JavaScriptParser) CaseBlock() (localctx ICaseBlockContext)

func (*JavaScriptParser) CaseClause

func (p *JavaScriptParser) CaseClause() (localctx ICaseClauseContext)

func (*JavaScriptParser) CaseClauses

func (p *JavaScriptParser) CaseClauses() (localctx ICaseClausesContext)

func (*JavaScriptParser) CatchProduction

func (p *JavaScriptParser) CatchProduction() (localctx ICatchProductionContext)

func (*JavaScriptParser) ClassDeclaration

func (p *JavaScriptParser) ClassDeclaration() (localctx IClassDeclarationContext)

func (*JavaScriptParser) ClassElement

func (p *JavaScriptParser) ClassElement() (localctx IClassElementContext)

func (*JavaScriptParser) ClassElementName

func (p *JavaScriptParser) ClassElementName() (localctx IClassElementNameContext)

func (*JavaScriptParser) ClassElement_Sempred

func (p *JavaScriptParser) ClassElement_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) ClassTail

func (p *JavaScriptParser) ClassTail() (localctx IClassTailContext)

func (*JavaScriptParser) ContinueStatement

func (p *JavaScriptParser) ContinueStatement() (localctx IContinueStatementContext)

func (*JavaScriptParser) ContinueStatement_Sempred

func (p *JavaScriptParser) ContinueStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) DebuggerStatement

func (p *JavaScriptParser) DebuggerStatement() (localctx IDebuggerStatementContext)

func (*JavaScriptParser) Declaration

func (p *JavaScriptParser) Declaration() (localctx IDeclarationContext)

func (*JavaScriptParser) DefaultClause

func (p *JavaScriptParser) DefaultClause() (localctx IDefaultClauseContext)

func (*JavaScriptParser) ElementList

func (p *JavaScriptParser) ElementList() (localctx IElementListContext)

func (*JavaScriptParser) ElseBlock

func (p *JavaScriptParser) ElseBlock() (localctx IElseBlockContext)

func (*JavaScriptParser) EmptyStatement_

func (p *JavaScriptParser) EmptyStatement_() (localctx IEmptyStatement_Context)

func (*JavaScriptParser) Eos

func (p *JavaScriptParser) Eos() (localctx IEosContext)

func (*JavaScriptParser) Eos_Sempred

func (p *JavaScriptParser) Eos_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) ExportAliasName

func (p *JavaScriptParser) ExportAliasName() (localctx IExportAliasNameContext)

func (*JavaScriptParser) ExportFromBlock

func (p *JavaScriptParser) ExportFromBlock() (localctx IExportFromBlockContext)

func (*JavaScriptParser) ExportModuleItems

func (p *JavaScriptParser) ExportModuleItems() (localctx IExportModuleItemsContext)

func (*JavaScriptParser) ExportStatement

func (p *JavaScriptParser) ExportStatement() (localctx IExportStatementContext)

func (*JavaScriptParser) ExpressionSequence

func (p *JavaScriptParser) ExpressionSequence() (localctx IExpressionSequenceContext)

func (*JavaScriptParser) ExpressionStatement

func (p *JavaScriptParser) ExpressionStatement() (localctx IExpressionStatementContext)

func (*JavaScriptParser) ExpressionStatement_Sempred

func (p *JavaScriptParser) ExpressionStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) FieldDefinition

func (p *JavaScriptParser) FieldDefinition() (localctx IFieldDefinitionContext)

func (*JavaScriptParser) FinallyProduction

func (p *JavaScriptParser) FinallyProduction() (localctx IFinallyProductionContext)

func (*JavaScriptParser) ForFirst

func (p *JavaScriptParser) ForFirst() (localctx IForFirstContext)

func (*JavaScriptParser) ForSecond

func (p *JavaScriptParser) ForSecond() (localctx IForSecondContext)

func (*JavaScriptParser) ForThird

func (p *JavaScriptParser) ForThird() (localctx IForThirdContext)

func (*JavaScriptParser) FormalParameterArg

func (p *JavaScriptParser) FormalParameterArg() (localctx IFormalParameterArgContext)

func (*JavaScriptParser) FormalParameterList

func (p *JavaScriptParser) FormalParameterList() (localctx IFormalParameterListContext)

func (*JavaScriptParser) FunctionBody

func (p *JavaScriptParser) FunctionBody() (localctx IFunctionBodyContext)

func (*JavaScriptParser) FunctionDeclaration

func (p *JavaScriptParser) FunctionDeclaration() (localctx IFunctionDeclarationContext)

func (*JavaScriptParser) Getter

func (p *JavaScriptParser) Getter() (localctx IGetterContext)

func (*JavaScriptParser) Getter_Sempred

func (p *JavaScriptParser) Getter_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) Identifier

func (p *JavaScriptParser) Identifier() (localctx IIdentifierContext)

func (*JavaScriptParser) IdentifierName

func (p *JavaScriptParser) IdentifierName() (localctx IIdentifierNameContext)

func (*JavaScriptParser) IfStatement

func (p *JavaScriptParser) IfStatement() (localctx IIfStatementContext)

func (*JavaScriptParser) ImportAliasName

func (p *JavaScriptParser) ImportAliasName() (localctx IImportAliasNameContext)

func (*JavaScriptParser) ImportDefault

func (p *JavaScriptParser) ImportDefault() (localctx IImportDefaultContext)

func (*JavaScriptParser) ImportFrom

func (p *JavaScriptParser) ImportFrom() (localctx IImportFromContext)

func (*JavaScriptParser) ImportFromBlock

func (p *JavaScriptParser) ImportFromBlock() (localctx IImportFromBlockContext)

func (*JavaScriptParser) ImportModuleItems

func (p *JavaScriptParser) ImportModuleItems() (localctx IImportModuleItemsContext)

func (*JavaScriptParser) ImportNamespace

func (p *JavaScriptParser) ImportNamespace() (localctx IImportNamespaceContext)

func (*JavaScriptParser) ImportStatement

func (p *JavaScriptParser) ImportStatement() (localctx IImportStatementContext)

func (*JavaScriptParser) ImportedBinding

func (p *JavaScriptParser) ImportedBinding() (localctx IImportedBindingContext)

func (*JavaScriptParser) Initializer

func (p *JavaScriptParser) Initializer() (localctx IInitializerContext)

func (*JavaScriptParser) IterationStatement

func (p *JavaScriptParser) IterationStatement() (localctx IIterationStatementContext)

func (*JavaScriptParser) IterationStatement_Sempred

func (p *JavaScriptParser) IterationStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) Keyword

func (p *JavaScriptParser) Keyword() (localctx IKeywordContext)

func (*JavaScriptParser) LabelledStatement

func (p *JavaScriptParser) LabelledStatement() (localctx ILabelledStatementContext)

func (*JavaScriptParser) LastFormalParameterArg

func (p *JavaScriptParser) LastFormalParameterArg() (localctx ILastFormalParameterArgContext)

func (*JavaScriptParser) Let_

func (p *JavaScriptParser) Let_() (localctx ILet_Context)

func (*JavaScriptParser) Literal

func (p *JavaScriptParser) Literal() (localctx ILiteralContext)

func (*JavaScriptParser) MethodDefinition

func (p *JavaScriptParser) MethodDefinition() (localctx IMethodDefinitionContext)

func (*JavaScriptParser) MethodDefinition_Sempred

func (p *JavaScriptParser) MethodDefinition_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) ModuleExportName

func (p *JavaScriptParser) ModuleExportName() (localctx IModuleExportNameContext)

func (*JavaScriptParser) NumericLiteral

func (p *JavaScriptParser) NumericLiteral() (localctx INumericLiteralContext)

func (*JavaScriptParser) ObjectLiteral

func (p *JavaScriptParser) ObjectLiteral() (localctx IObjectLiteralContext)

func (*JavaScriptParser) PrivateIdentifier

func (p *JavaScriptParser) PrivateIdentifier() (localctx IPrivateIdentifierContext)

func (*JavaScriptParser) Program

func (p *JavaScriptParser) Program() (localctx IProgramContext)

func (*JavaScriptParser) PropertyAssignment

func (p *JavaScriptParser) PropertyAssignment() (localctx IPropertyAssignmentContext)

func (*JavaScriptParser) PropertyName

func (p *JavaScriptParser) PropertyName() (localctx IPropertyNameContext)

func (*JavaScriptParser) ReservedWord

func (p *JavaScriptParser) ReservedWord() (localctx IReservedWordContext)

func (*JavaScriptParser) ReturnStatement

func (p *JavaScriptParser) ReturnStatement() (localctx IReturnStatementContext)

func (*JavaScriptParser) ReturnStatement_Sempred

func (p *JavaScriptParser) ReturnStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) Sempred

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

func (*JavaScriptParser) Setter

func (p *JavaScriptParser) Setter() (localctx ISetterContext)

func (*JavaScriptParser) Setter_Sempred

func (p *JavaScriptParser) Setter_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) SingleExpression

func (p *JavaScriptParser) SingleExpression() (localctx ISingleExpressionContext)

func (*JavaScriptParser) SingleExpression_Sempred

func (p *JavaScriptParser) SingleExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) SourceElement

func (p *JavaScriptParser) SourceElement() (localctx ISourceElementContext)

func (*JavaScriptParser) SourceElements

func (p *JavaScriptParser) SourceElements() (localctx ISourceElementsContext)

func (*JavaScriptParser) Statement

func (p *JavaScriptParser) Statement() (localctx IStatementContext)

func (*JavaScriptParser) StatementList

func (p *JavaScriptParser) StatementList() (localctx IStatementListContext)

func (*JavaScriptParser) SwitchStatement

func (p *JavaScriptParser) SwitchStatement() (localctx ISwitchStatementContext)

func (*JavaScriptParser) TemplateStringAtom

func (p *JavaScriptParser) TemplateStringAtom() (localctx ITemplateStringAtomContext)

func (*JavaScriptParser) TemplateStringLiteral

func (p *JavaScriptParser) TemplateStringLiteral() (localctx ITemplateStringLiteralContext)

func (*JavaScriptParser) ThrowStatement

func (p *JavaScriptParser) ThrowStatement() (localctx IThrowStatementContext)

func (*JavaScriptParser) ThrowStatement_Sempred

func (p *JavaScriptParser) ThrowStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) TryStatement

func (p *JavaScriptParser) TryStatement() (localctx ITryStatementContext)

func (*JavaScriptParser) VarModifier

func (p *JavaScriptParser) VarModifier() (localctx IVarModifierContext)

func (*JavaScriptParser) VariableDeclaration

func (p *JavaScriptParser) VariableDeclaration() (localctx IVariableDeclarationContext)

func (*JavaScriptParser) VariableDeclarationList

func (p *JavaScriptParser) VariableDeclarationList() (localctx IVariableDeclarationListContext)

func (*JavaScriptParser) VariableStatement

func (p *JavaScriptParser) VariableStatement() (localctx IVariableStatementContext)

func (*JavaScriptParser) WithStatement

func (p *JavaScriptParser) WithStatement() (localctx IWithStatementContext)

func (*JavaScriptParser) YieldStatement

func (p *JavaScriptParser) YieldStatement() (localctx IYieldStatementContext)

func (*JavaScriptParser) YieldStatement_Sempred

func (p *JavaScriptParser) YieldStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

type JavaScriptParserBase

type JavaScriptParserBase struct {
	*antlr.BaseParser
}

JavaScriptParserBase implementation.

type JavaScriptParserVisitor

type JavaScriptParserVisitor interface {
	antlr.ParseTreeVisitor

	// Visit a parse tree produced by JavaScriptParser#program.
	VisitProgram(ctx *ProgramContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#sourceElement.
	VisitSourceElement(ctx *SourceElementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#statement.
	VisitStatement(ctx *StatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#block.
	VisitBlock(ctx *BlockContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#statementList.
	VisitStatementList(ctx *StatementListContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#importStatement.
	VisitImportStatement(ctx *ImportStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#importFromBlock.
	VisitImportFromBlock(ctx *ImportFromBlockContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#importModuleItems.
	VisitImportModuleItems(ctx *ImportModuleItemsContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#importAliasName.
	VisitImportAliasName(ctx *ImportAliasNameContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#moduleExportName.
	VisitModuleExportName(ctx *ModuleExportNameContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#importedBinding.
	VisitImportedBinding(ctx *ImportedBindingContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#importDefault.
	VisitImportDefault(ctx *ImportDefaultContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#importNamespace.
	VisitImportNamespace(ctx *ImportNamespaceContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#importFrom.
	VisitImportFrom(ctx *ImportFromContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#aliasName.
	VisitAliasName(ctx *AliasNameContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ExportDeclaration.
	VisitExportDeclaration(ctx *ExportDeclarationContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ExportDefaultDeclaration.
	VisitExportDefaultDeclaration(ctx *ExportDefaultDeclarationContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#exportFromBlock.
	VisitExportFromBlock(ctx *ExportFromBlockContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#exportModuleItems.
	VisitExportModuleItems(ctx *ExportModuleItemsContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#exportAliasName.
	VisitExportAliasName(ctx *ExportAliasNameContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#declaration.
	VisitDeclaration(ctx *DeclarationContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#variableStatement.
	VisitVariableStatement(ctx *VariableStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#variableDeclarationList.
	VisitVariableDeclarationList(ctx *VariableDeclarationListContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#variableDeclaration.
	VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#emptyStatement_.
	VisitEmptyStatement_(ctx *EmptyStatement_Context) interface{}

	// Visit a parse tree produced by JavaScriptParser#expressionStatement.
	VisitExpressionStatement(ctx *ExpressionStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ifStatement.
	VisitIfStatement(ctx *IfStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#elseBlock.
	VisitElseBlock(ctx *ElseBlockContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#forFirst.
	VisitForFirst(ctx *ForFirstContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#forSecond.
	VisitForSecond(ctx *ForSecondContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#forThird.
	VisitForThird(ctx *ForThirdContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#DoStatement.
	VisitDoStatement(ctx *DoStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#WhileStatement.
	VisitWhileStatement(ctx *WhileStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ForStatement.
	VisitForStatement(ctx *ForStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ForInStatement.
	VisitForInStatement(ctx *ForInStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ForOfStatement.
	VisitForOfStatement(ctx *ForOfStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#varModifier.
	VisitVarModifier(ctx *VarModifierContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#continueStatement.
	VisitContinueStatement(ctx *ContinueStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#breakStatement.
	VisitBreakStatement(ctx *BreakStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#returnStatement.
	VisitReturnStatement(ctx *ReturnStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#yieldStatement.
	VisitYieldStatement(ctx *YieldStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#withStatement.
	VisitWithStatement(ctx *WithStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#switchStatement.
	VisitSwitchStatement(ctx *SwitchStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#caseBlock.
	VisitCaseBlock(ctx *CaseBlockContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#caseClauses.
	VisitCaseClauses(ctx *CaseClausesContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#caseClause.
	VisitCaseClause(ctx *CaseClauseContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#defaultClause.
	VisitDefaultClause(ctx *DefaultClauseContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#labelledStatement.
	VisitLabelledStatement(ctx *LabelledStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#throwStatement.
	VisitThrowStatement(ctx *ThrowStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#tryStatement.
	VisitTryStatement(ctx *TryStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#catchProduction.
	VisitCatchProduction(ctx *CatchProductionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#finallyProduction.
	VisitFinallyProduction(ctx *FinallyProductionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#debuggerStatement.
	VisitDebuggerStatement(ctx *DebuggerStatementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#functionDeclaration.
	VisitFunctionDeclaration(ctx *FunctionDeclarationContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#classDeclaration.
	VisitClassDeclaration(ctx *ClassDeclarationContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#classTail.
	VisitClassTail(ctx *ClassTailContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#classElement.
	VisitClassElement(ctx *ClassElementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#methodDefinition.
	VisitMethodDefinition(ctx *MethodDefinitionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#fieldDefinition.
	VisitFieldDefinition(ctx *FieldDefinitionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#classElementName.
	VisitClassElementName(ctx *ClassElementNameContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#privateIdentifier.
	VisitPrivateIdentifier(ctx *PrivateIdentifierContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#formalParameterList.
	VisitFormalParameterList(ctx *FormalParameterListContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#formalParameterArg.
	VisitFormalParameterArg(ctx *FormalParameterArgContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#lastFormalParameterArg.
	VisitLastFormalParameterArg(ctx *LastFormalParameterArgContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#functionBody.
	VisitFunctionBody(ctx *FunctionBodyContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#sourceElements.
	VisitSourceElements(ctx *SourceElementsContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#arrayLiteral.
	VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#elementList.
	VisitElementList(ctx *ElementListContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#arrayElement.
	VisitArrayElement(ctx *ArrayElementContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PropertyExpressionAssignment.
	VisitPropertyExpressionAssignment(ctx *PropertyExpressionAssignmentContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ComputedPropertyExpressionAssignment.
	VisitComputedPropertyExpressionAssignment(ctx *ComputedPropertyExpressionAssignmentContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#FunctionProperty.
	VisitFunctionProperty(ctx *FunctionPropertyContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PropertyGetter.
	VisitPropertyGetter(ctx *PropertyGetterContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PropertySetter.
	VisitPropertySetter(ctx *PropertySetterContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PropertyShorthand.
	VisitPropertyShorthand(ctx *PropertyShorthandContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#propertyName.
	VisitPropertyName(ctx *PropertyNameContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#arguments.
	VisitArguments(ctx *ArgumentsContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#argument.
	VisitArgument(ctx *ArgumentContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#expressionSequence.
	VisitExpressionSequence(ctx *ExpressionSequenceContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#TemplateStringExpression.
	VisitTemplateStringExpression(ctx *TemplateStringExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#TernaryExpression.
	VisitTernaryExpression(ctx *TernaryExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#LogicalAndExpression.
	VisitLogicalAndExpression(ctx *LogicalAndExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PowerExpression.
	VisitPowerExpression(ctx *PowerExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PreIncrementExpression.
	VisitPreIncrementExpression(ctx *PreIncrementExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ObjectLiteralExpression.
	VisitObjectLiteralExpression(ctx *ObjectLiteralExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#MetaExpression.
	VisitMetaExpression(ctx *MetaExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#InExpression.
	VisitInExpression(ctx *InExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#LogicalOrExpression.
	VisitLogicalOrExpression(ctx *LogicalOrExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#OptionalChainExpression.
	VisitOptionalChainExpression(ctx *OptionalChainExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#NotExpression.
	VisitNotExpression(ctx *NotExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PreDecreaseExpression.
	VisitPreDecreaseExpression(ctx *PreDecreaseExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ArgumentsExpression.
	VisitArgumentsExpression(ctx *ArgumentsExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#AwaitExpression.
	VisitAwaitExpression(ctx *AwaitExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ThisExpression.
	VisitThisExpression(ctx *ThisExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#FunctionExpression.
	VisitFunctionExpression(ctx *FunctionExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#UnaryMinusExpression.
	VisitUnaryMinusExpression(ctx *UnaryMinusExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#AssignmentExpression.
	VisitAssignmentExpression(ctx *AssignmentExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PostDecreaseExpression.
	VisitPostDecreaseExpression(ctx *PostDecreaseExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#TypeofExpression.
	VisitTypeofExpression(ctx *TypeofExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#InstanceofExpression.
	VisitInstanceofExpression(ctx *InstanceofExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#UnaryPlusExpression.
	VisitUnaryPlusExpression(ctx *UnaryPlusExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#DeleteExpression.
	VisitDeleteExpression(ctx *DeleteExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ImportExpression.
	VisitImportExpression(ctx *ImportExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#EqualityExpression.
	VisitEqualityExpression(ctx *EqualityExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#BitXOrExpression.
	VisitBitXOrExpression(ctx *BitXOrExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#SuperExpression.
	VisitSuperExpression(ctx *SuperExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#MultiplicativeExpression.
	VisitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#BitShiftExpression.
	VisitBitShiftExpression(ctx *BitShiftExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ParenthesizedExpression.
	VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#AdditiveExpression.
	VisitAdditiveExpression(ctx *AdditiveExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#RelationalExpression.
	VisitRelationalExpression(ctx *RelationalExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PostIncrementExpression.
	VisitPostIncrementExpression(ctx *PostIncrementExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#YieldExpression.
	VisitYieldExpression(ctx *YieldExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#BitNotExpression.
	VisitBitNotExpression(ctx *BitNotExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#NewExpression.
	VisitNewExpression(ctx *NewExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#LiteralExpression.
	VisitLiteralExpression(ctx *LiteralExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ArrayLiteralExpression.
	VisitArrayLiteralExpression(ctx *ArrayLiteralExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#MemberDotExpression.
	VisitMemberDotExpression(ctx *MemberDotExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ClassExpression.
	VisitClassExpression(ctx *ClassExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#MemberIndexExpression.
	VisitMemberIndexExpression(ctx *MemberIndexExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#IdentifierExpression.
	VisitIdentifierExpression(ctx *IdentifierExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#BitAndExpression.
	VisitBitAndExpression(ctx *BitAndExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#BitOrExpression.
	VisitBitOrExpression(ctx *BitOrExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#AssignmentOperatorExpression.
	VisitAssignmentOperatorExpression(ctx *AssignmentOperatorExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#VoidExpression.
	VisitVoidExpression(ctx *VoidExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#CoalesceExpression.
	VisitCoalesceExpression(ctx *CoalesceExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#initializer.
	VisitInitializer(ctx *InitializerContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#assignable.
	VisitAssignable(ctx *AssignableContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#objectLiteral.
	VisitObjectLiteral(ctx *ObjectLiteralContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#AnonymousFunctionDecl.
	VisitAnonymousFunctionDecl(ctx *AnonymousFunctionDeclContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ArrowFunction.
	VisitArrowFunction(ctx *ArrowFunctionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#arrowFunctionParameters.
	VisitArrowFunctionParameters(ctx *ArrowFunctionParametersContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#arrowFunctionBody.
	VisitArrowFunctionBody(ctx *ArrowFunctionBodyContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#assignmentOperator.
	VisitAssignmentOperator(ctx *AssignmentOperatorContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#literal.
	VisitLiteral(ctx *LiteralContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#templateStringLiteral.
	VisitTemplateStringLiteral(ctx *TemplateStringLiteralContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#templateStringAtom.
	VisitTemplateStringAtom(ctx *TemplateStringAtomContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#numericLiteral.
	VisitNumericLiteral(ctx *NumericLiteralContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#bigintLiteral.
	VisitBigintLiteral(ctx *BigintLiteralContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#getter.
	VisitGetter(ctx *GetterContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#setter.
	VisitSetter(ctx *SetterContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#identifierName.
	VisitIdentifierName(ctx *IdentifierNameContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#identifier.
	VisitIdentifier(ctx *IdentifierContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#reservedWord.
	VisitReservedWord(ctx *ReservedWordContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#keyword.
	VisitKeyword(ctx *KeywordContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#let_.
	VisitLet_(ctx *Let_Context) interface{}

	// Visit a parse tree produced by JavaScriptParser#eos.
	VisitEos(ctx *EosContext) interface{}
}

A complete Visitor for a parse tree produced by JavaScriptParser.

type KeywordContext

type KeywordContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyKeywordContext

func NewEmptyKeywordContext() *KeywordContext

func NewKeywordContext

func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext

func (*KeywordContext) Accept

func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*KeywordContext) As

func (s *KeywordContext) As() antlr.TerminalNode

func (*KeywordContext) Async

func (s *KeywordContext) Async() antlr.TerminalNode

func (*KeywordContext) Await

func (s *KeywordContext) Await() antlr.TerminalNode

func (*KeywordContext) Break

func (s *KeywordContext) Break() antlr.TerminalNode

func (*KeywordContext) Case

func (s *KeywordContext) Case() antlr.TerminalNode

func (*KeywordContext) Catch

func (s *KeywordContext) Catch() antlr.TerminalNode

func (*KeywordContext) Class

func (s *KeywordContext) Class() antlr.TerminalNode

func (*KeywordContext) Const

func (s *KeywordContext) Const() antlr.TerminalNode

func (*KeywordContext) Continue

func (s *KeywordContext) Continue() antlr.TerminalNode

func (*KeywordContext) Debugger

func (s *KeywordContext) Debugger() antlr.TerminalNode

func (*KeywordContext) Default

func (s *KeywordContext) Default() antlr.TerminalNode

func (*KeywordContext) Delete

func (s *KeywordContext) Delete() antlr.TerminalNode

func (*KeywordContext) Do

func (s *KeywordContext) Do() antlr.TerminalNode

func (*KeywordContext) Else

func (s *KeywordContext) Else() antlr.TerminalNode

func (*KeywordContext) Enum

func (s *KeywordContext) Enum() antlr.TerminalNode

func (*KeywordContext) Export

func (s *KeywordContext) Export() antlr.TerminalNode

func (*KeywordContext) Extends

func (s *KeywordContext) Extends() antlr.TerminalNode

func (*KeywordContext) Finally

func (s *KeywordContext) Finally() antlr.TerminalNode

func (*KeywordContext) For

func (s *KeywordContext) For() antlr.TerminalNode

func (*KeywordContext) From

func (s *KeywordContext) From() antlr.TerminalNode

func (*KeywordContext) Function_

func (s *KeywordContext) Function_() antlr.TerminalNode

func (*KeywordContext) GetParser

func (s *KeywordContext) GetParser() antlr.Parser

func (*KeywordContext) GetRuleContext

func (s *KeywordContext) GetRuleContext() antlr.RuleContext

func (*KeywordContext) If

func (s *KeywordContext) If() antlr.TerminalNode

func (*KeywordContext) Implements

func (s *KeywordContext) Implements() antlr.TerminalNode

func (*KeywordContext) Import

func (s *KeywordContext) Import() antlr.TerminalNode

func (*KeywordContext) In

func (s *KeywordContext) In() antlr.TerminalNode

func (*KeywordContext) Instanceof

func (s *KeywordContext) Instanceof() antlr.TerminalNode

func (*KeywordContext) Interface

func (s *KeywordContext) Interface() antlr.TerminalNode

func (*KeywordContext) IsKeywordContext

func (*KeywordContext) IsKeywordContext()

func (*KeywordContext) Let_

func (s *KeywordContext) Let_() ILet_Context

func (*KeywordContext) New

func (s *KeywordContext) New() antlr.TerminalNode

func (*KeywordContext) Package

func (s *KeywordContext) Package() antlr.TerminalNode

func (*KeywordContext) Private

func (s *KeywordContext) Private() antlr.TerminalNode

func (*KeywordContext) Protected

func (s *KeywordContext) Protected() antlr.TerminalNode

func (*KeywordContext) Public

func (s *KeywordContext) Public() antlr.TerminalNode

func (*KeywordContext) Return

func (s *KeywordContext) Return() antlr.TerminalNode

func (*KeywordContext) Static

func (s *KeywordContext) Static() antlr.TerminalNode

func (*KeywordContext) Super

func (s *KeywordContext) Super() antlr.TerminalNode

func (*KeywordContext) Switch

func (s *KeywordContext) Switch() antlr.TerminalNode

func (*KeywordContext) This

func (s *KeywordContext) This() antlr.TerminalNode

func (*KeywordContext) Throw

func (s *KeywordContext) Throw() antlr.TerminalNode

func (*KeywordContext) ToStringTree

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

func (*KeywordContext) Try

func (s *KeywordContext) Try() antlr.TerminalNode

func (*KeywordContext) Typeof

func (s *KeywordContext) Typeof() antlr.TerminalNode

func (*KeywordContext) Var

func (s *KeywordContext) Var() antlr.TerminalNode

func (*KeywordContext) Void

func (s *KeywordContext) Void() antlr.TerminalNode

func (*KeywordContext) While

func (s *KeywordContext) While() antlr.TerminalNode

func (*KeywordContext) With

func (s *KeywordContext) With() antlr.TerminalNode

func (*KeywordContext) Yield

func (s *KeywordContext) Yield() antlr.TerminalNode

type LabelledStatementContext

type LabelledStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLabelledStatementContext

func NewEmptyLabelledStatementContext() *LabelledStatementContext

func NewLabelledStatementContext

func NewLabelledStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabelledStatementContext

func (*LabelledStatementContext) Accept

func (s *LabelledStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LabelledStatementContext) Colon

func (s *LabelledStatementContext) Colon() antlr.TerminalNode

func (*LabelledStatementContext) GetParser

func (s *LabelledStatementContext) GetParser() antlr.Parser

func (*LabelledStatementContext) GetRuleContext

func (s *LabelledStatementContext) GetRuleContext() antlr.RuleContext

func (*LabelledStatementContext) Identifier

func (s *LabelledStatementContext) Identifier() IIdentifierContext

func (*LabelledStatementContext) IsLabelledStatementContext

func (*LabelledStatementContext) IsLabelledStatementContext()

func (*LabelledStatementContext) Statement

func (s *LabelledStatementContext) Statement() IStatementContext

func (*LabelledStatementContext) ToStringTree

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

type LastFormalParameterArgContext

type LastFormalParameterArgContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLastFormalParameterArgContext

func NewEmptyLastFormalParameterArgContext() *LastFormalParameterArgContext

func NewLastFormalParameterArgContext

func NewLastFormalParameterArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LastFormalParameterArgContext

func (*LastFormalParameterArgContext) Accept

func (s *LastFormalParameterArgContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LastFormalParameterArgContext) Ellipsis

func (s *LastFormalParameterArgContext) Ellipsis() antlr.TerminalNode

func (*LastFormalParameterArgContext) GetParser

func (s *LastFormalParameterArgContext) GetParser() antlr.Parser

func (*LastFormalParameterArgContext) GetRuleContext

func (s *LastFormalParameterArgContext) GetRuleContext() antlr.RuleContext

func (*LastFormalParameterArgContext) IsLastFormalParameterArgContext

func (*LastFormalParameterArgContext) IsLastFormalParameterArgContext()

func (*LastFormalParameterArgContext) SingleExpression

func (s *LastFormalParameterArgContext) SingleExpression() ISingleExpressionContext

func (*LastFormalParameterArgContext) ToStringTree

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

type Let_Context

type Let_Context struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLet_Context

func NewEmptyLet_Context() *Let_Context

func NewLet_Context

func NewLet_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Let_Context

func (*Let_Context) Accept

func (s *Let_Context) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*Let_Context) GetParser

func (s *Let_Context) GetParser() antlr.Parser

func (*Let_Context) GetRuleContext

func (s *Let_Context) GetRuleContext() antlr.RuleContext

func (*Let_Context) IsLet_Context

func (*Let_Context) IsLet_Context()

func (*Let_Context) NonStrictLet

func (s *Let_Context) NonStrictLet() antlr.TerminalNode

func (*Let_Context) StrictLet

func (s *Let_Context) StrictLet() antlr.TerminalNode

func (*Let_Context) ToStringTree

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

type LiteralContext

type LiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLiteralContext

func NewEmptyLiteralContext() *LiteralContext

func NewLiteralContext

func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext

func (*LiteralContext) Accept

func (s *LiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LiteralContext) BigintLiteral

func (s *LiteralContext) BigintLiteral() IBigintLiteralContext

func (*LiteralContext) BooleanLiteral

func (s *LiteralContext) BooleanLiteral() antlr.TerminalNode

func (*LiteralContext) GetParser

func (s *LiteralContext) GetParser() antlr.Parser

func (*LiteralContext) GetRuleContext

func (s *LiteralContext) GetRuleContext() antlr.RuleContext

func (*LiteralContext) IsLiteralContext

func (*LiteralContext) IsLiteralContext()

func (*LiteralContext) NullLiteral

func (s *LiteralContext) NullLiteral() antlr.TerminalNode

func (*LiteralContext) NumericLiteral

func (s *LiteralContext) NumericLiteral() INumericLiteralContext

func (*LiteralContext) RegularExpressionLiteral

func (s *LiteralContext) RegularExpressionLiteral() antlr.TerminalNode

func (*LiteralContext) StringLiteral

func (s *LiteralContext) StringLiteral() antlr.TerminalNode

func (*LiteralContext) TemplateStringLiteral

func (s *LiteralContext) TemplateStringLiteral() ITemplateStringLiteralContext

func (*LiteralContext) ToStringTree

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

type LiteralExpressionContext

type LiteralExpressionContext struct {
	SingleExpressionContext
}

func NewLiteralExpressionContext

func NewLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralExpressionContext

func (*LiteralExpressionContext) Accept

func (s *LiteralExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LiteralExpressionContext) GetRuleContext

func (s *LiteralExpressionContext) GetRuleContext() antlr.RuleContext

func (*LiteralExpressionContext) Literal

func (s *LiteralExpressionContext) Literal() ILiteralContext

type LogicalAndExpressionContext

type LogicalAndExpressionContext struct {
	SingleExpressionContext
}

func NewLogicalAndExpressionContext

func NewLogicalAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalAndExpressionContext

func (*LogicalAndExpressionContext) Accept

func (s *LogicalAndExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LogicalAndExpressionContext) AllSingleExpression

func (s *LogicalAndExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*LogicalAndExpressionContext) And

func (s *LogicalAndExpressionContext) And() antlr.TerminalNode

func (*LogicalAndExpressionContext) GetRuleContext

func (s *LogicalAndExpressionContext) GetRuleContext() antlr.RuleContext

func (*LogicalAndExpressionContext) SingleExpression

func (s *LogicalAndExpressionContext) SingleExpression(i int) ISingleExpressionContext

type LogicalOrExpressionContext

type LogicalOrExpressionContext struct {
	SingleExpressionContext
}

func NewLogicalOrExpressionContext

func NewLogicalOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalOrExpressionContext

func (*LogicalOrExpressionContext) Accept

func (s *LogicalOrExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LogicalOrExpressionContext) AllSingleExpression

func (s *LogicalOrExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*LogicalOrExpressionContext) GetRuleContext

func (s *LogicalOrExpressionContext) GetRuleContext() antlr.RuleContext

func (*LogicalOrExpressionContext) Or

func (s *LogicalOrExpressionContext) Or() antlr.TerminalNode

func (*LogicalOrExpressionContext) SingleExpression

func (s *LogicalOrExpressionContext) SingleExpression(i int) ISingleExpressionContext

type MemberDotExpressionContext

type MemberDotExpressionContext struct {
	SingleExpressionContext
}

func NewMemberDotExpressionContext

func NewMemberDotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberDotExpressionContext

func (*MemberDotExpressionContext) Accept

func (s *MemberDotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MemberDotExpressionContext) Dot

func (s *MemberDotExpressionContext) Dot() antlr.TerminalNode

func (*MemberDotExpressionContext) GetRuleContext

func (s *MemberDotExpressionContext) GetRuleContext() antlr.RuleContext

func (*MemberDotExpressionContext) Hashtag

func (s *MemberDotExpressionContext) Hashtag() antlr.TerminalNode

func (*MemberDotExpressionContext) IdentifierName

func (s *MemberDotExpressionContext) IdentifierName() IIdentifierNameContext

func (*MemberDotExpressionContext) QuestionMark

func (s *MemberDotExpressionContext) QuestionMark() antlr.TerminalNode

func (*MemberDotExpressionContext) SingleExpression

func (s *MemberDotExpressionContext) SingleExpression() ISingleExpressionContext

type MemberIndexExpressionContext

type MemberIndexExpressionContext struct {
	SingleExpressionContext
}

func NewMemberIndexExpressionContext

func NewMemberIndexExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberIndexExpressionContext

func (*MemberIndexExpressionContext) Accept

func (s *MemberIndexExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MemberIndexExpressionContext) AllSingleExpression

func (s *MemberIndexExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*MemberIndexExpressionContext) CloseBracket

func (s *MemberIndexExpressionContext) CloseBracket() antlr.TerminalNode

func (*MemberIndexExpressionContext) GetRuleContext

func (s *MemberIndexExpressionContext) GetRuleContext() antlr.RuleContext

func (*MemberIndexExpressionContext) OpenBracket

func (s *MemberIndexExpressionContext) OpenBracket() antlr.TerminalNode

func (*MemberIndexExpressionContext) QuestionMarkDot

func (s *MemberIndexExpressionContext) QuestionMarkDot() antlr.TerminalNode

func (*MemberIndexExpressionContext) SingleExpression

func (s *MemberIndexExpressionContext) SingleExpression(i int) ISingleExpressionContext

type MetaExpressionContext

type MetaExpressionContext struct {
	SingleExpressionContext
}

func NewMetaExpressionContext

func NewMetaExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MetaExpressionContext

func (*MetaExpressionContext) Accept

func (s *MetaExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MetaExpressionContext) Dot

func (s *MetaExpressionContext) Dot() antlr.TerminalNode

func (*MetaExpressionContext) GetRuleContext

func (s *MetaExpressionContext) GetRuleContext() antlr.RuleContext

func (*MetaExpressionContext) Identifier

func (s *MetaExpressionContext) Identifier() IIdentifierContext

func (*MetaExpressionContext) New

func (s *MetaExpressionContext) New() antlr.TerminalNode

type MethodDefinitionContext

type MethodDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMethodDefinitionContext

func NewEmptyMethodDefinitionContext() *MethodDefinitionContext

func NewMethodDefinitionContext

func NewMethodDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodDefinitionContext

func (*MethodDefinitionContext) Accept

func (s *MethodDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MethodDefinitionContext) Async

func (s *MethodDefinitionContext) Async() antlr.TerminalNode

func (*MethodDefinitionContext) ClassElementName

func (s *MethodDefinitionContext) ClassElementName() IClassElementNameContext

func (*MethodDefinitionContext) CloseParen

func (s *MethodDefinitionContext) CloseParen() antlr.TerminalNode

func (*MethodDefinitionContext) FormalParameterList

func (s *MethodDefinitionContext) FormalParameterList() IFormalParameterListContext

func (*MethodDefinitionContext) FunctionBody

func (s *MethodDefinitionContext) FunctionBody() IFunctionBodyContext

func (*MethodDefinitionContext) GetParser

func (s *MethodDefinitionContext) GetParser() antlr.Parser

func (*MethodDefinitionContext) GetRuleContext

func (s *MethodDefinitionContext) GetRuleContext() antlr.RuleContext

func (*MethodDefinitionContext) Getter

func (s *MethodDefinitionContext) Getter() IGetterContext

func (*MethodDefinitionContext) IsMethodDefinitionContext

func (*MethodDefinitionContext) IsMethodDefinitionContext()

func (*MethodDefinitionContext) Multiply

func (s *MethodDefinitionContext) Multiply() antlr.TerminalNode

func (*MethodDefinitionContext) OpenParen

func (s *MethodDefinitionContext) OpenParen() antlr.TerminalNode

func (*MethodDefinitionContext) Setter

func (s *MethodDefinitionContext) Setter() ISetterContext

func (*MethodDefinitionContext) ToStringTree

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

type ModuleExportNameContext

type ModuleExportNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyModuleExportNameContext

func NewEmptyModuleExportNameContext() *ModuleExportNameContext

func NewModuleExportNameContext

func NewModuleExportNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleExportNameContext

func (*ModuleExportNameContext) Accept

func (s *ModuleExportNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ModuleExportNameContext) GetParser

func (s *ModuleExportNameContext) GetParser() antlr.Parser

func (*ModuleExportNameContext) GetRuleContext

func (s *ModuleExportNameContext) GetRuleContext() antlr.RuleContext

func (*ModuleExportNameContext) IdentifierName

func (s *ModuleExportNameContext) IdentifierName() IIdentifierNameContext

func (*ModuleExportNameContext) IsModuleExportNameContext

func (*ModuleExportNameContext) IsModuleExportNameContext()

func (*ModuleExportNameContext) StringLiteral

func (s *ModuleExportNameContext) StringLiteral() antlr.TerminalNode

func (*ModuleExportNameContext) ToStringTree

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

type MultiplicativeExpressionContext

type MultiplicativeExpressionContext struct {
	SingleExpressionContext
}

func NewMultiplicativeExpressionContext

func NewMultiplicativeExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MultiplicativeExpressionContext

func (*MultiplicativeExpressionContext) Accept

func (s *MultiplicativeExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MultiplicativeExpressionContext) AllSingleExpression

func (s *MultiplicativeExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*MultiplicativeExpressionContext) Divide

func (s *MultiplicativeExpressionContext) Divide() antlr.TerminalNode

func (*MultiplicativeExpressionContext) GetRuleContext

func (s *MultiplicativeExpressionContext) GetRuleContext() antlr.RuleContext

func (*MultiplicativeExpressionContext) Modulus

func (s *MultiplicativeExpressionContext) Modulus() antlr.TerminalNode

func (*MultiplicativeExpressionContext) Multiply

func (s *MultiplicativeExpressionContext) Multiply() antlr.TerminalNode

func (*MultiplicativeExpressionContext) SingleExpression

func (s *MultiplicativeExpressionContext) SingleExpression(i int) ISingleExpressionContext

type NewExpressionContext

type NewExpressionContext struct {
	SingleExpressionContext
}

func NewNewExpressionContext

func NewNewExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NewExpressionContext

func (*NewExpressionContext) Accept

func (s *NewExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NewExpressionContext) Arguments

func (s *NewExpressionContext) Arguments() IArgumentsContext

func (*NewExpressionContext) GetRuleContext

func (s *NewExpressionContext) GetRuleContext() antlr.RuleContext

func (*NewExpressionContext) New

func (s *NewExpressionContext) New() antlr.TerminalNode

func (*NewExpressionContext) SingleExpression

func (s *NewExpressionContext) SingleExpression() ISingleExpressionContext

type NotExpressionContext

type NotExpressionContext struct {
	SingleExpressionContext
}

func NewNotExpressionContext

func NewNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExpressionContext

func (*NotExpressionContext) Accept

func (s *NotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NotExpressionContext) GetRuleContext

func (s *NotExpressionContext) GetRuleContext() antlr.RuleContext

func (*NotExpressionContext) Not

func (s *NotExpressionContext) Not() antlr.TerminalNode

func (*NotExpressionContext) SingleExpression

func (s *NotExpressionContext) SingleExpression() ISingleExpressionContext

type NumericLiteralContext

type NumericLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNumericLiteralContext

func NewEmptyNumericLiteralContext() *NumericLiteralContext

func NewNumericLiteralContext

func NewNumericLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericLiteralContext

func (*NumericLiteralContext) Accept

func (s *NumericLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NumericLiteralContext) BinaryIntegerLiteral

func (s *NumericLiteralContext) BinaryIntegerLiteral() antlr.TerminalNode

func (*NumericLiteralContext) DecimalLiteral

func (s *NumericLiteralContext) DecimalLiteral() antlr.TerminalNode

func (*NumericLiteralContext) GetParser

func (s *NumericLiteralContext) GetParser() antlr.Parser

func (*NumericLiteralContext) GetRuleContext

func (s *NumericLiteralContext) GetRuleContext() antlr.RuleContext

func (*NumericLiteralContext) HexIntegerLiteral

func (s *NumericLiteralContext) HexIntegerLiteral() antlr.TerminalNode

func (*NumericLiteralContext) IsNumericLiteralContext

func (*NumericLiteralContext) IsNumericLiteralContext()

func (*NumericLiteralContext) OctalIntegerLiteral

func (s *NumericLiteralContext) OctalIntegerLiteral() antlr.TerminalNode

func (*NumericLiteralContext) OctalIntegerLiteral2

func (s *NumericLiteralContext) OctalIntegerLiteral2() antlr.TerminalNode

func (*NumericLiteralContext) ToStringTree

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

type ObjectLiteralContext

type ObjectLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyObjectLiteralContext

func NewEmptyObjectLiteralContext() *ObjectLiteralContext

func NewObjectLiteralContext

func NewObjectLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectLiteralContext

func (*ObjectLiteralContext) Accept

func (s *ObjectLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ObjectLiteralContext) AllComma

func (s *ObjectLiteralContext) AllComma() []antlr.TerminalNode

func (*ObjectLiteralContext) AllPropertyAssignment

func (s *ObjectLiteralContext) AllPropertyAssignment() []IPropertyAssignmentContext

func (*ObjectLiteralContext) CloseBrace

func (s *ObjectLiteralContext) CloseBrace() antlr.TerminalNode

func (*ObjectLiteralContext) Comma

func (s *ObjectLiteralContext) Comma(i int) antlr.TerminalNode

func (*ObjectLiteralContext) GetParser

func (s *ObjectLiteralContext) GetParser() antlr.Parser

func (*ObjectLiteralContext) GetRuleContext

func (s *ObjectLiteralContext) GetRuleContext() antlr.RuleContext

func (*ObjectLiteralContext) IsObjectLiteralContext

func (*ObjectLiteralContext) IsObjectLiteralContext()

func (*ObjectLiteralContext) OpenBrace

func (s *ObjectLiteralContext) OpenBrace() antlr.TerminalNode

func (*ObjectLiteralContext) PropertyAssignment

func (s *ObjectLiteralContext) PropertyAssignment(i int) IPropertyAssignmentContext

func (*ObjectLiteralContext) ToStringTree

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

type ObjectLiteralExpressionContext

type ObjectLiteralExpressionContext struct {
	SingleExpressionContext
}

func NewObjectLiteralExpressionContext

func NewObjectLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjectLiteralExpressionContext

func (*ObjectLiteralExpressionContext) Accept

func (s *ObjectLiteralExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ObjectLiteralExpressionContext) GetRuleContext

func (s *ObjectLiteralExpressionContext) GetRuleContext() antlr.RuleContext

func (*ObjectLiteralExpressionContext) ObjectLiteral

func (s *ObjectLiteralExpressionContext) ObjectLiteral() IObjectLiteralContext

type OptionalChainExpressionContext

type OptionalChainExpressionContext struct {
	SingleExpressionContext
}

func NewOptionalChainExpressionContext

func NewOptionalChainExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OptionalChainExpressionContext

func (*OptionalChainExpressionContext) Accept

func (s *OptionalChainExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OptionalChainExpressionContext) AllSingleExpression

func (s *OptionalChainExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*OptionalChainExpressionContext) GetRuleContext

func (s *OptionalChainExpressionContext) GetRuleContext() antlr.RuleContext

func (*OptionalChainExpressionContext) QuestionMarkDot

func (s *OptionalChainExpressionContext) QuestionMarkDot() antlr.TerminalNode

func (*OptionalChainExpressionContext) SingleExpression

func (s *OptionalChainExpressionContext) SingleExpression(i int) ISingleExpressionContext

type ParenthesizedExpressionContext

type ParenthesizedExpressionContext struct {
	SingleExpressionContext
}

func NewParenthesizedExpressionContext

func NewParenthesizedExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesizedExpressionContext

func (*ParenthesizedExpressionContext) Accept

func (s *ParenthesizedExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ParenthesizedExpressionContext) CloseParen

func (s *ParenthesizedExpressionContext) CloseParen() antlr.TerminalNode

func (*ParenthesizedExpressionContext) ExpressionSequence

func (s *ParenthesizedExpressionContext) ExpressionSequence() IExpressionSequenceContext

func (*ParenthesizedExpressionContext) GetRuleContext

func (s *ParenthesizedExpressionContext) GetRuleContext() antlr.RuleContext

func (*ParenthesizedExpressionContext) OpenParen

func (s *ParenthesizedExpressionContext) OpenParen() antlr.TerminalNode

type PostDecreaseExpressionContext

type PostDecreaseExpressionContext struct {
	SingleExpressionContext
}

func NewPostDecreaseExpressionContext

func NewPostDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostDecreaseExpressionContext

func (*PostDecreaseExpressionContext) Accept

func (s *PostDecreaseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PostDecreaseExpressionContext) GetRuleContext

func (s *PostDecreaseExpressionContext) GetRuleContext() antlr.RuleContext

func (*PostDecreaseExpressionContext) MinusMinus

func (s *PostDecreaseExpressionContext) MinusMinus() antlr.TerminalNode

func (*PostDecreaseExpressionContext) SingleExpression

func (s *PostDecreaseExpressionContext) SingleExpression() ISingleExpressionContext

type PostIncrementExpressionContext

type PostIncrementExpressionContext struct {
	SingleExpressionContext
}

func NewPostIncrementExpressionContext

func NewPostIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostIncrementExpressionContext

func (*PostIncrementExpressionContext) Accept

func (s *PostIncrementExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PostIncrementExpressionContext) GetRuleContext

func (s *PostIncrementExpressionContext) GetRuleContext() antlr.RuleContext

func (*PostIncrementExpressionContext) PlusPlus

func (s *PostIncrementExpressionContext) PlusPlus() antlr.TerminalNode

func (*PostIncrementExpressionContext) SingleExpression

func (s *PostIncrementExpressionContext) SingleExpression() ISingleExpressionContext

type PowerExpressionContext

type PowerExpressionContext struct {
	SingleExpressionContext
}

func NewPowerExpressionContext

func NewPowerExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PowerExpressionContext

func (*PowerExpressionContext) Accept

func (s *PowerExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PowerExpressionContext) AllSingleExpression

func (s *PowerExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*PowerExpressionContext) GetRuleContext

func (s *PowerExpressionContext) GetRuleContext() antlr.RuleContext

func (*PowerExpressionContext) Power

func (s *PowerExpressionContext) Power() antlr.TerminalNode

func (*PowerExpressionContext) SingleExpression

func (s *PowerExpressionContext) SingleExpression(i int) ISingleExpressionContext

type PreDecreaseExpressionContext

type PreDecreaseExpressionContext struct {
	SingleExpressionContext
}

func NewPreDecreaseExpressionContext

func NewPreDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreDecreaseExpressionContext

func (*PreDecreaseExpressionContext) Accept

func (s *PreDecreaseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PreDecreaseExpressionContext) GetRuleContext

func (s *PreDecreaseExpressionContext) GetRuleContext() antlr.RuleContext

func (*PreDecreaseExpressionContext) MinusMinus

func (s *PreDecreaseExpressionContext) MinusMinus() antlr.TerminalNode

func (*PreDecreaseExpressionContext) SingleExpression

func (s *PreDecreaseExpressionContext) SingleExpression() ISingleExpressionContext

type PreIncrementExpressionContext

type PreIncrementExpressionContext struct {
	SingleExpressionContext
}

func NewPreIncrementExpressionContext

func NewPreIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreIncrementExpressionContext

func (*PreIncrementExpressionContext) Accept

func (s *PreIncrementExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PreIncrementExpressionContext) GetRuleContext

func (s *PreIncrementExpressionContext) GetRuleContext() antlr.RuleContext

func (*PreIncrementExpressionContext) PlusPlus

func (s *PreIncrementExpressionContext) PlusPlus() antlr.TerminalNode

func (*PreIncrementExpressionContext) SingleExpression

func (s *PreIncrementExpressionContext) SingleExpression() ISingleExpressionContext

type PrivateIdentifierContext

type PrivateIdentifierContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrivateIdentifierContext

func NewEmptyPrivateIdentifierContext() *PrivateIdentifierContext

func NewPrivateIdentifierContext

func NewPrivateIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivateIdentifierContext

func (*PrivateIdentifierContext) Accept

func (s *PrivateIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PrivateIdentifierContext) GetParser

func (s *PrivateIdentifierContext) GetParser() antlr.Parser

func (*PrivateIdentifierContext) GetRuleContext

func (s *PrivateIdentifierContext) GetRuleContext() antlr.RuleContext

func (*PrivateIdentifierContext) Hashtag

func (s *PrivateIdentifierContext) Hashtag() antlr.TerminalNode

func (*PrivateIdentifierContext) IdentifierName

func (s *PrivateIdentifierContext) IdentifierName() IIdentifierNameContext

func (*PrivateIdentifierContext) IsPrivateIdentifierContext

func (*PrivateIdentifierContext) IsPrivateIdentifierContext()

func (*PrivateIdentifierContext) ToStringTree

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

type ProgramContext

type ProgramContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyProgramContext

func NewEmptyProgramContext() *ProgramContext

func NewProgramContext

func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext

func (*ProgramContext) Accept

func (s *ProgramContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ProgramContext) EOF

func (s *ProgramContext) EOF() antlr.TerminalNode

func (*ProgramContext) GetParser

func (s *ProgramContext) GetParser() antlr.Parser

func (*ProgramContext) GetRuleContext

func (s *ProgramContext) GetRuleContext() antlr.RuleContext

func (*ProgramContext) HashBangLine

func (s *ProgramContext) HashBangLine() antlr.TerminalNode

func (*ProgramContext) IsProgramContext

func (*ProgramContext) IsProgramContext()

func (*ProgramContext) SourceElements

func (s *ProgramContext) SourceElements() ISourceElementsContext

func (*ProgramContext) ToStringTree

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

type PropertyAssignmentContext

type PropertyAssignmentContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPropertyAssignmentContext

func NewEmptyPropertyAssignmentContext() *PropertyAssignmentContext

func NewPropertyAssignmentContext

func NewPropertyAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyAssignmentContext

func (*PropertyAssignmentContext) CopyAll

func (s *PropertyAssignmentContext) CopyAll(ctx *PropertyAssignmentContext)

func (*PropertyAssignmentContext) GetParser

func (s *PropertyAssignmentContext) GetParser() antlr.Parser

func (*PropertyAssignmentContext) GetRuleContext

func (s *PropertyAssignmentContext) GetRuleContext() antlr.RuleContext

func (*PropertyAssignmentContext) IsPropertyAssignmentContext

func (*PropertyAssignmentContext) IsPropertyAssignmentContext()

func (*PropertyAssignmentContext) ToStringTree

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

type PropertyExpressionAssignmentContext

type PropertyExpressionAssignmentContext struct {
	PropertyAssignmentContext
}

func NewPropertyExpressionAssignmentContext

func NewPropertyExpressionAssignmentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyExpressionAssignmentContext

func (*PropertyExpressionAssignmentContext) Accept

func (s *PropertyExpressionAssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PropertyExpressionAssignmentContext) Colon

func (s *PropertyExpressionAssignmentContext) Colon() antlr.TerminalNode

func (*PropertyExpressionAssignmentContext) GetRuleContext

func (s *PropertyExpressionAssignmentContext) GetRuleContext() antlr.RuleContext

func (*PropertyExpressionAssignmentContext) PropertyName

func (s *PropertyExpressionAssignmentContext) PropertyName() IPropertyNameContext

func (*PropertyExpressionAssignmentContext) SingleExpression

func (s *PropertyExpressionAssignmentContext) SingleExpression() ISingleExpressionContext

type PropertyGetterContext

type PropertyGetterContext struct {
	PropertyAssignmentContext
}

func NewPropertyGetterContext

func NewPropertyGetterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyGetterContext

func (*PropertyGetterContext) Accept

func (s *PropertyGetterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PropertyGetterContext) CloseParen

func (s *PropertyGetterContext) CloseParen() antlr.TerminalNode

func (*PropertyGetterContext) FunctionBody

func (s *PropertyGetterContext) FunctionBody() IFunctionBodyContext

func (*PropertyGetterContext) GetRuleContext

func (s *PropertyGetterContext) GetRuleContext() antlr.RuleContext

func (*PropertyGetterContext) Getter

func (s *PropertyGetterContext) Getter() IGetterContext

func (*PropertyGetterContext) OpenParen

func (s *PropertyGetterContext) OpenParen() antlr.TerminalNode

type PropertyNameContext

type PropertyNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPropertyNameContext

func NewEmptyPropertyNameContext() *PropertyNameContext

func NewPropertyNameContext

func NewPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyNameContext

func (*PropertyNameContext) Accept

func (s *PropertyNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PropertyNameContext) CloseBracket

func (s *PropertyNameContext) CloseBracket() antlr.TerminalNode

func (*PropertyNameContext) GetParser

func (s *PropertyNameContext) GetParser() antlr.Parser

func (*PropertyNameContext) GetRuleContext

func (s *PropertyNameContext) GetRuleContext() antlr.RuleContext

func (*PropertyNameContext) IdentifierName

func (s *PropertyNameContext) IdentifierName() IIdentifierNameContext

func (*PropertyNameContext) IsPropertyNameContext

func (*PropertyNameContext) IsPropertyNameContext()

func (*PropertyNameContext) NumericLiteral

func (s *PropertyNameContext) NumericLiteral() INumericLiteralContext

func (*PropertyNameContext) OpenBracket

func (s *PropertyNameContext) OpenBracket() antlr.TerminalNode

func (*PropertyNameContext) SingleExpression

func (s *PropertyNameContext) SingleExpression() ISingleExpressionContext

func (*PropertyNameContext) StringLiteral

func (s *PropertyNameContext) StringLiteral() antlr.TerminalNode

func (*PropertyNameContext) ToStringTree

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

type PropertySetterContext

type PropertySetterContext struct {
	PropertyAssignmentContext
}

func NewPropertySetterContext

func NewPropertySetterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertySetterContext

func (*PropertySetterContext) Accept

func (s *PropertySetterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PropertySetterContext) CloseParen

func (s *PropertySetterContext) CloseParen() antlr.TerminalNode

func (*PropertySetterContext) FormalParameterArg

func (s *PropertySetterContext) FormalParameterArg() IFormalParameterArgContext

func (*PropertySetterContext) FunctionBody

func (s *PropertySetterContext) FunctionBody() IFunctionBodyContext

func (*PropertySetterContext) GetRuleContext

func (s *PropertySetterContext) GetRuleContext() antlr.RuleContext

func (*PropertySetterContext) OpenParen

func (s *PropertySetterContext) OpenParen() antlr.TerminalNode

func (*PropertySetterContext) Setter

func (s *PropertySetterContext) Setter() ISetterContext

type PropertyShorthandContext

type PropertyShorthandContext struct {
	PropertyAssignmentContext
}

func NewPropertyShorthandContext

func NewPropertyShorthandContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyShorthandContext

func (*PropertyShorthandContext) Accept

func (s *PropertyShorthandContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PropertyShorthandContext) Ellipsis

func (s *PropertyShorthandContext) Ellipsis() antlr.TerminalNode

func (*PropertyShorthandContext) GetRuleContext

func (s *PropertyShorthandContext) GetRuleContext() antlr.RuleContext

func (*PropertyShorthandContext) SingleExpression

func (s *PropertyShorthandContext) SingleExpression() ISingleExpressionContext

type RelationalExpressionContext

type RelationalExpressionContext struct {
	SingleExpressionContext
}

func NewRelationalExpressionContext

func NewRelationalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelationalExpressionContext

func (*RelationalExpressionContext) Accept

func (s *RelationalExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RelationalExpressionContext) AllSingleExpression

func (s *RelationalExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*RelationalExpressionContext) GetRuleContext

func (s *RelationalExpressionContext) GetRuleContext() antlr.RuleContext

func (*RelationalExpressionContext) GreaterThanEquals

func (s *RelationalExpressionContext) GreaterThanEquals() antlr.TerminalNode

func (*RelationalExpressionContext) LessThan

func (s *RelationalExpressionContext) LessThan() antlr.TerminalNode

func (*RelationalExpressionContext) LessThanEquals

func (s *RelationalExpressionContext) LessThanEquals() antlr.TerminalNode

func (*RelationalExpressionContext) MoreThan

func (s *RelationalExpressionContext) MoreThan() antlr.TerminalNode

func (*RelationalExpressionContext) SingleExpression

func (s *RelationalExpressionContext) SingleExpression(i int) ISingleExpressionContext

type ReservedWordContext

type ReservedWordContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReservedWordContext

func NewEmptyReservedWordContext() *ReservedWordContext

func NewReservedWordContext

func NewReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReservedWordContext

func (*ReservedWordContext) Accept

func (s *ReservedWordContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ReservedWordContext) BooleanLiteral

func (s *ReservedWordContext) BooleanLiteral() antlr.TerminalNode

func (*ReservedWordContext) GetParser

func (s *ReservedWordContext) GetParser() antlr.Parser

func (*ReservedWordContext) GetRuleContext

func (s *ReservedWordContext) GetRuleContext() antlr.RuleContext

func (*ReservedWordContext) IsReservedWordContext

func (*ReservedWordContext) IsReservedWordContext()

func (*ReservedWordContext) Keyword

func (s *ReservedWordContext) Keyword() IKeywordContext

func (*ReservedWordContext) NullLiteral

func (s *ReservedWordContext) NullLiteral() antlr.TerminalNode

func (*ReservedWordContext) ToStringTree

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

type ReturnStatementContext

type ReturnStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReturnStatementContext

func NewEmptyReturnStatementContext() *ReturnStatementContext

func NewReturnStatementContext

func NewReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStatementContext

func (*ReturnStatementContext) Accept

func (s *ReturnStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ReturnStatementContext) Eos

func (s *ReturnStatementContext) Eos() IEosContext

func (*ReturnStatementContext) ExpressionSequence

func (s *ReturnStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ReturnStatementContext) GetParser

func (s *ReturnStatementContext) GetParser() antlr.Parser

func (*ReturnStatementContext) GetRuleContext

func (s *ReturnStatementContext) GetRuleContext() antlr.RuleContext

func (*ReturnStatementContext) IsReturnStatementContext

func (*ReturnStatementContext) IsReturnStatementContext()

func (*ReturnStatementContext) Return

func (s *ReturnStatementContext) Return() antlr.TerminalNode

func (*ReturnStatementContext) ToStringTree

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

type SetterContext

type SetterContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySetterContext

func NewEmptySetterContext() *SetterContext

func NewSetterContext

func NewSetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetterContext

func (*SetterContext) Accept

func (s *SetterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetterContext) ClassElementName

func (s *SetterContext) ClassElementName() IClassElementNameContext

func (*SetterContext) GetParser

func (s *SetterContext) GetParser() antlr.Parser

func (*SetterContext) GetRuleContext

func (s *SetterContext) GetRuleContext() antlr.RuleContext

func (*SetterContext) Identifier

func (s *SetterContext) Identifier() IIdentifierContext

func (*SetterContext) IsSetterContext

func (*SetterContext) IsSetterContext()

func (*SetterContext) ToStringTree

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

type SingleExpressionContext

type SingleExpressionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySingleExpressionContext

func NewEmptySingleExpressionContext() *SingleExpressionContext

func NewSingleExpressionContext

func NewSingleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleExpressionContext

func (*SingleExpressionContext) CopyAll

func (s *SingleExpressionContext) CopyAll(ctx *SingleExpressionContext)

func (*SingleExpressionContext) GetParser

func (s *SingleExpressionContext) GetParser() antlr.Parser

func (*SingleExpressionContext) GetRuleContext

func (s *SingleExpressionContext) GetRuleContext() antlr.RuleContext

func (*SingleExpressionContext) IsSingleExpressionContext

func (*SingleExpressionContext) IsSingleExpressionContext()

func (*SingleExpressionContext) ToStringTree

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

type SourceElementContext

type SourceElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySourceElementContext

func NewEmptySourceElementContext() *SourceElementContext

func NewSourceElementContext

func NewSourceElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SourceElementContext

func (*SourceElementContext) Accept

func (s *SourceElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SourceElementContext) GetParser

func (s *SourceElementContext) GetParser() antlr.Parser

func (*SourceElementContext) GetRuleContext

func (s *SourceElementContext) GetRuleContext() antlr.RuleContext

func (*SourceElementContext) IsSourceElementContext

func (*SourceElementContext) IsSourceElementContext()

func (*SourceElementContext) Statement

func (s *SourceElementContext) Statement() IStatementContext

func (*SourceElementContext) ToStringTree

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

type SourceElementsContext

type SourceElementsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySourceElementsContext

func NewEmptySourceElementsContext() *SourceElementsContext

func NewSourceElementsContext

func NewSourceElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SourceElementsContext

func (*SourceElementsContext) Accept

func (s *SourceElementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SourceElementsContext) AllSourceElement

func (s *SourceElementsContext) AllSourceElement() []ISourceElementContext

func (*SourceElementsContext) GetParser

func (s *SourceElementsContext) GetParser() antlr.Parser

func (*SourceElementsContext) GetRuleContext

func (s *SourceElementsContext) GetRuleContext() antlr.RuleContext

func (*SourceElementsContext) IsSourceElementsContext

func (*SourceElementsContext) IsSourceElementsContext()

func (*SourceElementsContext) SourceElement

func (s *SourceElementsContext) SourceElement(i int) ISourceElementContext

func (*SourceElementsContext) ToStringTree

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

type StatementContext

type StatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStatementContext

func NewEmptyStatementContext() *StatementContext

func NewStatementContext

func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext

func (*StatementContext) Accept

func (s *StatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StatementContext) Block

func (s *StatementContext) Block() IBlockContext

func (*StatementContext) BreakStatement

func (s *StatementContext) BreakStatement() IBreakStatementContext

func (*StatementContext) ClassDeclaration

func (s *StatementContext) ClassDeclaration() IClassDeclarationContext

func (*StatementContext) ContinueStatement

func (s *StatementContext) ContinueStatement() IContinueStatementContext

func (*StatementContext) DebuggerStatement

func (s *StatementContext) DebuggerStatement() IDebuggerStatementContext

func (*StatementContext) EmptyStatement_

func (s *StatementContext) EmptyStatement_() IEmptyStatement_Context

func (*StatementContext) ExportStatement

func (s *StatementContext) ExportStatement() IExportStatementContext

func (*StatementContext) ExpressionStatement

func (s *StatementContext) ExpressionStatement() IExpressionStatementContext

func (*StatementContext) FunctionDeclaration

func (s *StatementContext) FunctionDeclaration() IFunctionDeclarationContext

func (*StatementContext) GetParser

func (s *StatementContext) GetParser() antlr.Parser

func (*StatementContext) GetRuleContext

func (s *StatementContext) GetRuleContext() antlr.RuleContext

func (*StatementContext) IfStatement

func (s *StatementContext) IfStatement() IIfStatementContext

func (*StatementContext) ImportStatement

func (s *StatementContext) ImportStatement() IImportStatementContext

func (*StatementContext) IsStatementContext

func (*StatementContext) IsStatementContext()

func (*StatementContext) IterationStatement

func (s *StatementContext) IterationStatement() IIterationStatementContext

func (*StatementContext) LabelledStatement

func (s *StatementContext) LabelledStatement() ILabelledStatementContext

func (*StatementContext) ReturnStatement

func (s *StatementContext) ReturnStatement() IReturnStatementContext

func (*StatementContext) SwitchStatement

func (s *StatementContext) SwitchStatement() ISwitchStatementContext

func (*StatementContext) ThrowStatement

func (s *StatementContext) ThrowStatement() IThrowStatementContext

func (*StatementContext) ToStringTree

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

func (*StatementContext) TryStatement

func (s *StatementContext) TryStatement() ITryStatementContext

func (*StatementContext) VariableStatement

func (s *StatementContext) VariableStatement() IVariableStatementContext

func (*StatementContext) WithStatement

func (s *StatementContext) WithStatement() IWithStatementContext

func (*StatementContext) YieldStatement

func (s *StatementContext) YieldStatement() IYieldStatementContext

type StatementListContext

type StatementListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStatementListContext

func NewEmptyStatementListContext() *StatementListContext

func NewStatementListContext

func NewStatementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementListContext

func (*StatementListContext) Accept

func (s *StatementListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StatementListContext) AllStatement

func (s *StatementListContext) AllStatement() []IStatementContext

func (*StatementListContext) GetParser

func (s *StatementListContext) GetParser() antlr.Parser

func (*StatementListContext) GetRuleContext

func (s *StatementListContext) GetRuleContext() antlr.RuleContext

func (*StatementListContext) IsStatementListContext

func (*StatementListContext) IsStatementListContext()

func (*StatementListContext) Statement

func (s *StatementListContext) Statement(i int) IStatementContext

func (*StatementListContext) ToStringTree

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

type SuperExpressionContext

type SuperExpressionContext struct {
	SingleExpressionContext
}

func NewSuperExpressionContext

func NewSuperExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SuperExpressionContext

func (*SuperExpressionContext) Accept

func (s *SuperExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SuperExpressionContext) GetRuleContext

func (s *SuperExpressionContext) GetRuleContext() antlr.RuleContext

func (*SuperExpressionContext) Super

func (s *SuperExpressionContext) Super() antlr.TerminalNode

type SwitchStatementContext

type SwitchStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySwitchStatementContext

func NewEmptySwitchStatementContext() *SwitchStatementContext

func NewSwitchStatementContext

func NewSwitchStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchStatementContext

func (*SwitchStatementContext) Accept

func (s *SwitchStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SwitchStatementContext) CaseBlock

func (s *SwitchStatementContext) CaseBlock() ICaseBlockContext

func (*SwitchStatementContext) CloseParen

func (s *SwitchStatementContext) CloseParen() antlr.TerminalNode

func (*SwitchStatementContext) GetParser

func (s *SwitchStatementContext) GetParser() antlr.Parser

func (*SwitchStatementContext) GetRuleContext

func (s *SwitchStatementContext) GetRuleContext() antlr.RuleContext

func (*SwitchStatementContext) IsSwitchStatementContext

func (*SwitchStatementContext) IsSwitchStatementContext()

func (*SwitchStatementContext) OpenParen

func (s *SwitchStatementContext) OpenParen() antlr.TerminalNode

func (*SwitchStatementContext) SingleExpression

func (s *SwitchStatementContext) SingleExpression() ISingleExpressionContext

func (*SwitchStatementContext) Switch

func (s *SwitchStatementContext) Switch() antlr.TerminalNode

func (*SwitchStatementContext) ToStringTree

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

type TemplateStringAtomContext

type TemplateStringAtomContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTemplateStringAtomContext

func NewEmptyTemplateStringAtomContext() *TemplateStringAtomContext

func NewTemplateStringAtomContext

func NewTemplateStringAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemplateStringAtomContext

func (*TemplateStringAtomContext) Accept

func (s *TemplateStringAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TemplateStringAtomContext) GetParser

func (s *TemplateStringAtomContext) GetParser() antlr.Parser

func (*TemplateStringAtomContext) GetRuleContext

func (s *TemplateStringAtomContext) GetRuleContext() antlr.RuleContext

func (*TemplateStringAtomContext) IsTemplateStringAtomContext

func (*TemplateStringAtomContext) IsTemplateStringAtomContext()

func (*TemplateStringAtomContext) SingleExpression

func (s *TemplateStringAtomContext) SingleExpression() ISingleExpressionContext

func (*TemplateStringAtomContext) TemplateCloseBrace

func (s *TemplateStringAtomContext) TemplateCloseBrace() antlr.TerminalNode

func (*TemplateStringAtomContext) TemplateStringAtom

func (s *TemplateStringAtomContext) TemplateStringAtom() antlr.TerminalNode

func (*TemplateStringAtomContext) TemplateStringStartExpression

func (s *TemplateStringAtomContext) TemplateStringStartExpression() antlr.TerminalNode

func (*TemplateStringAtomContext) ToStringTree

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

type TemplateStringExpressionContext

type TemplateStringExpressionContext struct {
	SingleExpressionContext
}

func NewTemplateStringExpressionContext

func NewTemplateStringExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TemplateStringExpressionContext

func (*TemplateStringExpressionContext) Accept

func (s *TemplateStringExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TemplateStringExpressionContext) GetRuleContext

func (s *TemplateStringExpressionContext) GetRuleContext() antlr.RuleContext

func (*TemplateStringExpressionContext) SingleExpression

func (s *TemplateStringExpressionContext) SingleExpression() ISingleExpressionContext

func (*TemplateStringExpressionContext) TemplateStringLiteral

func (s *TemplateStringExpressionContext) TemplateStringLiteral() ITemplateStringLiteralContext

type TemplateStringLiteralContext

type TemplateStringLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTemplateStringLiteralContext

func NewEmptyTemplateStringLiteralContext() *TemplateStringLiteralContext

func NewTemplateStringLiteralContext

func NewTemplateStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemplateStringLiteralContext

func (*TemplateStringLiteralContext) Accept

func (s *TemplateStringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TemplateStringLiteralContext) AllBackTick

func (s *TemplateStringLiteralContext) AllBackTick() []antlr.TerminalNode

func (*TemplateStringLiteralContext) AllTemplateStringAtom

func (s *TemplateStringLiteralContext) AllTemplateStringAtom() []ITemplateStringAtomContext

func (*TemplateStringLiteralContext) BackTick

func (s *TemplateStringLiteralContext) BackTick(i int) antlr.TerminalNode

func (*TemplateStringLiteralContext) GetParser

func (s *TemplateStringLiteralContext) GetParser() antlr.Parser

func (*TemplateStringLiteralContext) GetRuleContext

func (s *TemplateStringLiteralContext) GetRuleContext() antlr.RuleContext

func (*TemplateStringLiteralContext) IsTemplateStringLiteralContext

func (*TemplateStringLiteralContext) IsTemplateStringLiteralContext()

func (*TemplateStringLiteralContext) TemplateStringAtom

func (s *TemplateStringLiteralContext) TemplateStringAtom(i int) ITemplateStringAtomContext

func (*TemplateStringLiteralContext) ToStringTree

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

type TernaryExpressionContext

type TernaryExpressionContext struct {
	SingleExpressionContext
}

func NewTernaryExpressionContext

func NewTernaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TernaryExpressionContext

func (*TernaryExpressionContext) Accept

func (s *TernaryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TernaryExpressionContext) AllSingleExpression

func (s *TernaryExpressionContext) AllSingleExpression() []ISingleExpressionContext

func (*TernaryExpressionContext) Colon

func (s *TernaryExpressionContext) Colon() antlr.TerminalNode

func (*TernaryExpressionContext) GetRuleContext

func (s *TernaryExpressionContext) GetRuleContext() antlr.RuleContext

func (*TernaryExpressionContext) QuestionMark

func (s *TernaryExpressionContext) QuestionMark() antlr.TerminalNode

func (*TernaryExpressionContext) SingleExpression

func (s *TernaryExpressionContext) SingleExpression(i int) ISingleExpressionContext

type ThisExpressionContext

type ThisExpressionContext struct {
	SingleExpressionContext
}

func NewThisExpressionContext

func NewThisExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ThisExpressionContext

func (*ThisExpressionContext) Accept

func (s *ThisExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ThisExpressionContext) GetRuleContext

func (s *ThisExpressionContext) GetRuleContext() antlr.RuleContext

func (*ThisExpressionContext) This

func (s *ThisExpressionContext) This() antlr.TerminalNode

type ThrowStatementContext

type ThrowStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyThrowStatementContext

func NewEmptyThrowStatementContext() *ThrowStatementContext

func NewThrowStatementContext

func NewThrowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThrowStatementContext

func (*ThrowStatementContext) Accept

func (s *ThrowStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ThrowStatementContext) Eos

func (s *ThrowStatementContext) Eos() IEosContext

func (*ThrowStatementContext) ExpressionSequence

func (s *ThrowStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*ThrowStatementContext) GetParser

func (s *ThrowStatementContext) GetParser() antlr.Parser

func (*ThrowStatementContext) GetRuleContext

func (s *ThrowStatementContext) GetRuleContext() antlr.RuleContext

func (*ThrowStatementContext) IsThrowStatementContext

func (*ThrowStatementContext) IsThrowStatementContext()

func (*ThrowStatementContext) Throw

func (s *ThrowStatementContext) Throw() antlr.TerminalNode

func (*ThrowStatementContext) ToStringTree

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

type TryStatementContext

type TryStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTryStatementContext

func NewEmptyTryStatementContext() *TryStatementContext

func NewTryStatementContext

func NewTryStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TryStatementContext

func (*TryStatementContext) Accept

func (s *TryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TryStatementContext) Block

func (s *TryStatementContext) Block() IBlockContext

func (*TryStatementContext) CatchProduction

func (s *TryStatementContext) CatchProduction() ICatchProductionContext

func (*TryStatementContext) FinallyProduction

func (s *TryStatementContext) FinallyProduction() IFinallyProductionContext

func (*TryStatementContext) GetParser

func (s *TryStatementContext) GetParser() antlr.Parser

func (*TryStatementContext) GetRuleContext

func (s *TryStatementContext) GetRuleContext() antlr.RuleContext

func (*TryStatementContext) IsTryStatementContext

func (*TryStatementContext) IsTryStatementContext()

func (*TryStatementContext) ToStringTree

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

func (*TryStatementContext) Try

func (s *TryStatementContext) Try() antlr.TerminalNode

type TypeofExpressionContext

type TypeofExpressionContext struct {
	SingleExpressionContext
}

func NewTypeofExpressionContext

func NewTypeofExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeofExpressionContext

func (*TypeofExpressionContext) Accept

func (s *TypeofExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TypeofExpressionContext) GetRuleContext

func (s *TypeofExpressionContext) GetRuleContext() antlr.RuleContext

func (*TypeofExpressionContext) SingleExpression

func (s *TypeofExpressionContext) SingleExpression() ISingleExpressionContext

func (*TypeofExpressionContext) Typeof

func (s *TypeofExpressionContext) Typeof() antlr.TerminalNode

type UnaryMinusExpressionContext

type UnaryMinusExpressionContext struct {
	SingleExpressionContext
}

func NewUnaryMinusExpressionContext

func NewUnaryMinusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryMinusExpressionContext

func (*UnaryMinusExpressionContext) Accept

func (s *UnaryMinusExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UnaryMinusExpressionContext) GetRuleContext

func (s *UnaryMinusExpressionContext) GetRuleContext() antlr.RuleContext

func (*UnaryMinusExpressionContext) Minus

func (s *UnaryMinusExpressionContext) Minus() antlr.TerminalNode

func (*UnaryMinusExpressionContext) SingleExpression

func (s *UnaryMinusExpressionContext) SingleExpression() ISingleExpressionContext

type UnaryPlusExpressionContext

type UnaryPlusExpressionContext struct {
	SingleExpressionContext
}

func NewUnaryPlusExpressionContext

func NewUnaryPlusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryPlusExpressionContext

func (*UnaryPlusExpressionContext) Accept

func (s *UnaryPlusExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UnaryPlusExpressionContext) GetRuleContext

func (s *UnaryPlusExpressionContext) GetRuleContext() antlr.RuleContext

func (*UnaryPlusExpressionContext) Plus

func (s *UnaryPlusExpressionContext) Plus() antlr.TerminalNode

func (*UnaryPlusExpressionContext) SingleExpression

func (s *UnaryPlusExpressionContext) SingleExpression() ISingleExpressionContext

type VarModifierContext

type VarModifierContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVarModifierContext

func NewEmptyVarModifierContext() *VarModifierContext

func NewVarModifierContext

func NewVarModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VarModifierContext

func (*VarModifierContext) Accept

func (s *VarModifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VarModifierContext) Const

func (s *VarModifierContext) Const() antlr.TerminalNode

func (*VarModifierContext) GetParser

func (s *VarModifierContext) GetParser() antlr.Parser

func (*VarModifierContext) GetRuleContext

func (s *VarModifierContext) GetRuleContext() antlr.RuleContext

func (*VarModifierContext) IsVarModifierContext

func (*VarModifierContext) IsVarModifierContext()

func (*VarModifierContext) Let_

func (s *VarModifierContext) Let_() ILet_Context

func (*VarModifierContext) ToStringTree

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

func (*VarModifierContext) Var

func (s *VarModifierContext) Var() antlr.TerminalNode

type VariableDeclarationContext

type VariableDeclarationContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVariableDeclarationContext

func NewEmptyVariableDeclarationContext() *VariableDeclarationContext

func NewVariableDeclarationContext

func NewVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationContext

func (*VariableDeclarationContext) Accept

func (s *VariableDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VariableDeclarationContext) Assign

func (s *VariableDeclarationContext) Assign() antlr.TerminalNode

func (*VariableDeclarationContext) Assignable

func (s *VariableDeclarationContext) Assignable() IAssignableContext

func (*VariableDeclarationContext) GetParser

func (s *VariableDeclarationContext) GetParser() antlr.Parser

func (*VariableDeclarationContext) GetRuleContext

func (s *VariableDeclarationContext) GetRuleContext() antlr.RuleContext

func (*VariableDeclarationContext) IsVariableDeclarationContext

func (*VariableDeclarationContext) IsVariableDeclarationContext()

func (*VariableDeclarationContext) SingleExpression

func (s *VariableDeclarationContext) SingleExpression() ISingleExpressionContext

func (*VariableDeclarationContext) ToStringTree

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

type VariableDeclarationListContext

type VariableDeclarationListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVariableDeclarationListContext

func NewEmptyVariableDeclarationListContext() *VariableDeclarationListContext

func NewVariableDeclarationListContext

func NewVariableDeclarationListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationListContext

func (*VariableDeclarationListContext) Accept

func (s *VariableDeclarationListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VariableDeclarationListContext) AllComma

func (s *VariableDeclarationListContext) AllComma() []antlr.TerminalNode

func (*VariableDeclarationListContext) AllVariableDeclaration

func (s *VariableDeclarationListContext) AllVariableDeclaration() []IVariableDeclarationContext

func (*VariableDeclarationListContext) Comma

func (s *VariableDeclarationListContext) Comma(i int) antlr.TerminalNode

func (*VariableDeclarationListContext) GetParser

func (s *VariableDeclarationListContext) GetParser() antlr.Parser

func (*VariableDeclarationListContext) GetRuleContext

func (s *VariableDeclarationListContext) GetRuleContext() antlr.RuleContext

func (*VariableDeclarationListContext) IsVariableDeclarationListContext

func (*VariableDeclarationListContext) IsVariableDeclarationListContext()

func (*VariableDeclarationListContext) ToStringTree

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

func (*VariableDeclarationListContext) VarModifier

func (s *VariableDeclarationListContext) VarModifier() IVarModifierContext

func (*VariableDeclarationListContext) VariableDeclaration

func (s *VariableDeclarationListContext) VariableDeclaration(i int) IVariableDeclarationContext

type VariableStatementContext

type VariableStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVariableStatementContext

func NewEmptyVariableStatementContext() *VariableStatementContext

func NewVariableStatementContext

func NewVariableStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableStatementContext

func (*VariableStatementContext) Accept

func (s *VariableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VariableStatementContext) Eos

func (s *VariableStatementContext) Eos() IEosContext

func (*VariableStatementContext) GetParser

func (s *VariableStatementContext) GetParser() antlr.Parser

func (*VariableStatementContext) GetRuleContext

func (s *VariableStatementContext) GetRuleContext() antlr.RuleContext

func (*VariableStatementContext) IsVariableStatementContext

func (*VariableStatementContext) IsVariableStatementContext()

func (*VariableStatementContext) ToStringTree

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

func (*VariableStatementContext) VariableDeclarationList

func (s *VariableStatementContext) VariableDeclarationList() IVariableDeclarationListContext

type VoidExpressionContext

type VoidExpressionContext struct {
	SingleExpressionContext
}

func NewVoidExpressionContext

func NewVoidExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VoidExpressionContext

func (*VoidExpressionContext) Accept

func (s *VoidExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VoidExpressionContext) GetRuleContext

func (s *VoidExpressionContext) GetRuleContext() antlr.RuleContext

func (*VoidExpressionContext) SingleExpression

func (s *VoidExpressionContext) SingleExpression() ISingleExpressionContext

func (*VoidExpressionContext) Void

func (s *VoidExpressionContext) Void() antlr.TerminalNode

type WhileStatementContext

type WhileStatementContext struct {
	IterationStatementContext
}

func NewWhileStatementContext

func NewWhileStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhileStatementContext

func (*WhileStatementContext) Accept

func (s *WhileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*WhileStatementContext) CloseParen

func (s *WhileStatementContext) CloseParen() antlr.TerminalNode

func (*WhileStatementContext) GetRuleContext

func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext

func (*WhileStatementContext) OpenParen

func (s *WhileStatementContext) OpenParen() antlr.TerminalNode

func (*WhileStatementContext) SingleExpression

func (s *WhileStatementContext) SingleExpression() ISingleExpressionContext

func (*WhileStatementContext) Statement

func (s *WhileStatementContext) Statement() IStatementContext

func (*WhileStatementContext) While

func (s *WhileStatementContext) While() antlr.TerminalNode

type WithStatementContext

type WithStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWithStatementContext

func NewEmptyWithStatementContext() *WithStatementContext

func NewWithStatementContext

func NewWithStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithStatementContext

func (*WithStatementContext) Accept

func (s *WithStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*WithStatementContext) CloseParen

func (s *WithStatementContext) CloseParen() antlr.TerminalNode

func (*WithStatementContext) ExpressionSequence

func (s *WithStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*WithStatementContext) GetParser

func (s *WithStatementContext) GetParser() antlr.Parser

func (*WithStatementContext) GetRuleContext

func (s *WithStatementContext) GetRuleContext() antlr.RuleContext

func (*WithStatementContext) IsWithStatementContext

func (*WithStatementContext) IsWithStatementContext()

func (*WithStatementContext) OpenParen

func (s *WithStatementContext) OpenParen() antlr.TerminalNode

func (*WithStatementContext) Statement

func (s *WithStatementContext) Statement() IStatementContext

func (*WithStatementContext) ToStringTree

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

func (*WithStatementContext) With

func (s *WithStatementContext) With() antlr.TerminalNode

type YieldExpressionContext

type YieldExpressionContext struct {
	SingleExpressionContext
}

func NewYieldExpressionContext

func NewYieldExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *YieldExpressionContext

func (*YieldExpressionContext) Accept

func (s *YieldExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*YieldExpressionContext) GetRuleContext

func (s *YieldExpressionContext) GetRuleContext() antlr.RuleContext

func (*YieldExpressionContext) YieldStatement

func (s *YieldExpressionContext) YieldStatement() IYieldStatementContext

type YieldStatementContext

type YieldStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyYieldStatementContext

func NewEmptyYieldStatementContext() *YieldStatementContext

func NewYieldStatementContext

func NewYieldStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *YieldStatementContext

func (*YieldStatementContext) Accept

func (s *YieldStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*YieldStatementContext) Eos

func (s *YieldStatementContext) Eos() IEosContext

func (*YieldStatementContext) ExpressionSequence

func (s *YieldStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*YieldStatementContext) GetParser

func (s *YieldStatementContext) GetParser() antlr.Parser

func (*YieldStatementContext) GetRuleContext

func (s *YieldStatementContext) GetRuleContext() antlr.RuleContext

func (*YieldStatementContext) IsYieldStatementContext

func (*YieldStatementContext) IsYieldStatementContext()

func (*YieldStatementContext) ToStringTree

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

func (*YieldStatementContext) Yield

func (s *YieldStatementContext) Yield() antlr.TerminalNode