JS

Documentation

Index

• Constants
• Variables
• 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) GetOp() antlr.Token
  • func (s *AdditiveExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *AdditiveExpressionContext) Minus() antlr.TerminalNode
  • func (s *AdditiveExpressionContext) Plus() antlr.TerminalNode
  • func (s *AdditiveExpressionContext) SetOp(v antlr.Token)
  • 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) CopyFrom(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) Identifier() IIdentifierContext
  • 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 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) Assign() antlr.TerminalNode
  • 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) 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) VisitBitExpression(ctx *BitExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitBitShiftExpression(ctx *BitShiftExpressionContext) 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) VisitChainExpression(ctx *ChainExpressionContext) 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) 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) VisitEqExpression(ctx *EqExpressionContext) 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) 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) VisitInitializer(ctx *InitializerContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitKeywordExpression(ctx *KeywordExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLabelledStatement(ctx *LabelledStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitLastFormalParameterArg(ctx *LastFormalParameterArgContext) 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) 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) 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) VisitOptionalChainMember(ctx *OptionalChainMemberContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPostUnaryExpression(ctx *PostUnaryExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPowerExpression(ctx *PowerExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPreUnaryExpression(ctx *PreUnaryExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitPreUnaryOperator(ctx *PreUnaryOperatorContext) 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) VisitQuestionDot(ctx *QuestionDotContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitRelationalExpression(ctx *RelationalExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitReturnStatement(ctx *ReturnStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitSetter(ctx *SetterContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitSpecificExpression(ctx *SpecificExpressionContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitStatement(ctx *StatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitStatements(ctx *StatementsContext) 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) VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitVariableDeclarationList(ctx *VariableDeclarationListContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitVariableStatement(ctx *VariableStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitWhileStatement(ctx *WhileStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitWithStatement(ctx *WithStatementContext) interface{}
  • func (v *BaseJavaScriptParserVisitor) VisitWord(ctx *WordContext) 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 BitExpressionContext
  • func NewBitExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitExpressionContext
  • func (s *BitExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *BitExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *BitExpressionContext) BitAnd() antlr.TerminalNode
  • func (s *BitExpressionContext) BitOr() antlr.TerminalNode
  • func (s *BitExpressionContext) BitXOr() antlr.TerminalNode
  • func (s *BitExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *BitExpressionContext) 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) GetOp() antlr.Token
  • 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) SetOp(v antlr.Token)
  • func (s *BitShiftExpressionContext) 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) Statements() IStatementsContext
  • 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) ExpressionSequence() IExpressionSequenceContext
  • func (s *CaseClauseContext) GetParser() antlr.Parser
  • func (s *CaseClauseContext) GetRuleContext() antlr.RuleContext
  • func (*CaseClauseContext) IsCaseClauseContext()
  • func (s *CaseClauseContext) Statements() IStatementsContext
  • 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 ChainExpressionContext
  • func NewChainExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ChainExpressionContext
  • func (s *ChainExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ChainExpressionContext) Dot() antlr.TerminalNode
  • func (s *ChainExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *ChainExpressionContext) Hashtag() antlr.TerminalNode
  • func (s *ChainExpressionContext) IdentifierName() IIdentifierNameContext
  • func (s *ChainExpressionContext) SingleExpression() ISingleExpressionContext
• 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) FieldDefinition() IFieldDefinitionContext
  • func (s *ClassElementContext) GetParser() antlr.Parser
  • func (s *ClassElementContext) GetRuleContext() antlr.RuleContext
  • func (*ClassElementContext) IsClassElementContext()
  • func (s *ClassElementContext) MethodDefinition() IMethodDefinitionContext
  • func (s *ClassElementContext) SemiColon() antlr.TerminalNode
  • 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) Statements() IStatementsContext
  • func (s *DefaultClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• 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) ExpressionSequence() IExpressionSequenceContext
  • func (s *DoStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *DoStatementContext) OpenParen() antlr.TerminalNode
  • 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 EqExpressionContext
  • func NewEqExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqExpressionContext
  • func (s *EqExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *EqExpressionContext) AllSingleExpression() []ISingleExpressionContext
  • func (s *EqExpressionContext) Equals_() antlr.TerminalNode
  • func (s *EqExpressionContext) GetOp() antlr.Token
  • func (s *EqExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *EqExpressionContext) IdentityEquals() antlr.TerminalNode
  • func (s *EqExpressionContext) IdentityNotEquals() antlr.TerminalNode
  • func (s *EqExpressionContext) NotEquals() antlr.TerminalNode
  • func (s *EqExpressionContext) SetOp(v antlr.Token)
  • func (s *EqExpressionContext) 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) CopyFrom(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 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) ExpressionSequence() IExpressionSequenceContext
  • func (s *ForFirstContext) GetParser() antlr.Parser
  • func (s *ForFirstContext) GetRuleContext() antlr.RuleContext
  • func (*ForFirstContext) IsForFirstContext()
  • 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) CloseParen() antlr.TerminalNode
  • func (s *ForInStatementContext) ExpressionSequence() IExpressionSequenceContext
  • 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() ISingleExpressionContext
  • func (s *ForInStatementContext) Statement() IStatementContext
  • func (s *ForInStatementContext) VariableDeclarationList() IVariableDeclarationListContext
• type ForOfStatementContext
  • func NewForOfStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForOfStatementContext
  • func (s *ForOfStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *ForOfStatementContext) Await() antlr.TerminalNode
  • func (s *ForOfStatementContext) CloseParen() antlr.TerminalNode
  • func (s *ForOfStatementContext) ExpressionSequence() IExpressionSequenceContext
  • 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() ISingleExpressionContext
  • func (s *ForOfStatementContext) Statement() IStatementContext
  • func (s *ForOfStatementContext) VariableDeclarationList() IVariableDeclarationListContext
• 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) ExpressionSequence() IExpressionSequenceContext
  • func (s *ForSecondContext) GetParser() antlr.Parser
  • func (s *ForSecondContext) GetRuleContext() antlr.RuleContext
  • func (*ForSecondContext) IsForSecondContext()
  • 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) ExpressionSequence() IExpressionSequenceContext
  • func (s *ForThirdContext) GetParser() antlr.Parser
  • func (s *ForThirdContext) GetRuleContext() antlr.RuleContext
  • func (*ForThirdContext) IsForThirdContext()
  • 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) Statements() IStatementsContext
  • 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) Get() antlr.TerminalNode
  • func (s *GetterContext) GetParser() antlr.Parser
  • func (s *GetterContext) GetRuleContext() antlr.RuleContext
  • 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 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 IKeywordSingleExpressionContext
• type ILabelledStatementContext
• type ILastFormalParameterArgContext
• type ILiteralContext
• type IMethodDefinitionContext
• type IModuleExportNameContext
• type INumericLiteralContext
• type IObjectLiteralContext
• type IOptionalChainMemberContext
• type IPreUnaryOperatorContext
• type IPrivateIdentifierContext
• type IProgramContext
• type IPropertyAssignmentContext
• type IPropertyNameContext
• type IQuestionDotContext
• type IReturnStatementContext
• type ISetterContext
• type ISingleExpressionContext
• type ISpecificExpressionContext
• type IStatementContext
• type IStatementsContext
• type ISwitchStatementContext
• type ITemplateStringAtomContext
• type ITemplateStringLiteralContext
• type IThrowStatementContext
• type ITryStatementContext
• type IVariableDeclarationContext
• type IVariableDeclarationListContext
• type IVariableStatementContext
• type IWithStatementContext
• type IWordContext
• 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) Get() 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) Set() antlr.TerminalNode
  • func (s *IdentifierContext) Static() 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) BooleanLiteral() antlr.TerminalNode
  • func (s *IdentifierNameContext) GetParser() antlr.Parser
  • func (s *IdentifierNameContext) GetRuleContext() antlr.RuleContext
  • func (s *IdentifierNameContext) Identifier() IIdentifierContext
  • func (*IdentifierNameContext) IsIdentifierNameContext()
  • func (s *IdentifierNameContext) NullLiteral() antlr.TerminalNode
  • func (s *IdentifierNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *IdentifierNameContext) Word() IWordContext
• 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) AllExpressionSequence() []IExpressionSequenceContext
  • func (s *IfStatementContext) AllIf() []antlr.TerminalNode
  • func (s *IfStatementContext) AllOpenParen() []antlr.TerminalNode
  • 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) ExpressionSequence(i int) IExpressionSequenceContext
  • 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) 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 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 IterationStatementContext
  • func NewEmptyIterationStatementContext() *IterationStatementContext
  • func NewIterationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterationStatementContext
  • func (s *IterationStatementContext) CopyFrom(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 (l *JavaScriptLexer) HashBangLine_Action(localctx antlr.RuleContext, actionIndex int)
  • 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) 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) 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) 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) KeywordSingleExpression() (localctx IKeywordSingleExpressionContext)
  • func (p *JavaScriptParser) LabelledStatement() (localctx ILabelledStatementContext)
  • func (p *JavaScriptParser) LastFormalParameterArg() (localctx ILastFormalParameterArgContext)
  • 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) OptionalChainMember() (localctx IOptionalChainMemberContext)
  • func (p *JavaScriptParser) PreUnaryOperator() (localctx IPreUnaryOperatorContext)
  • 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) QuestionDot() (localctx IQuestionDotContext)
  • 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) SingleExpression() (localctx ISingleExpressionContext)
  • func (p *JavaScriptParser) SingleExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool
  • func (p *JavaScriptParser) SpecificExpression() (localctx ISpecificExpressionContext)
  • func (p *JavaScriptParser) Statement() (localctx IStatementContext)
  • func (p *JavaScriptParser) Statements() (localctx IStatementsContext)
  • 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) VariableDeclaration() (localctx IVariableDeclarationContext)
  • func (p *JavaScriptParser) VariableDeclarationList() (localctx IVariableDeclarationListContext)
  • func (p *JavaScriptParser) VariableStatement() (localctx IVariableStatementContext)
  • func (p *JavaScriptParser) WithStatement() (localctx IWithStatementContext)
  • func (p *JavaScriptParser) Word() (localctx IWordContext)
  • func (p *JavaScriptParser) YieldStatement() (localctx IYieldStatementContext)
  • func (p *JavaScriptParser) YieldStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool
• type JavaScriptParserBase
• type JavaScriptParserVisitor
• type KeywordExpressionContext
  • func NewKeywordExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KeywordExpressionContext
  • func (s *KeywordExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *KeywordExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *KeywordExpressionContext) KeywordSingleExpression() IKeywordSingleExpressionContext
• type KeywordSingleExpressionContext
  • func NewEmptyKeywordSingleExpressionContext() *KeywordSingleExpressionContext
  • func NewKeywordSingleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordSingleExpressionContext
  • func (s *KeywordSingleExpressionContext) CopyFrom(ctx *KeywordSingleExpressionContext)
  • func (s *KeywordSingleExpressionContext) GetParser() antlr.Parser
  • func (s *KeywordSingleExpressionContext) GetRuleContext() antlr.RuleContext
  • func (*KeywordSingleExpressionContext) IsKeywordSingleExpressionContext()
  • func (s *KeywordSingleExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• 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 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 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) 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) GetOp() antlr.Token
  • func (s *MultiplicativeExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *MultiplicativeExpressionContext) Modulus() antlr.TerminalNode
  • func (s *MultiplicativeExpressionContext) Multiply() antlr.TerminalNode
  • func (s *MultiplicativeExpressionContext) SetOp(v antlr.Token)
  • 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 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) GetRuleContext() antlr.RuleContext
  • func (s *OptionalChainExpressionContext) OptionalChainMember() IOptionalChainMemberContext
  • func (s *OptionalChainExpressionContext) QuestionDot() IQuestionDotContext
  • func (s *OptionalChainExpressionContext) SingleExpression() ISingleExpressionContext
• type OptionalChainMemberContext
  • func NewEmptyOptionalChainMemberContext() *OptionalChainMemberContext
  • func NewOptionalChainMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionalChainMemberContext
  • func (s *OptionalChainMemberContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *OptionalChainMemberContext) CloseBracket() antlr.TerminalNode
  • func (s *OptionalChainMemberContext) GetParser() antlr.Parser
  • func (s *OptionalChainMemberContext) GetRuleContext() antlr.RuleContext
  • func (s *OptionalChainMemberContext) Hashtag() antlr.TerminalNode
  • func (s *OptionalChainMemberContext) IdentifierName() IIdentifierNameContext
  • func (*OptionalChainMemberContext) IsOptionalChainMemberContext()
  • func (s *OptionalChainMemberContext) OpenBracket() antlr.TerminalNode
  • func (s *OptionalChainMemberContext) SingleExpression() ISingleExpressionContext
  • func (s *OptionalChainMemberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• 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 PostUnaryExpressionContext
  • func NewPostUnaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostUnaryExpressionContext
  • func (s *PostUnaryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PostUnaryExpressionContext) GetOp() antlr.Token
  • func (s *PostUnaryExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *PostUnaryExpressionContext) MinusMinus() antlr.TerminalNode
  • func (s *PostUnaryExpressionContext) PlusPlus() antlr.TerminalNode
  • func (s *PostUnaryExpressionContext) SetOp(v antlr.Token)
  • func (s *PostUnaryExpressionContext) 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 PreUnaryExpressionContext
  • func NewPreUnaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreUnaryExpressionContext
  • func (s *PreUnaryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PreUnaryExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *PreUnaryExpressionContext) PreUnaryOperator() IPreUnaryOperatorContext
  • func (s *PreUnaryExpressionContext) SingleExpression() ISingleExpressionContext
• type PreUnaryOperatorContext
  • func NewEmptyPreUnaryOperatorContext() *PreUnaryOperatorContext
  • func NewPreUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreUnaryOperatorContext
  • func (s *PreUnaryOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *PreUnaryOperatorContext) BitNot() antlr.TerminalNode
  • func (s *PreUnaryOperatorContext) Delete() antlr.TerminalNode
  • func (s *PreUnaryOperatorContext) GetParser() antlr.Parser
  • func (s *PreUnaryOperatorContext) GetRuleContext() antlr.RuleContext
  • func (*PreUnaryOperatorContext) IsPreUnaryOperatorContext()
  • func (s *PreUnaryOperatorContext) Minus() antlr.TerminalNode
  • func (s *PreUnaryOperatorContext) MinusMinus() antlr.TerminalNode
  • func (s *PreUnaryOperatorContext) Not() antlr.TerminalNode
  • func (s *PreUnaryOperatorContext) Plus() antlr.TerminalNode
  • func (s *PreUnaryOperatorContext) PlusPlus() antlr.TerminalNode
  • func (s *PreUnaryOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *PreUnaryOperatorContext) Typeof() antlr.TerminalNode
  • func (s *PreUnaryOperatorContext) Void() antlr.TerminalNode
• 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) Statements() IStatementsContext
  • 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) CopyFrom(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 QuestionDotContext
  • func NewEmptyQuestionDotContext() *QuestionDotContext
  • func NewQuestionDotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuestionDotContext
  • func (s *QuestionDotContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *QuestionDotContext) Dot() antlr.TerminalNode
  • func (s *QuestionDotContext) GetParser() antlr.Parser
  • func (s *QuestionDotContext) GetRuleContext() antlr.RuleContext
  • func (*QuestionDotContext) IsQuestionDotContext()
  • func (s *QuestionDotContext) QuestionMark() antlr.TerminalNode
  • func (s *QuestionDotContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
• 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) GetOp() antlr.Token
  • func (s *RelationalExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *RelationalExpressionContext) GreaterThanEquals() antlr.TerminalNode
  • func (s *RelationalExpressionContext) In() antlr.TerminalNode
  • func (s *RelationalExpressionContext) Instanceof() antlr.TerminalNode
  • func (s *RelationalExpressionContext) LessThan() antlr.TerminalNode
  • func (s *RelationalExpressionContext) LessThanEquals() antlr.TerminalNode
  • func (s *RelationalExpressionContext) MoreThan() antlr.TerminalNode
  • func (s *RelationalExpressionContext) SetOp(v antlr.Token)
  • func (s *RelationalExpressionContext) SingleExpression(i int) ISingleExpressionContext
• 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 (*SetterContext) IsSetterContext()
  • func (s *SetterContext) Set() antlr.TerminalNode
  • 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) CopyFrom(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 SpecificExpressionContext
  • func NewEmptySpecificExpressionContext() *SpecificExpressionContext
  • func NewSpecificExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SpecificExpressionContext
  • func (s *SpecificExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *SpecificExpressionContext) Arguments() IArgumentsContext
  • func (s *SpecificExpressionContext) GetParser() antlr.Parser
  • func (s *SpecificExpressionContext) GetRuleContext() antlr.RuleContext
  • func (s *SpecificExpressionContext) IdentifierName() IIdentifierNameContext
  • func (*SpecificExpressionContext) IsSpecificExpressionContext()
  • func (s *SpecificExpressionContext) TemplateStringLiteral() ITemplateStringLiteralContext
  • func (s *SpecificExpressionContext) 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) Eos() IEosContext
  • func (s *StatementContext) ExportStatement() IExportStatementContext
  • func (s *StatementContext) ExpressionSequence() IExpressionSequenceContext
  • 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) SemiColon() antlr.TerminalNode
  • 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 StatementsContext
  • func NewEmptyStatementsContext() *StatementsContext
  • func NewStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementsContext
  • func (s *StatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *StatementsContext) AllStatement() []IStatementContext
  • func (s *StatementsContext) GetParser() antlr.Parser
  • func (s *StatementsContext) GetRuleContext() antlr.RuleContext
  • func (*StatementsContext) IsStatementsContext()
  • func (s *StatementsContext) Statement(i int) IStatementContext
  • func (s *StatementsContext) 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) ExpressionSequence() IExpressionSequenceContext
  • func (s *SwitchStatementContext) GetParser() antlr.Parser
  • func (s *SwitchStatementContext) GetRuleContext() antlr.RuleContext
  • func (*SwitchStatementContext) IsSwitchStatementContext()
  • func (s *SwitchStatementContext) OpenParen() antlr.TerminalNode
  • 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 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) Const() antlr.TerminalNode
  • func (s *VariableDeclarationListContext) GetModifier() antlr.Token
  • func (s *VariableDeclarationListContext) GetParser() antlr.Parser
  • func (s *VariableDeclarationListContext) GetRuleContext() antlr.RuleContext
  • func (*VariableDeclarationListContext) IsVariableDeclarationListContext()
  • func (s *VariableDeclarationListContext) NonStrictLet() antlr.TerminalNode
  • func (s *VariableDeclarationListContext) SetModifier(v antlr.Token)
  • func (s *VariableDeclarationListContext) StrictLet() antlr.TerminalNode
  • func (s *VariableDeclarationListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *VariableDeclarationListContext) Var() antlr.TerminalNode
  • 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 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) ExpressionSequence() IExpressionSequenceContext
  • func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext
  • func (s *WhileStatementContext) OpenParen() antlr.TerminalNode
  • 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 WordContext
  • func NewEmptyWordContext() *WordContext
  • func NewWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WordContext
  • func (s *WordContext) Accept(visitor antlr.ParseTreeVisitor) interface{}
  • func (s *WordContext) As() antlr.TerminalNode
  • func (s *WordContext) Async() antlr.TerminalNode
  • func (s *WordContext) Await() antlr.TerminalNode
  • func (s *WordContext) Break() antlr.TerminalNode
  • func (s *WordContext) Case() antlr.TerminalNode
  • func (s *WordContext) Catch() antlr.TerminalNode
  • func (s *WordContext) Class() antlr.TerminalNode
  • func (s *WordContext) Const() antlr.TerminalNode
  • func (s *WordContext) Continue() antlr.TerminalNode
  • func (s *WordContext) Debugger() antlr.TerminalNode
  • func (s *WordContext) Default() antlr.TerminalNode
  • func (s *WordContext) Delete() antlr.TerminalNode
  • func (s *WordContext) Do() antlr.TerminalNode
  • func (s *WordContext) Else() antlr.TerminalNode
  • func (s *WordContext) Enum() antlr.TerminalNode
  • func (s *WordContext) Export() antlr.TerminalNode
  • func (s *WordContext) Extends() antlr.TerminalNode
  • func (s *WordContext) Finally() antlr.TerminalNode
  • func (s *WordContext) For() antlr.TerminalNode
  • func (s *WordContext) From() antlr.TerminalNode
  • func (s *WordContext) Function_() antlr.TerminalNode
  • func (s *WordContext) GetParser() antlr.Parser
  • func (s *WordContext) GetRuleContext() antlr.RuleContext
  • func (s *WordContext) If() antlr.TerminalNode
  • func (s *WordContext) Implements() antlr.TerminalNode
  • func (s *WordContext) Import() antlr.TerminalNode
  • func (s *WordContext) In() antlr.TerminalNode
  • func (s *WordContext) Instanceof() antlr.TerminalNode
  • func (s *WordContext) Interface() antlr.TerminalNode
  • func (*WordContext) IsWordContext()
  • func (s *WordContext) New() antlr.TerminalNode
  • func (s *WordContext) NonStrictLet() antlr.TerminalNode
  • func (s *WordContext) Package() antlr.TerminalNode
  • func (s *WordContext) Private() antlr.TerminalNode
  • func (s *WordContext) Protected() antlr.TerminalNode
  • func (s *WordContext) Public() antlr.TerminalNode
  • func (s *WordContext) Return() antlr.TerminalNode
  • func (s *WordContext) Static() antlr.TerminalNode
  • func (s *WordContext) StrictLet() antlr.TerminalNode
  • func (s *WordContext) Super() antlr.TerminalNode
  • func (s *WordContext) Switch() antlr.TerminalNode
  • func (s *WordContext) This() antlr.TerminalNode
  • func (s *WordContext) Throw() antlr.TerminalNode
  • func (s *WordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
  • func (s *WordContext) Try() antlr.TerminalNode
  • func (s *WordContext) Typeof() antlr.TerminalNode
  • func (s *WordContext) Var() antlr.TerminalNode
  • func (s *WordContext) Void() antlr.TerminalNode
  • func (s *WordContext) While() antlr.TerminalNode
  • func (s *WordContext) With() antlr.TerminalNode
  • func (s *WordContext) Yield() 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
	JavaScriptLexerSingleLineComment             = 2
	JavaScriptLexerBlockComment                  = 3
	JavaScriptLexerMultiLineComment              = 4
	JavaScriptLexerRegularExpressionLiteral      = 5
	JavaScriptLexerOpenBracket                   = 6
	JavaScriptLexerCloseBracket                  = 7
	JavaScriptLexerOpenParen                     = 8
	JavaScriptLexerCloseParen                    = 9
	JavaScriptLexerOpenBrace                     = 10
	JavaScriptLexerTemplateCloseBrace            = 11
	JavaScriptLexerCloseBrace                    = 12
	JavaScriptLexerSemiColon                     = 13
	JavaScriptLexerComma                         = 14
	JavaScriptLexerAssign                        = 15
	JavaScriptLexerQuestionMark                  = 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
	JavaScriptLexerGet                           = 100
	JavaScriptLexerSet                           = 101
	JavaScriptLexerClass                         = 102
	JavaScriptLexerEnum                          = 103
	JavaScriptLexerExtends                       = 104
	JavaScriptLexerSuper                         = 105
	JavaScriptLexerConst                         = 106
	JavaScriptLexerExport                        = 107
	JavaScriptLexerImport                        = 108
	JavaScriptLexerAsync                         = 109
	JavaScriptLexerAwait                         = 110
	JavaScriptLexerYield                         = 111
	JavaScriptLexerImplements                    = 112
	JavaScriptLexerStrictLet                     = 113
	JavaScriptLexerNonStrictLet                  = 114
	JavaScriptLexerPrivate                       = 115
	JavaScriptLexerPublic                        = 116
	JavaScriptLexerInterface                     = 117
	JavaScriptLexerPackage                       = 118
	JavaScriptLexerProtected                     = 119
	JavaScriptLexerStatic                        = 120
	JavaScriptLexerIdentifier                    = 121
	JavaScriptLexerStringLiteral                 = 122
	JavaScriptLexerBackTick                      = 123
	JavaScriptLexerCR                            = 124
	JavaScriptLexerWS                            = 125
	JavaScriptLexerLineTerminator                = 126
	JavaScriptLexerHtmlComment                   = 127
	JavaScriptLexerCDataComment                  = 128
	JavaScriptLexerUnexpectedCharacter           = 129
	JavaScriptLexerTemplateStringStartExpression = 130
	JavaScriptLexerTemplateStringAtom            = 131
)

JavaScriptLexer tokens.

const (
	JavaScriptParserEOF                           = antlr.TokenEOF
	JavaScriptParserHashBangLine                  = 1
	JavaScriptParserSingleLineComment             = 2
	JavaScriptParserBlockComment                  = 3
	JavaScriptParserMultiLineComment              = 4
	JavaScriptParserRegularExpressionLiteral      = 5
	JavaScriptParserOpenBracket                   = 6
	JavaScriptParserCloseBracket                  = 7
	JavaScriptParserOpenParen                     = 8
	JavaScriptParserCloseParen                    = 9
	JavaScriptParserOpenBrace                     = 10
	JavaScriptParserTemplateCloseBrace            = 11
	JavaScriptParserCloseBrace                    = 12
	JavaScriptParserSemiColon                     = 13
	JavaScriptParserComma                         = 14
	JavaScriptParserAssign                        = 15
	JavaScriptParserQuestionMark                  = 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
	JavaScriptParserGet                           = 100
	JavaScriptParserSet                           = 101
	JavaScriptParserClass                         = 102
	JavaScriptParserEnum                          = 103
	JavaScriptParserExtends                       = 104
	JavaScriptParserSuper                         = 105
	JavaScriptParserConst                         = 106
	JavaScriptParserExport                        = 107
	JavaScriptParserImport                        = 108
	JavaScriptParserAsync                         = 109
	JavaScriptParserAwait                         = 110
	JavaScriptParserYield                         = 111
	JavaScriptParserImplements                    = 112
	JavaScriptParserStrictLet                     = 113
	JavaScriptParserNonStrictLet                  = 114
	JavaScriptParserPrivate                       = 115
	JavaScriptParserPublic                        = 116
	JavaScriptParserInterface                     = 117
	JavaScriptParserPackage                       = 118
	JavaScriptParserProtected                     = 119
	JavaScriptParserStatic                        = 120
	JavaScriptParserIdentifier                    = 121
	JavaScriptParserStringLiteral                 = 122
	JavaScriptParserBackTick                      = 123
	JavaScriptParserCR                            = 124
	JavaScriptParserWS                            = 125
	JavaScriptParserLineTerminator                = 126
	JavaScriptParserHtmlComment                   = 127
	JavaScriptParserCDataComment                  = 128
	JavaScriptParserUnexpectedCharacter           = 129
	JavaScriptParserTemplateStringStartExpression = 130
	JavaScriptParserTemplateStringAtom            = 131
)

JavaScriptParser tokens.

const (
	JavaScriptParserRULE_program                 = 0
	JavaScriptParserRULE_statements              = 1
	JavaScriptParserRULE_statement               = 2
	JavaScriptParserRULE_block                   = 3
	JavaScriptParserRULE_importStatement         = 4
	JavaScriptParserRULE_importFromBlock         = 5
	JavaScriptParserRULE_importModuleItems       = 6
	JavaScriptParserRULE_importAliasName         = 7
	JavaScriptParserRULE_moduleExportName        = 8
	JavaScriptParserRULE_importedBinding         = 9
	JavaScriptParserRULE_importDefault           = 10
	JavaScriptParserRULE_importNamespace         = 11
	JavaScriptParserRULE_importFrom              = 12
	JavaScriptParserRULE_aliasName               = 13
	JavaScriptParserRULE_exportStatement         = 14
	JavaScriptParserRULE_exportFromBlock         = 15
	JavaScriptParserRULE_exportModuleItems       = 16
	JavaScriptParserRULE_exportAliasName         = 17
	JavaScriptParserRULE_declaration             = 18
	JavaScriptParserRULE_variableStatement       = 19
	JavaScriptParserRULE_variableDeclarationList = 20
	JavaScriptParserRULE_variableDeclaration     = 21
	JavaScriptParserRULE_emptyStatement_         = 22
	JavaScriptParserRULE_ifStatement             = 23
	JavaScriptParserRULE_elseBlock               = 24
	JavaScriptParserRULE_forFirst                = 25
	JavaScriptParserRULE_forSecond               = 26
	JavaScriptParserRULE_forThird                = 27
	JavaScriptParserRULE_iterationStatement      = 28
	JavaScriptParserRULE_continueStatement       = 29
	JavaScriptParserRULE_breakStatement          = 30
	JavaScriptParserRULE_returnStatement         = 31
	JavaScriptParserRULE_yieldStatement          = 32
	JavaScriptParserRULE_withStatement           = 33
	JavaScriptParserRULE_switchStatement         = 34
	JavaScriptParserRULE_caseBlock               = 35
	JavaScriptParserRULE_caseClauses             = 36
	JavaScriptParserRULE_caseClause              = 37
	JavaScriptParserRULE_defaultClause           = 38
	JavaScriptParserRULE_labelledStatement       = 39
	JavaScriptParserRULE_throwStatement          = 40
	JavaScriptParserRULE_tryStatement            = 41
	JavaScriptParserRULE_catchProduction         = 42
	JavaScriptParserRULE_finallyProduction       = 43
	JavaScriptParserRULE_debuggerStatement       = 44
	JavaScriptParserRULE_functionDeclaration     = 45
	JavaScriptParserRULE_classDeclaration        = 46
	JavaScriptParserRULE_classTail               = 47
	JavaScriptParserRULE_classElement            = 48
	JavaScriptParserRULE_methodDefinition        = 49
	JavaScriptParserRULE_fieldDefinition         = 50
	JavaScriptParserRULE_classElementName        = 51
	JavaScriptParserRULE_privateIdentifier       = 52
	JavaScriptParserRULE_formalParameterList     = 53
	JavaScriptParserRULE_formalParameterArg      = 54
	JavaScriptParserRULE_lastFormalParameterArg  = 55
	JavaScriptParserRULE_functionBody            = 56
	JavaScriptParserRULE_arrayLiteral            = 57
	JavaScriptParserRULE_elementList             = 58
	JavaScriptParserRULE_arrayElement            = 59
	JavaScriptParserRULE_propertyAssignment      = 60
	JavaScriptParserRULE_propertyName            = 61
	JavaScriptParserRULE_arguments               = 62
	JavaScriptParserRULE_argument                = 63
	JavaScriptParserRULE_expressionSequence      = 64
	JavaScriptParserRULE_specificExpression      = 65
	JavaScriptParserRULE_questionDot             = 66
	JavaScriptParserRULE_keywordSingleExpression = 67
	JavaScriptParserRULE_singleExpression        = 68
	JavaScriptParserRULE_preUnaryOperator        = 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_word                    = 85
	JavaScriptParserRULE_identifier              = 86
	JavaScriptParserRULE_optionalChainMember     = 87
	JavaScriptParserRULE_eos                     = 88
)

JavaScriptParser rules.

const JavaScriptLexerERROR = 2

JavaScriptLexerERROR is the JavaScriptLexer channel.

const JavaScriptLexerTEMPLATE = 1

JavaScriptLexerTEMPLATE is the JavaScriptLexer mode.

Variables

var EOSCOUNT = 0

Functions

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
	// contains filtered or unexported fields
}

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) GetOp

func (s *AdditiveExpressionContext) GetOp() antlr.Token

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) SetOp

func (s *AdditiveExpressionContext) SetOp(v antlr.Token)

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) CopyFrom

func (s *AnonymousFunctionContext) CopyFrom(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) Identifier

func (s *AnonymousFunctionDeclContext) Identifier() IIdentifierContext

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 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) Assign

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

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 {
	*KeywordSingleExpressionContext
}

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) 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) VisitBitExpression

func (v *BaseJavaScriptParserVisitor) VisitBitExpression(ctx *BitExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitBitShiftExpression

func (v *BaseJavaScriptParserVisitor) VisitBitShiftExpression(ctx *BitShiftExpressionContext) 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) VisitChainExpression

func (v *BaseJavaScriptParserVisitor) VisitChainExpression(ctx *ChainExpressionContext) 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) 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) VisitEqExpression

func (v *BaseJavaScriptParserVisitor) VisitEqExpression(ctx *EqExpressionContext) 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) 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) VisitInitializer

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

func (*BaseJavaScriptParserVisitor) VisitKeywordExpression

func (v *BaseJavaScriptParserVisitor) VisitKeywordExpression(ctx *KeywordExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitLabelledStatement

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

func (*BaseJavaScriptParserVisitor) VisitLastFormalParameterArg

func (v *BaseJavaScriptParserVisitor) VisitLastFormalParameterArg(ctx *LastFormalParameterArgContext) 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) 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) 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) VisitOptionalChainMember

func (v *BaseJavaScriptParserVisitor) VisitOptionalChainMember(ctx *OptionalChainMemberContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitParenthesizedExpression

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

func (*BaseJavaScriptParserVisitor) VisitPostUnaryExpression

func (v *BaseJavaScriptParserVisitor) VisitPostUnaryExpression(ctx *PostUnaryExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPowerExpression

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

func (*BaseJavaScriptParserVisitor) VisitPreUnaryExpression

func (v *BaseJavaScriptParserVisitor) VisitPreUnaryExpression(ctx *PreUnaryExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitPreUnaryOperator

func (v *BaseJavaScriptParserVisitor) VisitPreUnaryOperator(ctx *PreUnaryOperatorContext) 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) VisitQuestionDot

func (v *BaseJavaScriptParserVisitor) VisitQuestionDot(ctx *QuestionDotContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitRelationalExpression

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

func (*BaseJavaScriptParserVisitor) VisitReturnStatement

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

func (*BaseJavaScriptParserVisitor) VisitSetter

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

func (*BaseJavaScriptParserVisitor) VisitSpecificExpression

func (v *BaseJavaScriptParserVisitor) VisitSpecificExpression(ctx *SpecificExpressionContext) interface{}

func (*BaseJavaScriptParserVisitor) VisitStatement

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

func (*BaseJavaScriptParserVisitor) VisitStatements

func (v *BaseJavaScriptParserVisitor) VisitStatements(ctx *StatementsContext) 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) 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) VisitWhileStatement

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

func (*BaseJavaScriptParserVisitor) VisitWithStatement

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

func (*BaseJavaScriptParserVisitor) VisitWord

func (v *BaseJavaScriptParserVisitor) VisitWord(ctx *WordContext) 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 BitExpressionContext

type BitExpressionContext struct {
	*SingleExpressionContext
}

func NewBitExpressionContext

func NewBitExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitExpressionContext

func (*BitExpressionContext) Accept

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

func (*BitExpressionContext) AllSingleExpression

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

func (*BitExpressionContext) BitAnd

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

func (*BitExpressionContext) BitOr

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

func (*BitExpressionContext) BitXOr

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

func (*BitExpressionContext) GetRuleContext

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

func (*BitExpressionContext) SingleExpression

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

type BitShiftExpressionContext

type BitShiftExpressionContext struct {
	*SingleExpressionContext
	// contains filtered or unexported fields
}

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) GetOp

func (s *BitShiftExpressionContext) GetOp() antlr.Token

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) SetOp

func (s *BitShiftExpressionContext) SetOp(v antlr.Token)

func (*BitShiftExpressionContext) SingleExpression

func (s *BitShiftExpressionContext) 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) Statements

func (s *BlockContext) Statements() IStatementsContext

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) ExpressionSequence

func (s *CaseClauseContext) ExpressionSequence() IExpressionSequenceContext

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) Statements

func (s *CaseClauseContext) Statements() IStatementsContext

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 ChainExpressionContext

type ChainExpressionContext struct {
	*SingleExpressionContext
}

func NewChainExpressionContext

func NewChainExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ChainExpressionContext

func (*ChainExpressionContext) Accept

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

func (*ChainExpressionContext) Dot

func (s *ChainExpressionContext) Dot() antlr.TerminalNode

func (*ChainExpressionContext) GetRuleContext

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

func (*ChainExpressionContext) Hashtag

func (s *ChainExpressionContext) Hashtag() antlr.TerminalNode

func (*ChainExpressionContext) IdentifierName

func (s *ChainExpressionContext) IdentifierName() IIdentifierNameContext

func (*ChainExpressionContext) SingleExpression

func (s *ChainExpressionContext) SingleExpression() ISingleExpressionContext

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) 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) IsClassElementContext

func (*ClassElementContext) IsClassElementContext()

func (*ClassElementContext) MethodDefinition

func (s *ClassElementContext) MethodDefinition() IMethodDefinitionContext

func (*ClassElementContext) SemiColon

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

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) Statements

func (s *DefaultClauseContext) Statements() IStatementsContext

func (*DefaultClauseContext) ToStringTree

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

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) ExpressionSequence

func (s *DoStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*DoStatementContext) GetRuleContext

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

func (*DoStatementContext) OpenParen

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

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 EqExpressionContext

type EqExpressionContext struct {
	*SingleExpressionContext
	// contains filtered or unexported fields
}

func NewEqExpressionContext

func NewEqExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqExpressionContext

func (*EqExpressionContext) Accept

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

func (*EqExpressionContext) AllSingleExpression

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

func (*EqExpressionContext) Equals_

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

func (*EqExpressionContext) GetOp

func (s *EqExpressionContext) GetOp() antlr.Token

func (*EqExpressionContext) GetRuleContext

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

func (*EqExpressionContext) IdentityEquals

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

func (*EqExpressionContext) IdentityNotEquals

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

func (*EqExpressionContext) NotEquals

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

func (*EqExpressionContext) SetOp

func (s *EqExpressionContext) SetOp(v antlr.Token)

func (*EqExpressionContext) SingleExpression

func (s *EqExpressionContext) 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) CopyFrom

func (s *ExportStatementContext) CopyFrom(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 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) ExpressionSequence

func (s *ForFirstContext) ExpressionSequence() IExpressionSequenceContext

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) 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) CloseParen

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

func (*ForInStatementContext) ExpressionSequence

func (s *ForInStatementContext) ExpressionSequence() IExpressionSequenceContext

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() ISingleExpressionContext

func (*ForInStatementContext) Statement

func (s *ForInStatementContext) Statement() IStatementContext

func (*ForInStatementContext) VariableDeclarationList

func (s *ForInStatementContext) VariableDeclarationList() IVariableDeclarationListContext

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) Await

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

func (*ForOfStatementContext) CloseParen

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

func (*ForOfStatementContext) ExpressionSequence

func (s *ForOfStatementContext) ExpressionSequence() IExpressionSequenceContext

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() ISingleExpressionContext

func (*ForOfStatementContext) Statement

func (s *ForOfStatementContext) Statement() IStatementContext

func (*ForOfStatementContext) VariableDeclarationList

func (s *ForOfStatementContext) VariableDeclarationList() IVariableDeclarationListContext

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) ExpressionSequence

func (s *ForSecondContext) ExpressionSequence() IExpressionSequenceContext

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) 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) ExpressionSequence

func (s *ForThirdContext) ExpressionSequence() IExpressionSequenceContext

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) 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) Statements

func (s *FunctionBodyContext) Statements() IStatementsContext

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) Get

func (s *GetterContext) Get() antlr.TerminalNode

func (*GetterContext) GetParser

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

func (*GetterContext) GetRuleContext

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

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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

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

IExpressionSequenceContext is an interface to support dynamic dispatch.

type IFieldDefinitionContext

type IFieldDefinitionContext interface {
	antlr.ParserRuleContext

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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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

	// 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 IKeywordSingleExpressionContext

type IKeywordSingleExpressionContext interface {
	antlr.ParserRuleContext

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

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

IKeywordSingleExpressionContext is an interface to support dynamic dispatch.

type ILabelledStatementContext

type ILabelledStatementContext interface {
	antlr.ParserRuleContext

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

	// 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

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

ILastFormalParameterArgContext is an interface to support dynamic dispatch.

type ILiteralContext

type ILiteralContext interface {
	antlr.ParserRuleContext

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

	// 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

	// 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

	// 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

	// 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

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

IObjectLiteralContext is an interface to support dynamic dispatch.

type IOptionalChainMemberContext

type IOptionalChainMemberContext interface {
	antlr.ParserRuleContext

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

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

IOptionalChainMemberContext is an interface to support dynamic dispatch.

type IPreUnaryOperatorContext

type IPreUnaryOperatorContext interface {
	antlr.ParserRuleContext

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

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

IPreUnaryOperatorContext is an interface to support dynamic dispatch.

type IPrivateIdentifierContext

type IPrivateIdentifierContext interface {
	antlr.ParserRuleContext

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

	// 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

	// 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

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

IPropertyNameContext is an interface to support dynamic dispatch.

type IQuestionDotContext

type IQuestionDotContext interface {
	antlr.ParserRuleContext

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

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

IQuestionDotContext is an interface to support dynamic dispatch.

type IReturnStatementContext

type IReturnStatementContext interface {
	antlr.ParserRuleContext

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

	// 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

	// 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 ISpecificExpressionContext

type ISpecificExpressionContext interface {
	antlr.ParserRuleContext

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

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

ISpecificExpressionContext is an interface to support dynamic dispatch.

type IStatementContext

type IStatementContext interface {
	antlr.ParserRuleContext

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

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

IStatementContext is an interface to support dynamic dispatch.

type IStatementsContext

type IStatementsContext interface {
	antlr.ParserRuleContext

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

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

IStatementsContext is an interface to support dynamic dispatch.

type ISwitchStatementContext

type ISwitchStatementContext interface {
	antlr.ParserRuleContext

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

	// 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

	// 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

	// 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

	// 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

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

ITryStatementContext is an interface to support dynamic dispatch.

type IVariableDeclarationContext

type IVariableDeclarationContext interface {
	antlr.ParserRuleContext

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

	// 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

	// GetModifier returns the modifier token.
	GetModifier() antlr.Token

	// SetModifier sets the modifier token.
	SetModifier(antlr.Token)

	// 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

	// 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

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

IWithStatementContext is an interface to support dynamic dispatch.

type IWordContext

type IWordContext interface {
	antlr.ParserRuleContext

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

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

IWordContext is an interface to support dynamic dispatch.

type IYieldStatementContext

type IYieldStatementContext interface {
	antlr.ParserRuleContext

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

	// 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) Get

func (s *IdentifierContext) Get() 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) Set

func (s *IdentifierContext) Set() antlr.TerminalNode

func (*IdentifierContext) Static

func (s *IdentifierContext) Static() 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) BooleanLiteral

func (s *IdentifierNameContext) BooleanLiteral() antlr.TerminalNode

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) NullLiteral

func (s *IdentifierNameContext) NullLiteral() antlr.TerminalNode

func (*IdentifierNameContext) ToStringTree

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

func (*IdentifierNameContext) Word

func (s *IdentifierNameContext) Word() IWordContext

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) AllExpressionSequence

func (s *IfStatementContext) AllExpressionSequence() []IExpressionSequenceContext

func (*IfStatementContext) AllIf

func (s *IfStatementContext) AllIf() []antlr.TerminalNode

func (*IfStatementContext) AllOpenParen

func (s *IfStatementContext) AllOpenParen() []antlr.TerminalNode

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) ExpressionSequence

func (s *IfStatementContext) ExpressionSequence(i int) IExpressionSequenceContext

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) 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 {
	*KeywordSingleExpressionContext
}

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 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 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) CopyFrom

func (s *IterationStatementContext) CopyFrom(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_Action

func (l *JavaScriptLexer) HashBangLine_Action(localctx antlr.RuleContext, actionIndex int)

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) 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) 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) 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) KeywordSingleExpression

func (p *JavaScriptParser) KeywordSingleExpression() (localctx IKeywordSingleExpressionContext)

func (*JavaScriptParser) LabelledStatement

func (p *JavaScriptParser) LabelledStatement() (localctx ILabelledStatementContext)

func (*JavaScriptParser) LastFormalParameterArg

func (p *JavaScriptParser) LastFormalParameterArg() (localctx ILastFormalParameterArgContext)

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) OptionalChainMember

func (p *JavaScriptParser) OptionalChainMember() (localctx IOptionalChainMemberContext)

func (*JavaScriptParser) PreUnaryOperator

func (p *JavaScriptParser) PreUnaryOperator() (localctx IPreUnaryOperatorContext)

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) QuestionDot

func (p *JavaScriptParser) QuestionDot() (localctx IQuestionDotContext)

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) SingleExpression

func (p *JavaScriptParser) SingleExpression() (localctx ISingleExpressionContext)

func (*JavaScriptParser) SingleExpression_Sempred

func (p *JavaScriptParser) SingleExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*JavaScriptParser) SpecificExpression

func (p *JavaScriptParser) SpecificExpression() (localctx ISpecificExpressionContext)

func (*JavaScriptParser) Statement

func (p *JavaScriptParser) Statement() (localctx IStatementContext)

func (*JavaScriptParser) Statements

func (p *JavaScriptParser) Statements() (localctx IStatementsContext)

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) 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) Word

func (p *JavaScriptParser) Word() (localctx IWordContext)

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
	// contains filtered or unexported fields
}

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#statements.
	VisitStatements(ctx *StatementsContext) 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#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#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#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#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#specificExpression.
	VisitSpecificExpression(ctx *SpecificExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#questionDot.
	VisitQuestionDot(ctx *QuestionDotContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ImportExpression.
	VisitImportExpression(ctx *ImportExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#NewExpression.
	VisitNewExpression(ctx *NewExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#MetaExpression.
	VisitMetaExpression(ctx *MetaExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#AwaitExpression.
	VisitAwaitExpression(ctx *AwaitExpressionContext) 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#ChainExpression.
	VisitChainExpression(ctx *ChainExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PowerExpression.
	VisitPowerExpression(ctx *PowerExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#ObjectLiteralExpression.
	VisitObjectLiteralExpression(ctx *ObjectLiteralExpressionContext) 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#ArgumentsExpression.
	VisitArgumentsExpression(ctx *ArgumentsExpressionContext) 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#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#YieldExpression.
	VisitYieldExpression(ctx *YieldExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#EqExpression.
	VisitEqExpression(ctx *EqExpressionContext) 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#ClassExpression.
	VisitClassExpression(ctx *ClassExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#KeywordExpression.
	VisitKeywordExpression(ctx *KeywordExpressionContext) 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#PreUnaryExpression.
	VisitPreUnaryExpression(ctx *PreUnaryExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#PostUnaryExpression.
	VisitPostUnaryExpression(ctx *PostUnaryExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#BitExpression.
	VisitBitExpression(ctx *BitExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#AssignmentOperatorExpression.
	VisitAssignmentOperatorExpression(ctx *AssignmentOperatorExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#CoalesceExpression.
	VisitCoalesceExpression(ctx *CoalesceExpressionContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#preUnaryOperator.
	VisitPreUnaryOperator(ctx *PreUnaryOperatorContext) 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#word.
	VisitWord(ctx *WordContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#identifier.
	VisitIdentifier(ctx *IdentifierContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#optionalChainMember.
	VisitOptionalChainMember(ctx *OptionalChainMemberContext) interface{}

	// Visit a parse tree produced by JavaScriptParser#eos.
	VisitEos(ctx *EosContext) interface{}
}

A complete Visitor for a parse tree produced by JavaScriptParser.

type KeywordExpressionContext

type KeywordExpressionContext struct {
	*SingleExpressionContext
}

func NewKeywordExpressionContext

func NewKeywordExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KeywordExpressionContext

func (*KeywordExpressionContext) Accept

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

func (*KeywordExpressionContext) GetRuleContext

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

func (*KeywordExpressionContext) KeywordSingleExpression

func (s *KeywordExpressionContext) KeywordSingleExpression() IKeywordSingleExpressionContext

type KeywordSingleExpressionContext

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

func NewEmptyKeywordSingleExpressionContext

func NewEmptyKeywordSingleExpressionContext() *KeywordSingleExpressionContext

func NewKeywordSingleExpressionContext

func NewKeywordSingleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordSingleExpressionContext

func (*KeywordSingleExpressionContext) CopyFrom

func (s *KeywordSingleExpressionContext) CopyFrom(ctx *KeywordSingleExpressionContext)

func (*KeywordSingleExpressionContext) GetParser

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

func (*KeywordSingleExpressionContext) GetRuleContext

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

func (*KeywordSingleExpressionContext) IsKeywordSingleExpressionContext

func (*KeywordSingleExpressionContext) IsKeywordSingleExpressionContext()

func (*KeywordSingleExpressionContext) ToStringTree

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

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 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 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) SingleExpression

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

type MetaExpressionContext

type MetaExpressionContext struct {
	*KeywordSingleExpressionContext
}

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
	// contains filtered or unexported fields
}

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) GetOp

func (s *MultiplicativeExpressionContext) GetOp() antlr.Token

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) SetOp

func (s *MultiplicativeExpressionContext) SetOp(v antlr.Token)

func (*MultiplicativeExpressionContext) SingleExpression

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

type NewExpressionContext

type NewExpressionContext struct {
	*KeywordSingleExpressionContext
}

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 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) GetRuleContext

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

func (*OptionalChainExpressionContext) OptionalChainMember

func (s *OptionalChainExpressionContext) OptionalChainMember() IOptionalChainMemberContext

func (*OptionalChainExpressionContext) QuestionDot

func (s *OptionalChainExpressionContext) QuestionDot() IQuestionDotContext

func (*OptionalChainExpressionContext) SingleExpression

func (s *OptionalChainExpressionContext) SingleExpression() ISingleExpressionContext

type OptionalChainMemberContext

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

func NewEmptyOptionalChainMemberContext

func NewEmptyOptionalChainMemberContext() *OptionalChainMemberContext

func NewOptionalChainMemberContext

func NewOptionalChainMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionalChainMemberContext

func (*OptionalChainMemberContext) Accept

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

func (*OptionalChainMemberContext) CloseBracket

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

func (*OptionalChainMemberContext) GetParser

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

func (*OptionalChainMemberContext) GetRuleContext

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

func (*OptionalChainMemberContext) Hashtag

func (s *OptionalChainMemberContext) Hashtag() antlr.TerminalNode

func (*OptionalChainMemberContext) IdentifierName

func (s *OptionalChainMemberContext) IdentifierName() IIdentifierNameContext

func (*OptionalChainMemberContext) IsOptionalChainMemberContext

func (*OptionalChainMemberContext) IsOptionalChainMemberContext()

func (*OptionalChainMemberContext) OpenBracket

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

func (*OptionalChainMemberContext) SingleExpression

func (s *OptionalChainMemberContext) SingleExpression() ISingleExpressionContext

func (*OptionalChainMemberContext) ToStringTree

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

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 PostUnaryExpressionContext

type PostUnaryExpressionContext struct {
	*SingleExpressionContext
	// contains filtered or unexported fields
}

func NewPostUnaryExpressionContext

func NewPostUnaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostUnaryExpressionContext

func (*PostUnaryExpressionContext) Accept

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

func (*PostUnaryExpressionContext) GetOp

func (s *PostUnaryExpressionContext) GetOp() antlr.Token

func (*PostUnaryExpressionContext) GetRuleContext

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

func (*PostUnaryExpressionContext) MinusMinus

func (s *PostUnaryExpressionContext) MinusMinus() antlr.TerminalNode

func (*PostUnaryExpressionContext) PlusPlus

func (s *PostUnaryExpressionContext) PlusPlus() antlr.TerminalNode

func (*PostUnaryExpressionContext) SetOp

func (s *PostUnaryExpressionContext) SetOp(v antlr.Token)

func (*PostUnaryExpressionContext) SingleExpression

func (s *PostUnaryExpressionContext) 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 PreUnaryExpressionContext

type PreUnaryExpressionContext struct {
	*SingleExpressionContext
}

func NewPreUnaryExpressionContext

func NewPreUnaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreUnaryExpressionContext

func (*PreUnaryExpressionContext) Accept

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

func (*PreUnaryExpressionContext) GetRuleContext

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

func (*PreUnaryExpressionContext) PreUnaryOperator

func (s *PreUnaryExpressionContext) PreUnaryOperator() IPreUnaryOperatorContext

func (*PreUnaryExpressionContext) SingleExpression

func (s *PreUnaryExpressionContext) SingleExpression() ISingleExpressionContext

type PreUnaryOperatorContext

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

func NewEmptyPreUnaryOperatorContext

func NewEmptyPreUnaryOperatorContext() *PreUnaryOperatorContext

func NewPreUnaryOperatorContext

func NewPreUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreUnaryOperatorContext

func (*PreUnaryOperatorContext) Accept

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

func (*PreUnaryOperatorContext) BitNot

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

func (*PreUnaryOperatorContext) Delete

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

func (*PreUnaryOperatorContext) GetParser

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

func (*PreUnaryOperatorContext) GetRuleContext

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

func (*PreUnaryOperatorContext) IsPreUnaryOperatorContext

func (*PreUnaryOperatorContext) IsPreUnaryOperatorContext()

func (*PreUnaryOperatorContext) Minus

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

func (*PreUnaryOperatorContext) MinusMinus

func (s *PreUnaryOperatorContext) MinusMinus() antlr.TerminalNode

func (*PreUnaryOperatorContext) Not

func (s *PreUnaryOperatorContext) Not() antlr.TerminalNode

func (*PreUnaryOperatorContext) Plus

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

func (*PreUnaryOperatorContext) PlusPlus

func (s *PreUnaryOperatorContext) PlusPlus() antlr.TerminalNode

func (*PreUnaryOperatorContext) ToStringTree

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

func (*PreUnaryOperatorContext) Typeof

func (s *PreUnaryOperatorContext) Typeof() antlr.TerminalNode

func (*PreUnaryOperatorContext) Void

func (s *PreUnaryOperatorContext) Void() antlr.TerminalNode

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) Statements

func (s *ProgramContext) Statements() IStatementsContext

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) CopyFrom

func (s *PropertyAssignmentContext) CopyFrom(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 QuestionDotContext

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

func NewEmptyQuestionDotContext

func NewEmptyQuestionDotContext() *QuestionDotContext

func NewQuestionDotContext

func NewQuestionDotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuestionDotContext

func (*QuestionDotContext) Accept

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

func (*QuestionDotContext) Dot

func (s *QuestionDotContext) Dot() antlr.TerminalNode

func (*QuestionDotContext) GetParser

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

func (*QuestionDotContext) GetRuleContext

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

func (*QuestionDotContext) IsQuestionDotContext

func (*QuestionDotContext) IsQuestionDotContext()

func (*QuestionDotContext) QuestionMark

func (s *QuestionDotContext) QuestionMark() antlr.TerminalNode

func (*QuestionDotContext) ToStringTree

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

type RelationalExpressionContext

type RelationalExpressionContext struct {
	*SingleExpressionContext
	// contains filtered or unexported fields
}

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) GetOp

func (s *RelationalExpressionContext) GetOp() antlr.Token

func (*RelationalExpressionContext) GetRuleContext

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

func (*RelationalExpressionContext) GreaterThanEquals

func (s *RelationalExpressionContext) GreaterThanEquals() antlr.TerminalNode

func (*RelationalExpressionContext) In

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

func (*RelationalExpressionContext) Instanceof

func (s *RelationalExpressionContext) Instanceof() 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) SetOp

func (s *RelationalExpressionContext) SetOp(v antlr.Token)

func (*RelationalExpressionContext) SingleExpression

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

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) IsSetterContext

func (*SetterContext) IsSetterContext()

func (*SetterContext) Set

func (s *SetterContext) Set() antlr.TerminalNode

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) CopyFrom

func (s *SingleExpressionContext) CopyFrom(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 SpecificExpressionContext

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

func NewEmptySpecificExpressionContext

func NewEmptySpecificExpressionContext() *SpecificExpressionContext

func NewSpecificExpressionContext

func NewSpecificExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SpecificExpressionContext

func (*SpecificExpressionContext) Accept

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

func (*SpecificExpressionContext) Arguments

func (s *SpecificExpressionContext) Arguments() IArgumentsContext

func (*SpecificExpressionContext) GetParser

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

func (*SpecificExpressionContext) GetRuleContext

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

func (*SpecificExpressionContext) IdentifierName

func (s *SpecificExpressionContext) IdentifierName() IIdentifierNameContext

func (*SpecificExpressionContext) IsSpecificExpressionContext

func (*SpecificExpressionContext) IsSpecificExpressionContext()

func (*SpecificExpressionContext) TemplateStringLiteral

func (s *SpecificExpressionContext) TemplateStringLiteral() ITemplateStringLiteralContext

func (*SpecificExpressionContext) ToStringTree

func (s *SpecificExpressionContext) 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) Eos

func (s *StatementContext) Eos() IEosContext

func (*StatementContext) ExportStatement

func (s *StatementContext) ExportStatement() IExportStatementContext

func (*StatementContext) ExpressionSequence

func (s *StatementContext) ExpressionSequence() IExpressionSequenceContext

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) SemiColon

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

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 StatementsContext

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

func NewEmptyStatementsContext

func NewEmptyStatementsContext() *StatementsContext

func NewStatementsContext

func NewStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementsContext

func (*StatementsContext) Accept

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

func (*StatementsContext) AllStatement

func (s *StatementsContext) AllStatement() []IStatementContext

func (*StatementsContext) GetParser

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

func (*StatementsContext) GetRuleContext

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

func (*StatementsContext) IsStatementsContext

func (*StatementsContext) IsStatementsContext()

func (*StatementsContext) Statement

func (s *StatementsContext) Statement(i int) IStatementContext

func (*StatementsContext) ToStringTree

func (s *StatementsContext) 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) ExpressionSequence

func (s *SwitchStatementContext) ExpressionSequence() IExpressionSequenceContext

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) 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 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) Const

func (s *VariableDeclarationListContext) Const() antlr.TerminalNode

func (*VariableDeclarationListContext) GetModifier

func (s *VariableDeclarationListContext) GetModifier() antlr.Token

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) NonStrictLet

func (s *VariableDeclarationListContext) NonStrictLet() antlr.TerminalNode

func (*VariableDeclarationListContext) SetModifier

func (s *VariableDeclarationListContext) SetModifier(v antlr.Token)

func (*VariableDeclarationListContext) StrictLet

func (s *VariableDeclarationListContext) StrictLet() antlr.TerminalNode

func (*VariableDeclarationListContext) ToStringTree

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

func (*VariableDeclarationListContext) Var

func (s *VariableDeclarationListContext) Var() antlr.TerminalNode

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 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) ExpressionSequence

func (s *WhileStatementContext) ExpressionSequence() IExpressionSequenceContext

func (*WhileStatementContext) GetRuleContext

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

func (*WhileStatementContext) OpenParen

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

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 WordContext

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

func NewEmptyWordContext

func NewEmptyWordContext() *WordContext

func NewWordContext

func NewWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WordContext

func (*WordContext) Accept

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

func (*WordContext) As

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

func (*WordContext) Async

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

func (*WordContext) Await

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

func (*WordContext) Break

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

func (*WordContext) Case

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

func (*WordContext) Catch

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

func (*WordContext) Class

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

func (*WordContext) Const

func (s *WordContext) Const() antlr.TerminalNode

func (*WordContext) Continue

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

func (*WordContext) Debugger

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

func (*WordContext) Default

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

func (*WordContext) Delete

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

func (*WordContext) Do

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

func (*WordContext) Else

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

func (*WordContext) Enum

func (s *WordContext) Enum() antlr.TerminalNode

func (*WordContext) Export

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

func (*WordContext) Extends

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

func (*WordContext) Finally

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

func (*WordContext) For

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

func (*WordContext) From

func (s *WordContext) From() antlr.TerminalNode

func (*WordContext) Function_

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

func (*WordContext) GetParser

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

func (*WordContext) GetRuleContext

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

func (*WordContext) If

func (s *WordContext) If() antlr.TerminalNode

func (*WordContext) Implements

func (s *WordContext) Implements() antlr.TerminalNode

func (*WordContext) Import

func (s *WordContext) Import() antlr.TerminalNode

func (*WordContext) In

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

func (*WordContext) Instanceof

func (s *WordContext) Instanceof() antlr.TerminalNode

func (*WordContext) Interface

func (s *WordContext) Interface() antlr.TerminalNode

func (*WordContext) IsWordContext

func (*WordContext) IsWordContext()

func (*WordContext) New

func (s *WordContext) New() antlr.TerminalNode

func (*WordContext) NonStrictLet

func (s *WordContext) NonStrictLet() antlr.TerminalNode

func (*WordContext) Package

func (s *WordContext) Package() antlr.TerminalNode

func (*WordContext) Private

func (s *WordContext) Private() antlr.TerminalNode

func (*WordContext) Protected

func (s *WordContext) Protected() antlr.TerminalNode

func (*WordContext) Public

func (s *WordContext) Public() antlr.TerminalNode

func (*WordContext) Return

func (s *WordContext) Return() antlr.TerminalNode

func (*WordContext) Static

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

func (*WordContext) StrictLet

func (s *WordContext) StrictLet() antlr.TerminalNode

func (*WordContext) Super

func (s *WordContext) Super() antlr.TerminalNode

func (*WordContext) Switch

func (s *WordContext) Switch() antlr.TerminalNode

func (*WordContext) This

func (s *WordContext) This() antlr.TerminalNode

func (*WordContext) Throw

func (s *WordContext) Throw() antlr.TerminalNode

func (*WordContext) ToStringTree

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

func (*WordContext) Try

func (s *WordContext) Try() antlr.TerminalNode

func (*WordContext) Typeof

func (s *WordContext) Typeof() antlr.TerminalNode

func (*WordContext) Var

func (s *WordContext) Var() antlr.TerminalNode

func (*WordContext) Void

func (s *WordContext) Void() antlr.TerminalNode

func (*WordContext) While

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

func (*WordContext) With

func (s *WordContext) With() antlr.TerminalNode

func (*WordContext) Yield

func (s *WordContext) Yield() 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