generated

package

Go to main page

Versions in this module

v0

v0.3.0

Jul 26, 2025

Changes in this version

+ func InitEmptyComptimeCaseClauseContext(p *ComptimeCaseClauseContext)

+ func InitEmptyComptimeDefaultClauseContext(p *ComptimeDefaultClauseContext)

type BasehuloParserVisitor

+ func (v *BasehuloParserVisitor) VisitComptimeCaseClause(ctx *ComptimeCaseClauseContext) interface{}

+ func (v *BasehuloParserVisitor) VisitComptimeDefaultClause(ctx *ComptimeDefaultClauseContext) interface{}

+ type ComptimeCaseClauseContext struct

+ func NewComptimeCaseClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComptimeCaseClauseContext

+ func NewEmptyComptimeCaseClauseContext() *ComptimeCaseClauseContext

+ func (*ComptimeCaseClauseContext) IsComptimeCaseClauseContext()

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

+ func (s *ComptimeCaseClauseContext) Block() IBlockContext

+ func (s *ComptimeCaseClauseContext) ConditionalExpression() IConditionalExpressionContext

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

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

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

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

+ func (s *ComptimeCaseClauseContext) WHEN() antlr.TerminalNode

+ type ComptimeDefaultClauseContext struct

+ func NewComptimeDefaultClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComptimeDefaultClauseContext

+ func NewEmptyComptimeDefaultClauseContext() *ComptimeDefaultClauseContext

+ func (*ComptimeDefaultClauseContext) IsComptimeDefaultClauseContext()

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

+ func (s *ComptimeDefaultClauseContext) Block() IBlockContext

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

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

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

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

type ComptimeExpressionContext

+ func (s *ComptimeExpressionContext) AllComptimeCaseClause() []IComptimeCaseClauseContext

+ func (s *ComptimeExpressionContext) ComptimeCaseClause(i int) IComptimeCaseClauseContext

+ func (s *ComptimeExpressionContext) ComptimeDefaultClause() IComptimeDefaultClauseContext

+ func (s *ComptimeExpressionContext) ConditionalExpression() IConditionalExpressionContext

+ func (s *ComptimeExpressionContext) WHEN() antlr.TerminalNode

+ type IComptimeCaseClauseContext interface

+ Block func() IBlockContext

+ ConditionalExpression func() IConditionalExpressionContext

+ ELSE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsComptimeCaseClauseContext func()

+ WHEN func() antlr.TerminalNode

+ type IComptimeDefaultClauseContext interface

+ Block func() IBlockContext

+ ELSE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsComptimeDefaultClauseContext func()

type IComptimeExpressionContext

+ AllComptimeCaseClause func() []IComptimeCaseClauseContext

+ ComptimeCaseClause func(i int) IComptimeCaseClauseContext

+ ComptimeDefaultClause func() IComptimeDefaultClauseContext

+ ConditionalExpression func() IConditionalExpressionContext

+ WHEN func() antlr.TerminalNode

v0.2.0

Jul 19, 2025

Changes in this version

+ func InitEmptyBuiltinCommandArgumentContext(p *BuiltinCommandArgumentContext)

+ func InitEmptyCommandArgumentContext(p *CommandArgumentContext)

type BasehuloParserVisitor

+ func (v *BasehuloParserVisitor) VisitBuiltinCommandArgument(ctx *BuiltinCommandArgumentContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCommandArgument(ctx *CommandArgumentContext) interface{}

+ type BuiltinCommandArgumentContext struct

+ func NewBuiltinCommandArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BuiltinCommandArgumentContext

+ func NewEmptyBuiltinCommandArgumentContext() *BuiltinCommandArgumentContext

+ func (*BuiltinCommandArgumentContext) IsBuiltinCommandArgumentContext()

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

+ func (s *BuiltinCommandArgumentContext) AllCommandArgument() []ICommandArgumentContext

+ func (s *BuiltinCommandArgumentContext) CommandArgument(i int) ICommandArgumentContext

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

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

+ func (s *BuiltinCommandArgumentContext) TRIPLE_MINUS() antlr.TerminalNode

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

+ type CommandArgumentContext struct

+ func NewCommandArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommandArgumentContext

+ func NewEmptyCommandArgumentContext() *CommandArgumentContext

+ func (*CommandArgumentContext) IsCommandArgumentContext()

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

+ func (s *CommandArgumentContext) ConditionalExpression() IConditionalExpressionContext

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

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

+ func (s *CommandArgumentContext) MemberAccess() IMemberAccessContext

+ func (s *CommandArgumentContext) Option() IOptionContext

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

type CommandExpressionContext

+ func (s *CommandExpressionContext) AllCommandArgument() []ICommandArgumentContext

+ func (s *CommandExpressionContext) BuiltinCommandArgument() IBuiltinCommandArgumentContext

+ func (s *CommandExpressionContext) CommandArgument(i int) ICommandArgumentContext

+ type IBuiltinCommandArgumentContext interface

+ AllCommandArgument func() []ICommandArgumentContext

+ CommandArgument func(i int) ICommandArgumentContext

+ GetParser func() antlr.Parser

+ IsBuiltinCommandArgumentContext func()

+ TRIPLE_MINUS func() antlr.TerminalNode

+ type ICommandArgumentContext interface

+ ConditionalExpression func() IConditionalExpressionContext

+ GetParser func() antlr.Parser

+ IsCommandArgumentContext func()

+ MemberAccess func() IMemberAccessContext

+ Option func() IOptionContext

type ICommandExpressionContext

+ AllCommandArgument func() []ICommandArgumentContext

+ BuiltinCommandArgument func() IBuiltinCommandArgumentContext

+ CommandArgument func(i int) ICommandArgumentContext

v0.1.0

Jul 11, 2025

Changes in this version

+ var HuloLexerLexerStaticData struct

+ var HuloParserParserStaticData struct

+ func HuloLexerInit()

+ func HuloParserInit()

+ func InitEmptyAddSubExpressionContext(p *AddSubExpressionContext)

+ func InitEmptyArrayTypeContext(p *ArrayTypeContext)

+ func InitEmptyAsExpressionContext(p *AsExpressionContext)

+ func InitEmptyAsIdentifierContext(p *AsIdentifierContext)

+ func InitEmptyAssignStatementContext(p *AssignStatementContext)

+ func InitEmptyBlockContext(p *BlockContext)

+ func InitEmptyBreakStatementContext(p *BreakStatementContext)

+ func InitEmptyCallExpressionContext(p *CallExpressionContext)

+ func InitEmptyCallExpressionLinkedListContext(p *CallExpressionLinkedListContext)

+ func InitEmptyCatchClauseContext(p *CatchClauseContext)

+ func InitEmptyCatchClauseReceiverContext(p *CatchClauseReceiverContext)

+ func InitEmptyChannelInputStatementContext(p *ChannelInputStatementContext)

+ func InitEmptyChannelOutputExpressionContext(p *ChannelOutputExpressionContext)

+ func InitEmptyClassBodyContext(p *ClassBodyContext)

+ func InitEmptyClassBuiltinMethodContext(p *ClassBuiltinMethodContext)

+ func InitEmptyClassBuiltinMethodModifierContext(p *ClassBuiltinMethodModifierContext)

+ func InitEmptyClassBuiltinParametersContext(p *ClassBuiltinParametersContext)

+ func InitEmptyClassDeclarationContext(p *ClassDeclarationContext)

+ func InitEmptyClassInitializeExpressionContext(p *ClassInitializeExpressionContext)

+ func InitEmptyClassMemberContext(p *ClassMemberContext)

+ func InitEmptyClassMemberModifierContext(p *ClassMemberModifierContext)

+ func InitEmptyClassMethodContext(p *ClassMethodContext)

+ func InitEmptyClassMethodModifierContext(p *ClassMethodModifierContext)

+ func InitEmptyClassModifierContext(p *ClassModifierContext)

+ func InitEmptyClassNamedParameterAccessPointContext(p *ClassNamedParameterAccessPointContext)

+ func InitEmptyClassNamedParameterContext(p *ClassNamedParameterContext)

+ func InitEmptyClassNamedParameterListContext(p *ClassNamedParameterListContext)

+ func InitEmptyClassNamedParametersContext(p *ClassNamedParametersContext)

+ func InitEmptyClassSuperContext(p *ClassSuperContext)

+ func InitEmptyCommandAccessPointContext(p *CommandAccessPointContext)

+ func InitEmptyCommandExpressionContext(p *CommandExpressionContext)

+ func InitEmptyCommandJoinContext(p *CommandJoinContext)

+ func InitEmptyCommandMemberAccessContext(p *CommandMemberAccessContext)

+ func InitEmptyCommandStreamContext(p *CommandStreamContext)

+ func InitEmptyCommentContext(p *CommentContext)

+ func InitEmptyCompositeTypeContext(p *CompositeTypeContext)

+ func InitEmptyComptimeExpressionContext(p *ComptimeExpressionContext)

+ func InitEmptyConditionalBoolExpressionContext(p *ConditionalBoolExpressionContext)

+ func InitEmptyConditionalExpressionContext(p *ConditionalExpressionContext)

+ func InitEmptyContinueStatementContext(p *ContinueStatementContext)

+ func InitEmptyDeclareStatementContext(p *DeclareStatementContext)

+ func InitEmptyDeferStatementContext(p *DeferStatementContext)

+ func InitEmptyDoWhileStatementContext(p *DoWhileStatementContext)

+ func InitEmptyEnumAssociatedConstructorContext(p *EnumAssociatedConstructorContext)

+ func InitEmptyEnumAssociatedFieldContext(p *EnumAssociatedFieldContext)

+ func InitEmptyEnumAssociatedFieldsContext(p *EnumAssociatedFieldsContext)

+ func InitEmptyEnumAssociatedMethodsContext(p *EnumAssociatedMethodsContext)

+ func InitEmptyEnumAssociatedValueContext(p *EnumAssociatedValueContext)

+ func InitEmptyEnumAssociatedValuesContext(p *EnumAssociatedValuesContext)

+ func InitEmptyEnumBodyADTContext(p *EnumBodyADTContext)

+ func InitEmptyEnumBodyAssociatedContext(p *EnumBodyAssociatedContext)

+ func InitEmptyEnumBodySimpleContext(p *EnumBodySimpleContext)

+ func InitEmptyEnumBuiltinMethodModifierContext(p *EnumBuiltinMethodModifierContext)

+ func InitEmptyEnumConstructorContext(p *EnumConstructorContext)

+ func InitEmptyEnumConstructorDirectInitContext(p *EnumConstructorDirectInitContext)

+ func InitEmptyEnumConstructorInitContext(p *EnumConstructorInitContext)

+ func InitEmptyEnumConstructorNameContext(p *EnumConstructorNameContext)

+ func InitEmptyEnumConstructorParametersContext(p *EnumConstructorParametersContext)

+ func InitEmptyEnumDeclarationContext(p *EnumDeclarationContext)

+ func InitEmptyEnumFieldContext(p *EnumFieldContext)

+ func InitEmptyEnumFieldModifierContext(p *EnumFieldModifierContext)

+ func InitEmptyEnumInitializeContext(p *EnumInitializeContext)

+ func InitEmptyEnumInitializeMemberContext(p *EnumInitializeMemberContext)

+ func InitEmptyEnumMemberContext(p *EnumMemberContext)

+ func InitEmptyEnumMemberModifierContext(p *EnumMemberModifierContext)

+ func InitEmptyEnumMethodContext(p *EnumMethodContext)

+ func InitEmptyEnumMethodModifierContext(p *EnumMethodModifierContext)

+ func InitEmptyEnumMethodsContext(p *EnumMethodsContext)

+ func InitEmptyEnumModifierContext(p *EnumModifierContext)

+ func InitEmptyEnumValueContext(p *EnumValueContext)

+ func InitEmptyEnumVariantContext(p *EnumVariantContext)

+ func InitEmptyExpressionContext(p *ExpressionContext)

+ func InitEmptyExpressionListContext(p *ExpressionListContext)

+ func InitEmptyExpressionStatementContext(p *ExpressionStatementContext)

+ func InitEmptyExtendClassContext(p *ExtendClassContext)

+ func InitEmptyExtendDeclarationContext(p *ExtendDeclarationContext)

+ func InitEmptyExtendEnumContext(p *ExtendEnumContext)

+ func InitEmptyExtendModContext(p *ExtendModContext)

+ func InitEmptyExtendTraitContext(p *ExtendTraitContext)

+ func InitEmptyExtendTypeContext(p *ExtendTypeContext)

+ func InitEmptyExternDeclarationContext(p *ExternDeclarationContext)

+ func InitEmptyExternItemContext(p *ExternItemContext)

+ func InitEmptyExternListContext(p *ExternListContext)

+ func InitEmptyFactorContext(p *FactorContext)

+ func InitEmptyFileContext(p *FileContext)

+ func InitEmptyFileExpressionContext(p *FileExpressionContext)

+ func InitEmptyFinallyClauseContext(p *FinallyClauseContext)

+ func InitEmptyForClauseContext(p *ForClauseContext)

+ func InitEmptyForStatementContext(p *ForStatementContext)

+ func InitEmptyForeachClauseContext(p *ForeachClauseContext)

+ func InitEmptyForeachStatementContext(p *ForeachStatementContext)

+ func InitEmptyForeachVariableNameContext(p *ForeachVariableNameContext)

+ func InitEmptyFunctionDeclarationContext(p *FunctionDeclarationContext)

+ func InitEmptyFunctionModifierContext(p *FunctionModifierContext)

+ func InitEmptyFunctionReturnValueContext(p *FunctionReturnValueContext)

+ func InitEmptyFunctionSignatureContext(p *FunctionSignatureContext)

+ func InitEmptyFunctionTypeContext(p *FunctionTypeContext)

+ func InitEmptyGenericArgumentsContext(p *GenericArgumentsContext)

+ func InitEmptyGenericParameterContext(p *GenericParameterContext)

+ func InitEmptyGenericParameterListContext(p *GenericParameterListContext)

+ func InitEmptyGenericParametersContext(p *GenericParametersContext)

+ func InitEmptyIdentifierAsIdentifierContext(p *IdentifierAsIdentifierContext)

+ func InitEmptyIfStatementContext(p *IfStatementContext)

+ func InitEmptyImplDeclarationBindingContext(p *ImplDeclarationBindingContext)

+ func InitEmptyImplDeclarationBodyContext(p *ImplDeclarationBodyContext)

+ func InitEmptyImplDeclarationContext(p *ImplDeclarationContext)

+ func InitEmptyImportAllContext(p *ImportAllContext)

+ func InitEmptyImportDeclarationContext(p *ImportDeclarationContext)

+ func InitEmptyImportMultiContext(p *ImportMultiContext)

+ func InitEmptyImportSingleContext(p *ImportSingleContext)

+ func InitEmptyIncDecExpressionContext(p *IncDecExpressionContext)

+ func InitEmptyIntersectionTypeContext(p *IntersectionTypeContext)

+ func InitEmptyLambdaAssignStatementContext(p *LambdaAssignStatementContext)

+ func InitEmptyLambdaBodyContext(p *LambdaBodyContext)

+ func InitEmptyLambdaExpressionContext(p *LambdaExpressionContext)

+ func InitEmptyLambdaFunctionDeclarationContext(p *LambdaFunctionDeclarationContext)

+ func InitEmptyListExpressionContext(p *ListExpressionContext)

+ func InitEmptyLiteralContext(p *LiteralContext)

+ func InitEmptyLogicalExpressionContext(p *LogicalExpressionContext)

+ func InitEmptyLongOptionContext(p *LongOptionContext)

+ func InitEmptyLoopLabelContext(p *LoopLabelContext)

+ func InitEmptyLoopStatementContext(p *LoopStatementContext)

+ func InitEmptyMacroStatementContext(p *MacroStatementContext)

+ func InitEmptyMapExpressionContext(p *MapExpressionContext)

+ func InitEmptyMatchCaseBodyContext(p *MatchCaseBodyContext)

+ func InitEmptyMatchCaseClauseContext(p *MatchCaseClauseContext)

+ func InitEmptyMatchDefaultClauseContext(p *MatchDefaultClauseContext)

+ func InitEmptyMatchEnumContext(p *MatchEnumContext)

+ func InitEmptyMatchEnumMemberContext(p *MatchEnumMemberContext)

+ func InitEmptyMatchStatementContext(p *MatchStatementContext)

+ func InitEmptyMatchTripleContext(p *MatchTripleContext)

+ func InitEmptyMatchTripleValueContext(p *MatchTripleValueContext)

+ func InitEmptyMemberAccessContext(p *MemberAccessContext)

+ func InitEmptyMemberAccessPointContext(p *MemberAccessPointContext)

+ func InitEmptyMethodExpressionContext(p *MethodExpressionContext)

+ func InitEmptyModuleDeclarationContext(p *ModuleDeclarationContext)

+ func InitEmptyModuleStatementContext(p *ModuleStatementContext)

+ func InitEmptyMulDivExpressionContext(p *MulDivExpressionContext)

+ func InitEmptyNamedArgumentContext(p *NamedArgumentContext)

+ func InitEmptyNamedArgumentListContext(p *NamedArgumentListContext)

+ func InitEmptyNamedParameterContext(p *NamedParameterContext)

+ func InitEmptyNamedParameterListContext(p *NamedParameterListContext)

+ func InitEmptyNamedParametersContext(p *NamedParametersContext)

+ func InitEmptyNewDelExpressionContext(p *NewDelExpressionContext)

+ func InitEmptyNullableTypeContext(p *NullableTypeContext)

+ func InitEmptyObjectTypeContext(p *ObjectTypeContext)

+ func InitEmptyObjectTypeMemberContext(p *ObjectTypeMemberContext)

+ func InitEmptyOperatorIdentifierContext(p *OperatorIdentifierContext)

+ func InitEmptyOptionContext(p *OptionContext)

+ func InitEmptyPairContext(p *PairContext)

+ func InitEmptyPostIncDecExpressionContext(p *PostIncDecExpressionContext)

+ func InitEmptyPreIncDecExpressionContext(p *PreIncDecExpressionContext)

+ func InitEmptyRangeClauseContext(p *RangeClauseContext)

+ func InitEmptyRangeExpressionContext(p *RangeExpressionContext)

+ func InitEmptyRangeStatementContext(p *RangeStatementContext)

+ func InitEmptyReceiverArgumentListContext(p *ReceiverArgumentListContext)

+ func InitEmptyReceiverParameterContext(p *ReceiverParameterContext)

+ func InitEmptyReceiverParameterListContext(p *ReceiverParameterListContext)

+ func InitEmptyReceiverParametersContext(p *ReceiverParametersContext)

+ func InitEmptyReturnStatementContext(p *ReturnStatementContext)

+ func InitEmptyShiftExpressionContext(p *ShiftExpressionContext)

+ func InitEmptyShortOptionContext(p *ShortOptionContext)

+ func InitEmptyStandardFunctionDeclarationContext(p *StandardFunctionDeclarationContext)

+ func InitEmptyStatementContext(p *StatementContext)

+ func InitEmptyThrowStatementContext(p *ThrowStatementContext)

+ func InitEmptyTraitBodyContext(p *TraitBodyContext)

+ func InitEmptyTraitDeclarationContext(p *TraitDeclarationContext)

+ func InitEmptyTraitMemberContext(p *TraitMemberContext)

+ func InitEmptyTraitMemberModifierContext(p *TraitMemberModifierContext)

+ func InitEmptyTraitModifierContext(p *TraitModifierContext)

+ func InitEmptyTripleExpressionContext(p *TripleExpressionContext)

+ func InitEmptyTryStatementContext(p *TryStatementContext)

+ func InitEmptyTupleTypeContext(p *TupleTypeContext)

+ func InitEmptyTypeAccessPointContext(p *TypeAccessPointContext)

+ func InitEmptyTypeContext(p *TypeContext)

+ func InitEmptyTypeDeclarationContext(p *TypeDeclarationContext)

+ func InitEmptyTypeListContext(p *TypeListContext)

+ func InitEmptyTypeLiteralContext(p *TypeLiteralContext)

+ func InitEmptyTypeofExpressionContext(p *TypeofExpressionContext)

+ func InitEmptyUnionTypeContext(p *UnionTypeContext)

+ func InitEmptyUnsafeExpressionContext(p *UnsafeExpressionContext)

+ func InitEmptyUseAllContext(p *UseAllContext)

+ func InitEmptyUseDeclarationContext(p *UseDeclarationContext)

+ func InitEmptyUseMultiContext(p *UseMultiContext)

+ func InitEmptyUseSingleContext(p *UseSingleContext)

+ func InitEmptyVariableExpressionContext(p *VariableExpressionContext)

+ func InitEmptyVariableNameContext(p *VariableNameContext)

+ func InitEmptyVariableNameListContext(p *VariableNameListContext)

+ func InitEmptyVariableNamesContext(p *VariableNamesContext)

+ func InitEmptyVariableNullableExpressionContext(p *VariableNullableExpressionContext)

+ func InitEmptyVariableNullableExpressionsContext(p *VariableNullableExpressionsContext)

+ func InitEmptyWhileStatementContext(p *WhileStatementContext)

+ func NewhuloLexer(input antlr.CharStream) *huloLexer

+ func NewhuloParser(input antlr.TokenStream) *huloParser

+ type AddSubExpressionContext struct

+ func NewAddSubExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AddSubExpressionContext

+ func NewEmptyAddSubExpressionContext() *AddSubExpressionContext

+ func (*AddSubExpressionContext) IsAddSubExpressionContext()

+ func (s *AddSubExpressionContext) ADD(i int) antlr.TerminalNode

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

+ func (s *AddSubExpressionContext) AllADD() []antlr.TerminalNode

+ func (s *AddSubExpressionContext) AllMulDivExpression() []IMulDivExpressionContext

+ func (s *AddSubExpressionContext) AllSUB() []antlr.TerminalNode

+ func (s *AddSubExpressionContext) GetAddSubOp() antlr.Token

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

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

+ func (s *AddSubExpressionContext) MulDivExpression(i int) IMulDivExpressionContext

+ func (s *AddSubExpressionContext) SUB(i int) antlr.TerminalNode

+ func (s *AddSubExpressionContext) SetAddSubOp(v antlr.Token)

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

+ type ArrayTypeContext struct

+ func NewArrayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayTypeContext

+ func NewEmptyArrayTypeContext() *ArrayTypeContext

+ func (*ArrayTypeContext) IsArrayTypeContext()

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

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

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

+ func (s *ArrayTypeContext) LBRACK() antlr.TerminalNode

+ func (s *ArrayTypeContext) NumberLiteral() antlr.TerminalNode

+ func (s *ArrayTypeContext) RBRACK() antlr.TerminalNode

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

+ func (s *ArrayTypeContext) Type_() ITypeContext

+ type AsExpressionContext struct

+ func NewAsExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AsExpressionContext

+ func NewEmptyAsExpressionContext() *AsExpressionContext

+ func (*AsExpressionContext) IsAsExpressionContext()

+ func (s *AsExpressionContext) AS() antlr.TerminalNode

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

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

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

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

+ func (s *AsExpressionContext) Type_() ITypeContext

+ func (s *AsExpressionContext) VariableExpression() IVariableExpressionContext

+ type AsIdentifierContext struct

+ func NewAsIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AsIdentifierContext

+ func NewEmptyAsIdentifierContext() *AsIdentifierContext

+ func (*AsIdentifierContext) IsAsIdentifierContext()

+ func (s *AsIdentifierContext) AS() antlr.TerminalNode

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

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

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

+ func (s *AsIdentifierContext) Identifier() antlr.TerminalNode

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

+ type AssignStatementContext struct

+ func NewAssignStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignStatementContext

+ func NewEmptyAssignStatementContext() *AssignStatementContext

+ func (*AssignStatementContext) IsAssignStatementContext()

+ func (s *AssignStatementContext) ADD_ASSIGN() antlr.TerminalNode

+ func (s *AssignStatementContext) AND_ASSIGN() antlr.TerminalNode

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

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

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

+ func (s *AssignStatementContext) CONST() antlr.TerminalNode

+ func (s *AssignStatementContext) DIV_ASSIGN() antlr.TerminalNode

+ func (s *AssignStatementContext) EXP_ASSIGN() antlr.TerminalNode

+ func (s *AssignStatementContext) Expression() IExpressionContext

+ func (s *AssignStatementContext) GetAssignModifier() antlr.Token

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

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

+ func (s *AssignStatementContext) Identifier() antlr.TerminalNode

+ func (s *AssignStatementContext) LET() antlr.TerminalNode

+ func (s *AssignStatementContext) MOD_ASSIGN() antlr.TerminalNode

+ func (s *AssignStatementContext) MUL_ASSIGN() antlr.TerminalNode

+ func (s *AssignStatementContext) MatchStatement() IMatchStatementContext

+ func (s *AssignStatementContext) SUB_ASSIGN() antlr.TerminalNode

+ func (s *AssignStatementContext) SetAssignModifier(v antlr.Token)

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

+ func (s *AssignStatementContext) Type_() ITypeContext

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

+ func (s *AssignStatementContext) VariableExpression() IVariableExpressionContext

+ func (s *AssignStatementContext) VariableNames() IVariableNamesContext

+ func (s *AssignStatementContext) VariableNullableExpressions() IVariableNullableExpressionsContext

+ type BasehuloParserVisitor struct

+ func (v *BasehuloParserVisitor) VisitAddSubExpression(ctx *AddSubExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitArrayType(ctx *ArrayTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitAsExpression(ctx *AsExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitAsIdentifier(ctx *AsIdentifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitAssignStatement(ctx *AssignStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitBlock(ctx *BlockContext) interface{}

+ func (v *BasehuloParserVisitor) VisitBreakStatement(ctx *BreakStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCallExpression(ctx *CallExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCallExpressionLinkedList(ctx *CallExpressionLinkedListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCatchClause(ctx *CatchClauseContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCatchClauseReceiver(ctx *CatchClauseReceiverContext) interface{}

+ func (v *BasehuloParserVisitor) VisitChannelInputStatement(ctx *ChannelInputStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitChannelOutputExpression(ctx *ChannelOutputExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassBody(ctx *ClassBodyContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassBuiltinMethod(ctx *ClassBuiltinMethodContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassBuiltinMethodModifier(ctx *ClassBuiltinMethodModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassBuiltinParameters(ctx *ClassBuiltinParametersContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassDeclaration(ctx *ClassDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassInitializeExpression(ctx *ClassInitializeExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassMember(ctx *ClassMemberContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassMemberModifier(ctx *ClassMemberModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassMethod(ctx *ClassMethodContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassMethodModifier(ctx *ClassMethodModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassModifier(ctx *ClassModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassNamedParameter(ctx *ClassNamedParameterContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassNamedParameterAccessPoint(ctx *ClassNamedParameterAccessPointContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassNamedParameterList(ctx *ClassNamedParameterListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassNamedParameters(ctx *ClassNamedParametersContext) interface{}

+ func (v *BasehuloParserVisitor) VisitClassSuper(ctx *ClassSuperContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCommandAccessPoint(ctx *CommandAccessPointContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCommandExpression(ctx *CommandExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCommandJoin(ctx *CommandJoinContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCommandMemberAccess(ctx *CommandMemberAccessContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCommandStream(ctx *CommandStreamContext) interface{}

+ func (v *BasehuloParserVisitor) VisitComment(ctx *CommentContext) interface{}

+ func (v *BasehuloParserVisitor) VisitCompositeType(ctx *CompositeTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitComptimeExpression(ctx *ComptimeExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitConditionalBoolExpression(ctx *ConditionalBoolExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitConditionalExpression(ctx *ConditionalExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitContinueStatement(ctx *ContinueStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitDeclareStatement(ctx *DeclareStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitDeferStatement(ctx *DeferStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitDoWhileStatement(ctx *DoWhileStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumAssociatedConstructor(ctx *EnumAssociatedConstructorContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumAssociatedField(ctx *EnumAssociatedFieldContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumAssociatedFields(ctx *EnumAssociatedFieldsContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumAssociatedMethods(ctx *EnumAssociatedMethodsContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumAssociatedValue(ctx *EnumAssociatedValueContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumAssociatedValues(ctx *EnumAssociatedValuesContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumBodyADT(ctx *EnumBodyADTContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumBodyAssociated(ctx *EnumBodyAssociatedContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumBodySimple(ctx *EnumBodySimpleContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumBuiltinMethodModifier(ctx *EnumBuiltinMethodModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumConstructor(ctx *EnumConstructorContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumConstructorDirectInit(ctx *EnumConstructorDirectInitContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumConstructorInit(ctx *EnumConstructorInitContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumConstructorName(ctx *EnumConstructorNameContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumConstructorParameters(ctx *EnumConstructorParametersContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumDeclaration(ctx *EnumDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumField(ctx *EnumFieldContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumFieldModifier(ctx *EnumFieldModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumInitialize(ctx *EnumInitializeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumInitializeMember(ctx *EnumInitializeMemberContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumMember(ctx *EnumMemberContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumMemberModifier(ctx *EnumMemberModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumMethod(ctx *EnumMethodContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumMethodModifier(ctx *EnumMethodModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumMethods(ctx *EnumMethodsContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumModifier(ctx *EnumModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumValue(ctx *EnumValueContext) interface{}

+ func (v *BasehuloParserVisitor) VisitEnumVariant(ctx *EnumVariantContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExpression(ctx *ExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExpressionList(ctx *ExpressionListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExpressionStatement(ctx *ExpressionStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExtendClass(ctx *ExtendClassContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExtendDeclaration(ctx *ExtendDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExtendEnum(ctx *ExtendEnumContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExtendMod(ctx *ExtendModContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExtendTrait(ctx *ExtendTraitContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExtendType(ctx *ExtendTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExternDeclaration(ctx *ExternDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExternItem(ctx *ExternItemContext) interface{}

+ func (v *BasehuloParserVisitor) VisitExternList(ctx *ExternListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFactor(ctx *FactorContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFile(ctx *FileContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFileExpression(ctx *FileExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFinallyClause(ctx *FinallyClauseContext) interface{}

+ func (v *BasehuloParserVisitor) VisitForClause(ctx *ForClauseContext) interface{}

+ func (v *BasehuloParserVisitor) VisitForStatement(ctx *ForStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitForeachClause(ctx *ForeachClauseContext) interface{}

+ func (v *BasehuloParserVisitor) VisitForeachStatement(ctx *ForeachStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitForeachVariableName(ctx *ForeachVariableNameContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFunctionDeclaration(ctx *FunctionDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFunctionModifier(ctx *FunctionModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFunctionReturnValue(ctx *FunctionReturnValueContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFunctionSignature(ctx *FunctionSignatureContext) interface{}

+ func (v *BasehuloParserVisitor) VisitFunctionType(ctx *FunctionTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitGenericArguments(ctx *GenericArgumentsContext) interface{}

+ func (v *BasehuloParserVisitor) VisitGenericParameter(ctx *GenericParameterContext) interface{}

+ func (v *BasehuloParserVisitor) VisitGenericParameterList(ctx *GenericParameterListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitGenericParameters(ctx *GenericParametersContext) interface{}

+ func (v *BasehuloParserVisitor) VisitIdentifierAsIdentifier(ctx *IdentifierAsIdentifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitIfStatement(ctx *IfStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitImplDeclaration(ctx *ImplDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitImplDeclarationBinding(ctx *ImplDeclarationBindingContext) interface{}

+ func (v *BasehuloParserVisitor) VisitImplDeclarationBody(ctx *ImplDeclarationBodyContext) interface{}

+ func (v *BasehuloParserVisitor) VisitImportAll(ctx *ImportAllContext) interface{}

+ func (v *BasehuloParserVisitor) VisitImportDeclaration(ctx *ImportDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitImportMulti(ctx *ImportMultiContext) interface{}

+ func (v *BasehuloParserVisitor) VisitImportSingle(ctx *ImportSingleContext) interface{}

+ func (v *BasehuloParserVisitor) VisitIncDecExpression(ctx *IncDecExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitIntersectionType(ctx *IntersectionTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLambdaAssignStatement(ctx *LambdaAssignStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLambdaBody(ctx *LambdaBodyContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLambdaExpression(ctx *LambdaExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLambdaFunctionDeclaration(ctx *LambdaFunctionDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitListExpression(ctx *ListExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLiteral(ctx *LiteralContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLogicalExpression(ctx *LogicalExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLongOption(ctx *LongOptionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLoopLabel(ctx *LoopLabelContext) interface{}

+ func (v *BasehuloParserVisitor) VisitLoopStatement(ctx *LoopStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMacroStatement(ctx *MacroStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMapExpression(ctx *MapExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMatchCaseBody(ctx *MatchCaseBodyContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMatchCaseClause(ctx *MatchCaseClauseContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMatchDefaultClause(ctx *MatchDefaultClauseContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMatchEnum(ctx *MatchEnumContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMatchEnumMember(ctx *MatchEnumMemberContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMatchStatement(ctx *MatchStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMatchTriple(ctx *MatchTripleContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMatchTripleValue(ctx *MatchTripleValueContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMemberAccess(ctx *MemberAccessContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMemberAccessPoint(ctx *MemberAccessPointContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMethodExpression(ctx *MethodExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitModuleDeclaration(ctx *ModuleDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitModuleStatement(ctx *ModuleStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitMulDivExpression(ctx *MulDivExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitNamedArgument(ctx *NamedArgumentContext) interface{}

+ func (v *BasehuloParserVisitor) VisitNamedArgumentList(ctx *NamedArgumentListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitNamedParameter(ctx *NamedParameterContext) interface{}

+ func (v *BasehuloParserVisitor) VisitNamedParameterList(ctx *NamedParameterListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitNamedParameters(ctx *NamedParametersContext) interface{}

+ func (v *BasehuloParserVisitor) VisitNewDelExpression(ctx *NewDelExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitNullableType(ctx *NullableTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitObjectType(ctx *ObjectTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitObjectTypeMember(ctx *ObjectTypeMemberContext) interface{}

+ func (v *BasehuloParserVisitor) VisitOperatorIdentifier(ctx *OperatorIdentifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitOption(ctx *OptionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitPair(ctx *PairContext) interface{}

+ func (v *BasehuloParserVisitor) VisitPostIncDecExpression(ctx *PostIncDecExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitPreIncDecExpression(ctx *PreIncDecExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitRangeClause(ctx *RangeClauseContext) interface{}

+ func (v *BasehuloParserVisitor) VisitRangeExpression(ctx *RangeExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitRangeStatement(ctx *RangeStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitReceiverArgumentList(ctx *ReceiverArgumentListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitReceiverParameter(ctx *ReceiverParameterContext) interface{}

+ func (v *BasehuloParserVisitor) VisitReceiverParameterList(ctx *ReceiverParameterListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitReceiverParameters(ctx *ReceiverParametersContext) interface{}

+ func (v *BasehuloParserVisitor) VisitReturnStatement(ctx *ReturnStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitShiftExpression(ctx *ShiftExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitShortOption(ctx *ShortOptionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitStandardFunctionDeclaration(ctx *StandardFunctionDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitStatement(ctx *StatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitThrowStatement(ctx *ThrowStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTraitBody(ctx *TraitBodyContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTraitDeclaration(ctx *TraitDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTraitMember(ctx *TraitMemberContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTraitMemberModifier(ctx *TraitMemberModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTraitModifier(ctx *TraitModifierContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTripleExpression(ctx *TripleExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTryStatement(ctx *TryStatementContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTupleType(ctx *TupleTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitType(ctx *TypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTypeAccessPoint(ctx *TypeAccessPointContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTypeDeclaration(ctx *TypeDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTypeList(ctx *TypeListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTypeLiteral(ctx *TypeLiteralContext) interface{}

+ func (v *BasehuloParserVisitor) VisitTypeofExpression(ctx *TypeofExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitUnionType(ctx *UnionTypeContext) interface{}

+ func (v *BasehuloParserVisitor) VisitUnsafeExpression(ctx *UnsafeExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitUseAll(ctx *UseAllContext) interface{}

+ func (v *BasehuloParserVisitor) VisitUseDeclaration(ctx *UseDeclarationContext) interface{}

+ func (v *BasehuloParserVisitor) VisitUseMulti(ctx *UseMultiContext) interface{}

+ func (v *BasehuloParserVisitor) VisitUseSingle(ctx *UseSingleContext) interface{}

+ func (v *BasehuloParserVisitor) VisitVariableExpression(ctx *VariableExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitVariableName(ctx *VariableNameContext) interface{}

+ func (v *BasehuloParserVisitor) VisitVariableNameList(ctx *VariableNameListContext) interface{}

+ func (v *BasehuloParserVisitor) VisitVariableNames(ctx *VariableNamesContext) interface{}

+ func (v *BasehuloParserVisitor) VisitVariableNullableExpression(ctx *VariableNullableExpressionContext) interface{}

+ func (v *BasehuloParserVisitor) VisitVariableNullableExpressions(ctx *VariableNullableExpressionsContext) interface{}

+ func (v *BasehuloParserVisitor) VisitWhileStatement(ctx *WhileStatementContext) interface{}

+ type BlockContext struct

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

+ func NewEmptyBlockContext() *BlockContext

+ func (*BlockContext) IsBlockContext()

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

+ func (s *BlockContext) AllSEMI() []antlr.TerminalNode

+ func (s *BlockContext) AllStatement() []IStatementContext

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

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

+ func (s *BlockContext) LBRACE() antlr.TerminalNode

+ func (s *BlockContext) RBRACE() antlr.TerminalNode

+ func (s *BlockContext) SEMI(i int) antlr.TerminalNode

+ func (s *BlockContext) Statement(i int) IStatementContext

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

+ type BreakStatementContext struct

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

+ func NewEmptyBreakStatementContext() *BreakStatementContext

+ func (*BreakStatementContext) IsBreakStatementContext()

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

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

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

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

+ func (s *BreakStatementContext) Identifier() antlr.TerminalNode

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

+ type CallExpressionContext struct

+ func NewCallExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallExpressionContext

+ func NewEmptyCallExpressionContext() *CallExpressionContext

+ func (*CallExpressionContext) IsCallExpressionContext()

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

+ func (s *CallExpressionContext) CallExpressionLinkedList() ICallExpressionLinkedListContext

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

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

+ func (s *CallExpressionContext) LPAREN() antlr.TerminalNode

+ func (s *CallExpressionContext) MemberAccess() IMemberAccessContext

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

+ func (s *CallExpressionContext) RPAREN() antlr.TerminalNode

+ func (s *CallExpressionContext) ReceiverArgumentList() IReceiverArgumentListContext

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

+ type CallExpressionLinkedListContext struct

+ func NewCallExpressionLinkedListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallExpressionLinkedListContext

+ func NewEmptyCallExpressionLinkedListContext() *CallExpressionLinkedListContext

+ func (*CallExpressionLinkedListContext) IsCallExpressionLinkedListContext()

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

+ func (s *CallExpressionLinkedListContext) CallExpressionLinkedList() ICallExpressionLinkedListContext

+ func (s *CallExpressionLinkedListContext) DOT() antlr.TerminalNode

+ func (s *CallExpressionLinkedListContext) DOUBLE_DOT() antlr.TerminalNode

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

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

+ func (s *CallExpressionLinkedListContext) Identifier() antlr.TerminalNode

+ func (s *CallExpressionLinkedListContext) LPAREN() antlr.TerminalNode

+ func (s *CallExpressionLinkedListContext) RPAREN() antlr.TerminalNode

+ func (s *CallExpressionLinkedListContext) ReceiverArgumentList() IReceiverArgumentListContext

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

+ type CatchClauseContext struct

+ func NewCatchClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchClauseContext

+ func NewEmptyCatchClauseContext() *CatchClauseContext

+ func (*CatchClauseContext) IsCatchClauseContext()

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

+ func (s *CatchClauseContext) Block() IBlockContext

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

+ func (s *CatchClauseContext) CatchClauseReceiver() ICatchClauseReceiverContext

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

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

+ func (s *CatchClauseContext) MemberAccess() IMemberAccessContext

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

+ type CatchClauseReceiverContext struct

+ func NewCatchClauseReceiverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchClauseReceiverContext

+ func NewEmptyCatchClauseReceiverContext() *CatchClauseReceiverContext

+ func (*CatchClauseReceiverContext) IsCatchClauseReceiverContext()

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

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

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

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

+ func (s *CatchClauseReceiverContext) Identifier() antlr.TerminalNode

+ func (s *CatchClauseReceiverContext) LPAREN() antlr.TerminalNode

+ func (s *CatchClauseReceiverContext) RPAREN() antlr.TerminalNode

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

+ func (s *CatchClauseReceiverContext) Type_() ITypeContext

+ type ChannelInputStatementContext struct

+ func NewChannelInputStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChannelInputStatementContext

+ func NewEmptyChannelInputStatementContext() *ChannelInputStatementContext

+ func (*ChannelInputStatementContext) IsChannelInputStatementContext()

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

+ func (s *ChannelInputStatementContext) BACKARROW() antlr.TerminalNode

+ func (s *ChannelInputStatementContext) BITAND() antlr.TerminalNode

+ func (s *ChannelInputStatementContext) GetChannelPayload() antlr.Token

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

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

+ func (s *ChannelInputStatementContext) NumberLiteral() antlr.TerminalNode

+ func (s *ChannelInputStatementContext) SetChannelPayload(v antlr.Token)

+ func (s *ChannelInputStatementContext) StringLiteral() antlr.TerminalNode

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

+ func (s *ChannelInputStatementContext) VariableExpression() IVariableExpressionContext

+ type ChannelOutputExpressionContext struct

+ func NewChannelOutputExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChannelOutputExpressionContext

+ func NewEmptyChannelOutputExpressionContext() *ChannelOutputExpressionContext

+ func (*ChannelOutputExpressionContext) IsChannelOutputExpressionContext()

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

+ func (s *ChannelOutputExpressionContext) BACKARROW() antlr.TerminalNode

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

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

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

+ func (s *ChannelOutputExpressionContext) VariableExpression() IVariableExpressionContext

+ type ClassBodyContext struct

+ func NewClassBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassBodyContext

+ func NewEmptyClassBodyContext() *ClassBodyContext

+ func (*ClassBodyContext) IsClassBodyContext()

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

+ func (s *ClassBodyContext) AllClassBuiltinMethod() []IClassBuiltinMethodContext

+ func (s *ClassBodyContext) AllClassMember() []IClassMemberContext

+ func (s *ClassBodyContext) AllClassMethod() []IClassMethodContext

+ func (s *ClassBodyContext) AllComment() []ICommentContext

+ func (s *ClassBodyContext) AllSEMI() []antlr.TerminalNode

+ func (s *ClassBodyContext) ClassBuiltinMethod(i int) IClassBuiltinMethodContext

+ func (s *ClassBodyContext) ClassMember(i int) IClassMemberContext

+ func (s *ClassBodyContext) ClassMethod(i int) IClassMethodContext

+ func (s *ClassBodyContext) Comment(i int) ICommentContext

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

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

+ func (s *ClassBodyContext) LBRACE() antlr.TerminalNode

+ func (s *ClassBodyContext) RBRACE() antlr.TerminalNode

+ func (s *ClassBodyContext) SEMI(i int) antlr.TerminalNode

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

+ type ClassBuiltinMethodContext struct

+ func NewClassBuiltinMethodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassBuiltinMethodContext

+ func NewEmptyClassBuiltinMethodContext() *ClassBuiltinMethodContext

+ func (*ClassBuiltinMethodContext) IsClassBuiltinMethodContext()

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

+ func (s *ClassBuiltinMethodContext) AllMacroStatement() []IMacroStatementContext

+ func (s *ClassBuiltinMethodContext) Block() IBlockContext

+ func (s *ClassBuiltinMethodContext) ClassBuiltinMethodModifier() IClassBuiltinMethodModifierContext

+ func (s *ClassBuiltinMethodContext) ClassBuiltinParameters() IClassBuiltinParametersContext

+ func (s *ClassBuiltinMethodContext) DOUBLE_ARROW() antlr.TerminalNode

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

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

+ func (s *ClassBuiltinMethodContext) Identifier() antlr.TerminalNode

+ func (s *ClassBuiltinMethodContext) MacroStatement(i int) IMacroStatementContext

+ func (s *ClassBuiltinMethodContext) THROWS() antlr.TerminalNode

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

+ type ClassBuiltinMethodModifierContext struct

+ func NewClassBuiltinMethodModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassBuiltinMethodModifierContext

+ func NewEmptyClassBuiltinMethodModifierContext() *ClassBuiltinMethodModifierContext

+ func (*ClassBuiltinMethodModifierContext) IsClassBuiltinMethodModifierContext()

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

+ func (s *ClassBuiltinMethodModifierContext) CONST() antlr.TerminalNode

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

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

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

+ type ClassBuiltinParametersContext struct

+ func NewClassBuiltinParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassBuiltinParametersContext

+ func NewEmptyClassBuiltinParametersContext() *ClassBuiltinParametersContext

+ func (*ClassBuiltinParametersContext) IsClassBuiltinParametersContext()

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

+ func (s *ClassBuiltinParametersContext) COMMA() antlr.TerminalNode

+ func (s *ClassBuiltinParametersContext) ClassNamedParameters() IClassNamedParametersContext

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

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

+ func (s *ClassBuiltinParametersContext) LPAREN() antlr.TerminalNode

+ func (s *ClassBuiltinParametersContext) RPAREN() antlr.TerminalNode

+ func (s *ClassBuiltinParametersContext) ReceiverParameterList() IReceiverParameterListContext

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

+ type ClassDeclarationContext struct

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

+ func NewEmptyClassDeclarationContext() *ClassDeclarationContext

+ func (*ClassDeclarationContext) IsClassDeclarationContext()

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

+ func (s *ClassDeclarationContext) AllClassModifier() []IClassModifierContext

+ func (s *ClassDeclarationContext) AllMacroStatement() []IMacroStatementContext

+ func (s *ClassDeclarationContext) CLASS() antlr.TerminalNode

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

+ func (s *ClassDeclarationContext) ClassBody() IClassBodyContext

+ func (s *ClassDeclarationContext) ClassModifier(i int) IClassModifierContext

+ func (s *ClassDeclarationContext) ClassSuper() IClassSuperContext

+ func (s *ClassDeclarationContext) GenericParameters() IGenericParametersContext

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

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

+ func (s *ClassDeclarationContext) Identifier() antlr.TerminalNode

+ func (s *ClassDeclarationContext) MacroStatement(i int) IMacroStatementContext

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

+ type ClassInitializeExpressionContext struct

+ func NewClassInitializeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassInitializeExpressionContext

+ func NewEmptyClassInitializeExpressionContext() *ClassInitializeExpressionContext

+ func (*ClassInitializeExpressionContext) IsClassInitializeExpressionContext()

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

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

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

+ func (s *ClassInitializeExpressionContext) Identifier() antlr.TerminalNode

+ func (s *ClassInitializeExpressionContext) LBRACE() antlr.TerminalNode

+ func (s *ClassInitializeExpressionContext) NamedArgumentList() INamedArgumentListContext

+ func (s *ClassInitializeExpressionContext) RBRACE() antlr.TerminalNode

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

+ type ClassMemberContext struct

+ func NewClassMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassMemberContext

+ func NewEmptyClassMemberContext() *ClassMemberContext

+ func (*ClassMemberContext) IsClassMemberContext()

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

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

+ func (s *ClassMemberContext) AllClassMemberModifier() []IClassMemberModifierContext

+ func (s *ClassMemberContext) AllMacroStatement() []IMacroStatementContext

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

+ func (s *ClassMemberContext) ClassMemberModifier(i int) IClassMemberModifierContext

+ func (s *ClassMemberContext) Expression() IExpressionContext

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

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

+ func (s *ClassMemberContext) Identifier() antlr.TerminalNode

+ func (s *ClassMemberContext) MacroStatement(i int) IMacroStatementContext

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

+ func (s *ClassMemberContext) Type_() ITypeContext

+ type ClassMemberModifierContext struct

+ func NewClassMemberModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassMemberModifierContext

+ func NewEmptyClassMemberModifierContext() *ClassMemberModifierContext

+ func (*ClassMemberModifierContext) IsClassMemberModifierContext()

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

+ func (s *ClassMemberModifierContext) CONST() antlr.TerminalNode

+ func (s *ClassMemberModifierContext) FINAL() antlr.TerminalNode

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

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

+ func (s *ClassMemberModifierContext) PUB() antlr.TerminalNode

+ func (s *ClassMemberModifierContext) STATIC() antlr.TerminalNode

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

+ type ClassMethodContext struct

+ func NewClassMethodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassMethodContext

+ func NewEmptyClassMethodContext() *ClassMethodContext

+ func (*ClassMethodContext) IsClassMethodContext()

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

+ func (s *ClassMethodContext) AllClassMethodModifier() []IClassMethodModifierContext

+ func (s *ClassMethodContext) AllMacroStatement() []IMacroStatementContext

+ func (s *ClassMethodContext) ClassMethodModifier(i int) IClassMethodModifierContext

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

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

+ func (s *ClassMethodContext) LambdaFunctionDeclaration() ILambdaFunctionDeclarationContext

+ func (s *ClassMethodContext) MacroStatement(i int) IMacroStatementContext

+ func (s *ClassMethodContext) StandardFunctionDeclaration() IStandardFunctionDeclarationContext

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

+ type ClassMethodModifierContext struct

+ func NewClassMethodModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassMethodModifierContext

+ func NewEmptyClassMethodModifierContext() *ClassMethodModifierContext

+ func (*ClassMethodModifierContext) IsClassMethodModifierContext()

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

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

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

+ func (s *ClassMethodModifierContext) PUB() antlr.TerminalNode

+ func (s *ClassMethodModifierContext) STATIC() antlr.TerminalNode

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

+ type ClassModifierContext struct

+ func NewClassModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassModifierContext

+ func NewEmptyClassModifierContext() *ClassModifierContext

+ func (*ClassModifierContext) IsClassModifierContext()

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

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

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

+ func (s *ClassModifierContext) PUB() antlr.TerminalNode

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

+ type ClassNamedParameterAccessPointContext struct

+ func NewClassNamedParameterAccessPointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassNamedParameterAccessPointContext

+ func NewEmptyClassNamedParameterAccessPointContext() *ClassNamedParameterAccessPointContext

+ func (*ClassNamedParameterAccessPointContext) IsClassNamedParameterAccessPointContext()

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

+ func (s *ClassNamedParameterAccessPointContext) ClassNamedParameterAccessPoint() IClassNamedParameterAccessPointContext

+ func (s *ClassNamedParameterAccessPointContext) DOT() antlr.TerminalNode

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

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

+ func (s *ClassNamedParameterAccessPointContext) Identifier() antlr.TerminalNode

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

+ type ClassNamedParameterContext struct

+ func NewClassNamedParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassNamedParameterContext

+ func NewEmptyClassNamedParameterContext() *ClassNamedParameterContext

+ func (*ClassNamedParameterContext) IsClassNamedParameterContext()

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

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

+ func (s *ClassNamedParameterContext) ClassNamedParameterAccessPoint() IClassNamedParameterAccessPointContext

+ func (s *ClassNamedParameterContext) Expression() IExpressionContext

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

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

+ func (s *ClassNamedParameterContext) REQUIRED() antlr.TerminalNode

+ func (s *ClassNamedParameterContext) ReceiverParameter() IReceiverParameterContext

+ func (s *ClassNamedParameterContext) SUPER() antlr.TerminalNode

+ func (s *ClassNamedParameterContext) THIS() antlr.TerminalNode

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

+ type ClassNamedParameterListContext struct

+ func NewClassNamedParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassNamedParameterListContext

+ func NewEmptyClassNamedParameterListContext() *ClassNamedParameterListContext

+ func (*ClassNamedParameterListContext) IsClassNamedParameterListContext()

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

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

+ func (s *ClassNamedParameterListContext) AllClassNamedParameter() []IClassNamedParameterContext

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

+ func (s *ClassNamedParameterListContext) ClassNamedParameter(i int) IClassNamedParameterContext

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

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

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

+ type ClassNamedParametersContext struct

+ func NewClassNamedParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassNamedParametersContext

+ func NewEmptyClassNamedParametersContext() *ClassNamedParametersContext

+ func (*ClassNamedParametersContext) IsClassNamedParametersContext()

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

+ func (s *ClassNamedParametersContext) ClassNamedParameterList() IClassNamedParameterListContext

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

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

+ func (s *ClassNamedParametersContext) LBRACE() antlr.TerminalNode

+ func (s *ClassNamedParametersContext) RBRACE() antlr.TerminalNode

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

+ type ClassSuperContext struct

+ func NewClassSuperContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassSuperContext

+ func NewEmptyClassSuperContext() *ClassSuperContext

+ func (*ClassSuperContext) IsClassSuperContext()

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

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

+ func (s *ClassSuperContext) AllMemberAccess() []IMemberAccessContext

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

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

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

+ func (s *ClassSuperContext) MemberAccess(i int) IMemberAccessContext

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

+ type CommandAccessPointContext struct

+ func NewCommandAccessPointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommandAccessPointContext

+ func NewEmptyCommandAccessPointContext() *CommandAccessPointContext

+ func (*CommandAccessPointContext) IsCommandAccessPointContext()

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

+ func (s *CommandAccessPointContext) CommandAccessPoint() ICommandAccessPointContext

+ func (s *CommandAccessPointContext) DOT() antlr.TerminalNode

+ func (s *CommandAccessPointContext) DOUBLE_COLON() antlr.TerminalNode

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

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

+ func (s *CommandAccessPointContext) Identifier() antlr.TerminalNode

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

+ type CommandExpressionContext struct

+ func NewCommandExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommandExpressionContext

+ func NewEmptyCommandExpressionContext() *CommandExpressionContext

+ func (*CommandExpressionContext) IsCommandExpressionContext()

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

+ func (s *CommandExpressionContext) AllConditionalExpression() []IConditionalExpressionContext

+ func (s *CommandExpressionContext) AllMemberAccess() []IMemberAccessContext

+ func (s *CommandExpressionContext) AllOption() []IOptionContext

+ func (s *CommandExpressionContext) BITAND() antlr.TerminalNode

+ func (s *CommandExpressionContext) CommandJoin() ICommandJoinContext

+ func (s *CommandExpressionContext) CommandStream() ICommandStreamContext

+ func (s *CommandExpressionContext) CommandStringLiteral() antlr.TerminalNode

+ func (s *CommandExpressionContext) ConditionalExpression(i int) IConditionalExpressionContext

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

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

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

+ func (s *CommandExpressionContext) MemberAccess(i int) IMemberAccessContext

+ func (s *CommandExpressionContext) Option(i int) IOptionContext

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

+ type CommandJoinContext struct

+ func NewCommandJoinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommandJoinContext

+ func NewEmptyCommandJoinContext() *CommandJoinContext

+ func (*CommandJoinContext) IsCommandJoinContext()

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

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

+ func (s *CommandJoinContext) CommandExpression() ICommandExpressionContext

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

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

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

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

+ type CommandMemberAccessContext struct

+ func NewCommandMemberAccessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommandMemberAccessContext

+ func NewEmptyCommandMemberAccessContext() *CommandMemberAccessContext

+ func (*CommandMemberAccessContext) IsCommandMemberAccessContext()

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

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

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

+ func (s *CommandMemberAccessContext) Identifier() antlr.TerminalNode

+ func (s *CommandMemberAccessContext) MemberAccessPoint() IMemberAccessPointContext

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

+ type CommandStreamContext struct

+ func NewCommandStreamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommandStreamContext

+ func NewEmptyCommandStreamContext() *CommandStreamContext

+ func (*CommandStreamContext) IsCommandStreamContext()

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

+ func (s *CommandStreamContext) BITOR() antlr.TerminalNode

+ func (s *CommandStreamContext) CommandExpression() ICommandExpressionContext

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

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

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

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

+ func (s *CommandStreamContext) SHL() antlr.TerminalNode

+ func (s *CommandStreamContext) SHR() antlr.TerminalNode

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

+ type CommentContext struct

+ func NewCommentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommentContext

+ func NewEmptyCommentContext() *CommentContext

+ func (*CommentContext) IsCommentContext()

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

+ func (s *CommentContext) BlockComment() antlr.TerminalNode

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

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

+ func (s *CommentContext) LineComment() antlr.TerminalNode

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

+ type CompositeTypeContext struct

+ func NewCompositeTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompositeTypeContext

+ func NewEmptyCompositeTypeContext() *CompositeTypeContext

+ func (*CompositeTypeContext) IsCompositeTypeContext()

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

+ func (s *CompositeTypeContext) BITAND() antlr.TerminalNode

+ func (s *CompositeTypeContext) BITOR() antlr.TerminalNode

+ func (s *CompositeTypeContext) CompositeType() ICompositeTypeContext

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

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

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

+ func (s *CompositeTypeContext) Type_() ITypeContext

+ type ComptimeExpressionContext struct

+ func NewComptimeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComptimeExpressionContext

+ func NewEmptyComptimeExpressionContext() *ComptimeExpressionContext

+ func (*ComptimeExpressionContext) IsComptimeExpressionContext()

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

+ func (s *ComptimeExpressionContext) Block() IBlockContext

+ func (s *ComptimeExpressionContext) COMPTIME() antlr.TerminalNode

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

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

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

+ type ConditionalBoolExpressionContext struct

+ func NewConditionalBoolExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalBoolExpressionContext

+ func NewEmptyConditionalBoolExpressionContext() *ConditionalBoolExpressionContext

+ func (*ConditionalBoolExpressionContext) IsConditionalBoolExpressionContext()

+ func (s *ConditionalBoolExpressionContext) AND(i int) antlr.TerminalNode

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

+ func (s *ConditionalBoolExpressionContext) AllAND() []antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) AllBITAND() []antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) AllBITOR() []antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) AllBITXOR() []antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) AllLogicalExpression() []ILogicalExpressionContext

+ func (s *ConditionalBoolExpressionContext) AllOR() []antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) BITAND(i int) antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) BITOR(i int) antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) BITXOR(i int) antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) GetConditionalOp() antlr.Token

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

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

+ func (s *ConditionalBoolExpressionContext) LogicalExpression(i int) ILogicalExpressionContext

+ func (s *ConditionalBoolExpressionContext) OR(i int) antlr.TerminalNode

+ func (s *ConditionalBoolExpressionContext) SetConditionalOp(v antlr.Token)

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

+ type ConditionalExpressionContext struct

+ func NewConditionalExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalExpressionContext

+ func NewEmptyConditionalExpressionContext() *ConditionalExpressionContext

+ func (*ConditionalExpressionContext) IsConditionalExpressionContext()

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

+ func (s *ConditionalExpressionContext) AllConditionalExpression() []IConditionalExpressionContext

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

+ func (s *ConditionalExpressionContext) ConditionalBoolExpression() IConditionalBoolExpressionContext

+ func (s *ConditionalExpressionContext) ConditionalExpression(i int) IConditionalExpressionContext

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

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

+ func (s *ConditionalExpressionContext) QUEST() antlr.TerminalNode

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

+ type ContinueStatementContext struct

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

+ func NewEmptyContinueStatementContext() *ContinueStatementContext

+ func (*ContinueStatementContext) IsContinueStatementContext()

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

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

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

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

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

+ type DeclareStatementContext struct

+ func NewDeclareStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareStatementContext

+ func NewEmptyDeclareStatementContext() *DeclareStatementContext

+ func (*DeclareStatementContext) IsDeclareStatementContext()

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

+ func (s *DeclareStatementContext) Block() IBlockContext

+ func (s *DeclareStatementContext) ClassDeclaration() IClassDeclarationContext

+ func (s *DeclareStatementContext) DECLARE() antlr.TerminalNode

+ func (s *DeclareStatementContext) EnumDeclaration() IEnumDeclarationContext

+ func (s *DeclareStatementContext) FunctionDeclaration() IFunctionDeclarationContext

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

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

+ func (s *DeclareStatementContext) ModuleDeclaration() IModuleDeclarationContext

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

+ func (s *DeclareStatementContext) TraitDeclaration() ITraitDeclarationContext

+ func (s *DeclareStatementContext) TypeDeclaration() ITypeDeclarationContext

+ type DeferStatementContext struct

+ func NewDeferStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeferStatementContext

+ func NewEmptyDeferStatementContext() *DeferStatementContext

+ func (*DeferStatementContext) IsDeferStatementContext()

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

+ func (s *DeferStatementContext) CallExpression() ICallExpressionContext

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

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

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

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

+ type DoWhileStatementContext struct

+ func NewDoWhileStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DoWhileStatementContext

+ func NewEmptyDoWhileStatementContext() *DoWhileStatementContext

+ func (*DoWhileStatementContext) IsDoWhileStatementContext()

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

+ func (s *DoWhileStatementContext) Block() IBlockContext

+ func (s *DoWhileStatementContext) DO() antlr.TerminalNode

+ func (s *DoWhileStatementContext) Expression() IExpressionContext

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

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

+ func (s *DoWhileStatementContext) LOOP() antlr.TerminalNode

+ func (s *DoWhileStatementContext) LPAREN() antlr.TerminalNode

+ func (s *DoWhileStatementContext) RPAREN() antlr.TerminalNode

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

+ type EnumAssociatedConstructorContext struct

+ func NewEmptyEnumAssociatedConstructorContext() *EnumAssociatedConstructorContext

+ func NewEnumAssociatedConstructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumAssociatedConstructorContext

+ func (*EnumAssociatedConstructorContext) IsEnumAssociatedConstructorContext()

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

+ func (s *EnumAssociatedConstructorContext) AllEnumConstructor() []IEnumConstructorContext

+ func (s *EnumAssociatedConstructorContext) EnumConstructor(i int) IEnumConstructorContext

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

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

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

+ type EnumAssociatedFieldContext struct

+ func NewEmptyEnumAssociatedFieldContext() *EnumAssociatedFieldContext

+ func NewEnumAssociatedFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumAssociatedFieldContext

+ func (*EnumAssociatedFieldContext) IsEnumAssociatedFieldContext()

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

+ func (s *EnumAssociatedFieldContext) AllEnumFieldModifier() []IEnumFieldModifierContext

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

+ func (s *EnumAssociatedFieldContext) EnumFieldModifier(i int) IEnumFieldModifierContext

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

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

+ func (s *EnumAssociatedFieldContext) Identifier() antlr.TerminalNode

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

+ func (s *EnumAssociatedFieldContext) Type_() ITypeContext

+ type EnumAssociatedFieldsContext struct

+ func NewEmptyEnumAssociatedFieldsContext() *EnumAssociatedFieldsContext

+ func NewEnumAssociatedFieldsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumAssociatedFieldsContext

+ func (*EnumAssociatedFieldsContext) IsEnumAssociatedFieldsContext()

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

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

+ func (s *EnumAssociatedFieldsContext) AllEnumAssociatedField() []IEnumAssociatedFieldContext

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

+ func (s *EnumAssociatedFieldsContext) EnumAssociatedField(i int) IEnumAssociatedFieldContext

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

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

+ func (s *EnumAssociatedFieldsContext) SEMI() antlr.TerminalNode

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

+ type EnumAssociatedMethodsContext struct

+ func NewEmptyEnumAssociatedMethodsContext() *EnumAssociatedMethodsContext

+ func NewEnumAssociatedMethodsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumAssociatedMethodsContext

+ func (*EnumAssociatedMethodsContext) IsEnumAssociatedMethodsContext()

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

+ func (s *EnumAssociatedMethodsContext) AllEnumMethod() []IEnumMethodContext

+ func (s *EnumAssociatedMethodsContext) EnumMethod(i int) IEnumMethodContext

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

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

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

+ type EnumAssociatedValueContext struct

+ func NewEmptyEnumAssociatedValueContext() *EnumAssociatedValueContext

+ func NewEnumAssociatedValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumAssociatedValueContext

+ func (*EnumAssociatedValueContext) IsEnumAssociatedValueContext()

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

+ func (s *EnumAssociatedValueContext) ExpressionList() IExpressionListContext

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

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

+ func (s *EnumAssociatedValueContext) Identifier() antlr.TerminalNode

+ func (s *EnumAssociatedValueContext) LPAREN() antlr.TerminalNode

+ func (s *EnumAssociatedValueContext) RPAREN() antlr.TerminalNode

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

+ type EnumAssociatedValuesContext struct

+ func NewEmptyEnumAssociatedValuesContext() *EnumAssociatedValuesContext

+ func NewEnumAssociatedValuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumAssociatedValuesContext

+ func (*EnumAssociatedValuesContext) IsEnumAssociatedValuesContext()

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

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

+ func (s *EnumAssociatedValuesContext) AllComment() []ICommentContext

+ func (s *EnumAssociatedValuesContext) AllEnumAssociatedValue() []IEnumAssociatedValueContext

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

+ func (s *EnumAssociatedValuesContext) Comment(i int) ICommentContext

+ func (s *EnumAssociatedValuesContext) EnumAssociatedValue(i int) IEnumAssociatedValueContext

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

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

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

+ type EnumBodyADTContext struct

+ func NewEmptyEnumBodyADTContext() *EnumBodyADTContext

+ func NewEnumBodyADTContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumBodyADTContext

+ func (*EnumBodyADTContext) IsEnumBodyADTContext()

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

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

+ func (s *EnumBodyADTContext) AllComment() []ICommentContext

+ func (s *EnumBodyADTContext) AllEnumVariant() []IEnumVariantContext

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

+ func (s *EnumBodyADTContext) Comment(i int) ICommentContext

+ func (s *EnumBodyADTContext) EnumMethods() IEnumMethodsContext

+ func (s *EnumBodyADTContext) EnumVariant(i int) IEnumVariantContext

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

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

+ func (s *EnumBodyADTContext) LBRACE() antlr.TerminalNode

+ func (s *EnumBodyADTContext) RBRACE() antlr.TerminalNode

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

+ type EnumBodyAssociatedContext struct

+ func NewEmptyEnumBodyAssociatedContext() *EnumBodyAssociatedContext

+ func NewEnumBodyAssociatedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumBodyAssociatedContext

+ func (*EnumBodyAssociatedContext) IsEnumBodyAssociatedContext()

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

+ func (s *EnumBodyAssociatedContext) EnumAssociatedConstructor() IEnumAssociatedConstructorContext

+ func (s *EnumBodyAssociatedContext) EnumAssociatedFields() IEnumAssociatedFieldsContext

+ func (s *EnumBodyAssociatedContext) EnumAssociatedMethods() IEnumAssociatedMethodsContext

+ func (s *EnumBodyAssociatedContext) EnumAssociatedValues() IEnumAssociatedValuesContext

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

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

+ func (s *EnumBodyAssociatedContext) LBRACE() antlr.TerminalNode

+ func (s *EnumBodyAssociatedContext) RBRACE() antlr.TerminalNode

+ func (s *EnumBodyAssociatedContext) SEMI() antlr.TerminalNode

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

+ type EnumBodySimpleContext struct

+ func NewEmptyEnumBodySimpleContext() *EnumBodySimpleContext

+ func NewEnumBodySimpleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumBodySimpleContext

+ func (*EnumBodySimpleContext) IsEnumBodySimpleContext()

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

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

+ func (s *EnumBodySimpleContext) AllComment() []ICommentContext

+ func (s *EnumBodySimpleContext) AllEnumValue() []IEnumValueContext

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

+ func (s *EnumBodySimpleContext) Comment(i int) ICommentContext

+ func (s *EnumBodySimpleContext) EnumValue(i int) IEnumValueContext

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

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

+ func (s *EnumBodySimpleContext) LBRACE() antlr.TerminalNode

+ func (s *EnumBodySimpleContext) RBRACE() antlr.TerminalNode

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

+ type EnumBuiltinMethodModifierContext struct

+ func NewEmptyEnumBuiltinMethodModifierContext() *EnumBuiltinMethodModifierContext

+ func NewEnumBuiltinMethodModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumBuiltinMethodModifierContext

+ func (*EnumBuiltinMethodModifierContext) IsEnumBuiltinMethodModifierContext()

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

+ func (s *EnumBuiltinMethodModifierContext) CONST() antlr.TerminalNode

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

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

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

+ type EnumConstructorContext struct

+ func NewEmptyEnumConstructorContext() *EnumConstructorContext

+ func NewEnumConstructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstructorContext

+ func (*EnumConstructorContext) IsEnumConstructorContext()

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

+ func (s *EnumConstructorContext) AllMacroStatement() []IMacroStatementContext

+ func (s *EnumConstructorContext) Block() IBlockContext

+ func (s *EnumConstructorContext) DOUBLE_ARROW() antlr.TerminalNode

+ func (s *EnumConstructorContext) EnumBuiltinMethodModifier() IEnumBuiltinMethodModifierContext

+ func (s *EnumConstructorContext) EnumConstructorInit() IEnumConstructorInitContext

+ func (s *EnumConstructorContext) EnumConstructorName() IEnumConstructorNameContext

+ func (s *EnumConstructorContext) EnumConstructorParameters() IEnumConstructorParametersContext

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

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

+ func (s *EnumConstructorContext) MacroStatement(i int) IMacroStatementContext

+ func (s *EnumConstructorContext) SEMI() antlr.TerminalNode

+ func (s *EnumConstructorContext) THROWS() antlr.TerminalNode

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

+ type EnumConstructorDirectInitContext struct

+ func NewEmptyEnumConstructorDirectInitContext() *EnumConstructorDirectInitContext

+ func NewEnumConstructorDirectInitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstructorDirectInitContext

+ func (*EnumConstructorDirectInitContext) IsEnumConstructorDirectInitContext()

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

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

+ func (s *EnumConstructorDirectInitContext) Expression() IExpressionContext

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

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

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

+ func (s *EnumConstructorDirectInitContext) VariableExpression() IVariableExpressionContext

+ type EnumConstructorInitContext struct

+ func NewEmptyEnumConstructorInitContext() *EnumConstructorInitContext

+ func NewEnumConstructorInitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstructorInitContext

+ func (*EnumConstructorInitContext) IsEnumConstructorInitContext()

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

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

+ func (s *EnumConstructorInitContext) EnumConstructorDirectInit() IEnumConstructorDirectInitContext

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

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

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

+ type EnumConstructorNameContext struct

+ func NewEmptyEnumConstructorNameContext() *EnumConstructorNameContext

+ func NewEnumConstructorNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstructorNameContext

+ func (*EnumConstructorNameContext) IsEnumConstructorNameContext()

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

+ func (s *EnumConstructorNameContext) AllIdentifier() []antlr.TerminalNode

+ func (s *EnumConstructorNameContext) DOT() antlr.TerminalNode

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

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

+ func (s *EnumConstructorNameContext) Identifier(i int) antlr.TerminalNode

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

+ type EnumConstructorParametersContext struct

+ func NewEmptyEnumConstructorParametersContext() *EnumConstructorParametersContext

+ func NewEnumConstructorParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstructorParametersContext

+ func (*EnumConstructorParametersContext) IsEnumConstructorParametersContext()

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

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

+ func (s *EnumConstructorParametersContext) AllEnumConstructorDirectInit() []IEnumConstructorDirectInitContext

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

+ func (s *EnumConstructorParametersContext) EnumConstructorDirectInit(i int) IEnumConstructorDirectInitContext

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

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

+ func (s *EnumConstructorParametersContext) LPAREN() antlr.TerminalNode

+ func (s *EnumConstructorParametersContext) RPAREN() antlr.TerminalNode

+ func (s *EnumConstructorParametersContext) ReceiverParameterList() IReceiverParameterListContext

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

+ type EnumDeclarationContext struct

+ func NewEmptyEnumDeclarationContext() *EnumDeclarationContext

+ func NewEnumDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumDeclarationContext

+ func (*EnumDeclarationContext) IsEnumDeclarationContext()

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

+ func (s *EnumDeclarationContext) AllMacroStatement() []IMacroStatementContext

+ func (s *EnumDeclarationContext) ENUM() antlr.TerminalNode

+ func (s *EnumDeclarationContext) EnumBodyADT() IEnumBodyADTContext

+ func (s *EnumDeclarationContext) EnumBodyAssociated() IEnumBodyAssociatedContext

+ func (s *EnumDeclarationContext) EnumBodySimple() IEnumBodySimpleContext

+ func (s *EnumDeclarationContext) EnumModifier() IEnumModifierContext

+ func (s *EnumDeclarationContext) GenericParameters() IGenericParametersContext

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

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

+ func (s *EnumDeclarationContext) Identifier() antlr.TerminalNode

+ func (s *EnumDeclarationContext) MacroStatement(i int) IMacroStatementContext

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

+ type EnumFieldContext struct

+ func NewEmptyEnumFieldContext() *EnumFieldContext

+ func NewEnumFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumFieldContext

+ func (*EnumFieldContext) IsEnumFieldContext()

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

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

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

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

+ func (s *EnumFieldContext) Identifier() antlr.TerminalNode

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

+ func (s *EnumFieldContext) Type_() ITypeContext

+ type EnumFieldModifierContext struct

+ func NewEmptyEnumFieldModifierContext() *EnumFieldModifierContext

+ func NewEnumFieldModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumFieldModifierContext

+ func (*EnumFieldModifierContext) IsEnumFieldModifierContext()

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

+ func (s *EnumFieldModifierContext) CONST() antlr.TerminalNode

+ func (s *EnumFieldModifierContext) FINAL() antlr.TerminalNode

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

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

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

+ type EnumInitializeContext struct

+ func NewEmptyEnumInitializeContext() *EnumInitializeContext

+ func NewEnumInitializeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumInitializeContext

+ func (*EnumInitializeContext) IsEnumInitializeContext()

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

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

+ func (s *EnumInitializeContext) AllEnumInitializeMember() []IEnumInitializeMemberContext

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

+ func (s *EnumInitializeContext) EnumInitializeMember(i int) IEnumInitializeMemberContext

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

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

+ func (s *EnumInitializeContext) SEMI() antlr.TerminalNode

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

+ type EnumInitializeMemberContext struct

+ func NewEmptyEnumInitializeMemberContext() *EnumInitializeMemberContext

+ func NewEnumInitializeMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumInitializeMemberContext

+ func (*EnumInitializeMemberContext) IsEnumInitializeMemberContext()

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

+ func (s *EnumInitializeMemberContext) ExpressionList() IExpressionListContext

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

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

+ func (s *EnumInitializeMemberContext) Identifier() antlr.TerminalNode

+ func (s *EnumInitializeMemberContext) LPAREN() antlr.TerminalNode

+ func (s *EnumInitializeMemberContext) RPAREN() antlr.TerminalNode

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

+ type EnumMemberContext struct

+ func NewEmptyEnumMemberContext() *EnumMemberContext

+ func NewEnumMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumMemberContext

+ func (*EnumMemberContext) IsEnumMemberContext()

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

+ func (s *EnumMemberContext) AllEnumMemberModifier() []IEnumMemberModifierContext

+ func (s *EnumMemberContext) AllMacroStatement() []IMacroStatementContext

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

+ func (s *EnumMemberContext) EnumMemberModifier(i int) IEnumMemberModifierContext

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

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

+ func (s *EnumMemberContext) Identifier() antlr.TerminalNode

+ func (s *EnumMemberContext) MacroStatement(i int) IMacroStatementContext

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

+ func (s *EnumMemberContext) Type_() ITypeContext

+ type EnumMemberModifierContext struct

+ func NewEmptyEnumMemberModifierContext() *EnumMemberModifierContext

+ func NewEnumMemberModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumMemberModifierContext

+ func (*EnumMemberModifierContext) IsEnumMemberModifierContext()

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

+ func (s *EnumMemberModifierContext) FINAL() antlr.TerminalNode

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

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

+ func (s *EnumMemberModifierContext) PUB() antlr.TerminalNode

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

+ type EnumMethodContext struct

+ func NewEmptyEnumMethodContext() *EnumMethodContext

+ func NewEnumMethodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumMethodContext

+ func (*EnumMethodContext) IsEnumMethodContext()

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

+ func (s *EnumMethodContext) AllEnumMethodModifier() []IEnumMethodModifierContext

+ func (s *EnumMethodContext) AllMacroStatement() []IMacroStatementContext

+ func (s *EnumMethodContext) EnumMethodModifier(i int) IEnumMethodModifierContext

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

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

+ func (s *EnumMethodContext) LambdaFunctionDeclaration() ILambdaFunctionDeclarationContext

+ func (s *EnumMethodContext) MacroStatement(i int) IMacroStatementContext

+ func (s *EnumMethodContext) StandardFunctionDeclaration() IStandardFunctionDeclarationContext

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

+ type EnumMethodModifierContext struct

+ func NewEmptyEnumMethodModifierContext() *EnumMethodModifierContext

+ func NewEnumMethodModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumMethodModifierContext

+ func (*EnumMethodModifierContext) IsEnumMethodModifierContext()

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

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

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

+ func (s *EnumMethodModifierContext) PUB() antlr.TerminalNode

+ func (s *EnumMethodModifierContext) STATIC() antlr.TerminalNode

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

+ type EnumMethodsContext struct

+ func NewEmptyEnumMethodsContext() *EnumMethodsContext

+ func NewEnumMethodsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumMethodsContext

+ func (*EnumMethodsContext) IsEnumMethodsContext()

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

+ func (s *EnumMethodsContext) AllEnumMethod() []IEnumMethodContext

+ func (s *EnumMethodsContext) EnumMethod(i int) IEnumMethodContext

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

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

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

+ type EnumModifierContext struct

+ func NewEmptyEnumModifierContext() *EnumModifierContext

+ func NewEnumModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumModifierContext

+ func (*EnumModifierContext) IsEnumModifierContext()

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

+ func (s *EnumModifierContext) FINAL() antlr.TerminalNode

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

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

+ func (s *EnumModifierContext) PUB() antlr.TerminalNode

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

+ type EnumValueContext struct

+ func NewEmptyEnumValueContext() *EnumValueContext

+ func NewEnumValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumValueContext

+ func (*EnumValueContext) IsEnumValueContext()

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

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

+ func (s *EnumValueContext) Comment() ICommentContext

+ func (s *EnumValueContext) Expression() IExpressionContext

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

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

+ func (s *EnumValueContext) Identifier() antlr.TerminalNode

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

+ type EnumVariantContext struct

+ func NewEmptyEnumVariantContext() *EnumVariantContext

+ func NewEnumVariantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumVariantContext

+ func (*EnumVariantContext) IsEnumVariantContext()

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

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

+ func (s *EnumVariantContext) AllEnumField() []IEnumFieldContext

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

+ func (s *EnumVariantContext) EnumField(i int) IEnumFieldContext

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

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

+ func (s *EnumVariantContext) Identifier() antlr.TerminalNode

+ func (s *EnumVariantContext) LBRACE() antlr.TerminalNode

+ func (s *EnumVariantContext) RBRACE() antlr.TerminalNode

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

+ type ExpressionContext struct

+ func NewEmptyExpressionContext() *ExpressionContext

+ func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext

+ func (*ExpressionContext) IsExpressionContext()

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

+ func (s *ExpressionContext) ChannelOutputExpression() IChannelOutputExpressionContext

+ func (s *ExpressionContext) ClassInitializeExpression() IClassInitializeExpressionContext

+ func (s *ExpressionContext) CommandExpression() ICommandExpressionContext

+ func (s *ExpressionContext) ComptimeExpression() IComptimeExpressionContext

+ func (s *ExpressionContext) ConditionalExpression() IConditionalExpressionContext

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

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

+ func (s *ExpressionContext) LambdaExpression() ILambdaExpressionContext

+ func (s *ExpressionContext) NewDelExpression() INewDelExpressionContext

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

+ func (s *ExpressionContext) TypeofExpression() ITypeofExpressionContext

+ func (s *ExpressionContext) UnsafeExpression() IUnsafeExpressionContext

+ type ExpressionListContext struct

+ func NewEmptyExpressionListContext() *ExpressionListContext

+ func NewExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionListContext

+ func (*ExpressionListContext) IsExpressionListContext()

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

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

+ func (s *ExpressionListContext) AllExpression() []IExpressionContext

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

+ func (s *ExpressionListContext) Expression(i int) IExpressionContext

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

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

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

+ type ExpressionStatementContext struct

+ func NewEmptyExpressionStatementContext() *ExpressionStatementContext

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

+ func (*ExpressionStatementContext) IsExpressionStatementContext()

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

+ func (s *ExpressionStatementContext) Expression() IExpressionContext

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

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

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

+ type ExtendClassContext struct

+ func NewEmptyExtendClassContext() *ExtendClassContext

+ func NewExtendClassContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExtendClassContext

+ func (*ExtendClassContext) IsExtendClassContext()

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

+ func (s *ExtendClassContext) CLASS() antlr.TerminalNode

+ func (s *ExtendClassContext) ClassBody() IClassBodyContext

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

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

+ func (s *ExtendClassContext) Identifier() antlr.TerminalNode

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

+ type ExtendDeclarationContext struct

+ func NewEmptyExtendDeclarationContext() *ExtendDeclarationContext

+ func NewExtendDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExtendDeclarationContext

+ func (*ExtendDeclarationContext) IsExtendDeclarationContext()

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

+ func (s *ExtendDeclarationContext) EXTEND() antlr.TerminalNode

+ func (s *ExtendDeclarationContext) ExtendClass() IExtendClassContext

+ func (s *ExtendDeclarationContext) ExtendEnum() IExtendEnumContext

+ func (s *ExtendDeclarationContext) ExtendMod() IExtendModContext

+ func (s *ExtendDeclarationContext) ExtendTrait() IExtendTraitContext

+ func (s *ExtendDeclarationContext) ExtendType() IExtendTypeContext

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

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

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

+ type ExtendEnumContext struct

+ func NewEmptyExtendEnumContext() *ExtendEnumContext

+ func NewExtendEnumContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExtendEnumContext

+ func (*ExtendEnumContext) IsExtendEnumContext()

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

+ func (s *ExtendEnumContext) ENUM() antlr.TerminalNode

+ func (s *ExtendEnumContext) EnumBodyADT() IEnumBodyADTContext

+ func (s *ExtendEnumContext) EnumBodyAssociated() IEnumBodyAssociatedContext

+ func (s *ExtendEnumContext) EnumBodySimple() IEnumBodySimpleContext

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

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

+ func (s *ExtendEnumContext) Identifier() antlr.TerminalNode

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

+ type ExtendModContext struct

+ func NewEmptyExtendModContext() *ExtendModContext

+ func NewExtendModContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExtendModContext

+ func (*ExtendModContext) IsExtendModContext()

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

+ func (s *ExtendModContext) AllModuleStatement() []IModuleStatementContext

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

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

+ func (s *ExtendModContext) Identifier() antlr.TerminalNode

+ func (s *ExtendModContext) LBRACE() antlr.TerminalNode

+ func (s *ExtendModContext) MOD_LIT() antlr.TerminalNode

+ func (s *ExtendModContext) ModuleStatement(i int) IModuleStatementContext

+ func (s *ExtendModContext) RBRACE() antlr.TerminalNode

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

+ type ExtendTraitContext struct

+ func NewEmptyExtendTraitContext() *ExtendTraitContext

+ func NewExtendTraitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExtendTraitContext

+ func (*ExtendTraitContext) IsExtendTraitContext()

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

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

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

+ func (s *ExtendTraitContext) Identifier() antlr.TerminalNode

+ func (s *ExtendTraitContext) TRAIT() antlr.TerminalNode

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

+ func (s *ExtendTraitContext) TraitBody() ITraitBodyContext

+ type ExtendTypeContext struct

+ func NewEmptyExtendTypeContext() *ExtendTypeContext

+ func NewExtendTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExtendTypeContext

+ func (*ExtendTypeContext) IsExtendTypeContext()

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

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

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

+ func (s *ExtendTypeContext) Identifier() antlr.TerminalNode

+ func (s *ExtendTypeContext) LBRACE() antlr.TerminalNode

+ func (s *ExtendTypeContext) RBRACE() antlr.TerminalNode

+ func (s *ExtendTypeContext) TYPE() antlr.TerminalNode

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

+ func (s *ExtendTypeContext) Type_() ITypeContext

+ type ExternDeclarationContext struct

+ func NewEmptyExternDeclarationContext() *ExternDeclarationContext

+ func NewExternDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExternDeclarationContext

+ func (*ExternDeclarationContext) IsExternDeclarationContext()

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

+ func (s *ExternDeclarationContext) EXTERN() antlr.TerminalNode

+ func (s *ExternDeclarationContext) ExternList() IExternListContext

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

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

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

+ type ExternItemContext struct

+ func NewEmptyExternItemContext() *ExternItemContext

+ func NewExternItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExternItemContext

+ func (*ExternItemContext) IsExternItemContext()

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

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

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

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

+ func (s *ExternItemContext) Identifier() antlr.TerminalNode

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

+ func (s *ExternItemContext) Type_() ITypeContext

+ type ExternListContext struct

+ func NewEmptyExternListContext() *ExternListContext

+ func NewExternListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExternListContext

+ func (*ExternListContext) IsExternListContext()

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

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

+ func (s *ExternListContext) AllExternItem() []IExternItemContext

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

+ func (s *ExternListContext) ExternItem(i int) IExternItemContext

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

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

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

+ type FactorContext struct

+ func NewEmptyFactorContext() *FactorContext

+ func NewFactorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FactorContext

+ func (*FactorContext) IsFactorContext()

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

+ func (s *FactorContext) CallExpression() ICallExpressionContext

+ func (s *FactorContext) Factor() IFactorContext

+ func (s *FactorContext) FileExpression() IFileExpressionContext

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

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

+ func (s *FactorContext) LPAREN() antlr.TerminalNode

+ func (s *FactorContext) ListExpression() IListExpressionContext

+ func (s *FactorContext) Literal() ILiteralContext

+ func (s *FactorContext) MapExpression() IMapExpressionContext

+ func (s *FactorContext) MethodExpression() IMethodExpressionContext

+ func (s *FactorContext) RPAREN() antlr.TerminalNode

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

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

+ func (s *FactorContext) TripleExpression() ITripleExpressionContext

+ func (s *FactorContext) VariableExpression() IVariableExpressionContext

+ type FileContext struct

+ func NewEmptyFileContext() *FileContext

+ func NewFileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FileContext

+ func (*FileContext) IsFileContext()

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

+ func (s *FileContext) AllSEMI() []antlr.TerminalNode

+ func (s *FileContext) AllStatement() []IStatementContext

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

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

+ func (s *FileContext) SEMI(i int) antlr.TerminalNode

+ func (s *FileContext) Statement(i int) IStatementContext

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

+ type FileExpressionContext struct

+ func NewEmptyFileExpressionContext() *FileExpressionContext

+ func NewFileExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FileExpressionContext

+ func (*FileExpressionContext) IsFileExpressionContext()

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

+ func (s *FileExpressionContext) CallExpressionLinkedList() ICallExpressionLinkedListContext

+ func (s *FileExpressionContext) FileStringLiteral() antlr.TerminalNode

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

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

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

+ type FinallyClauseContext struct

+ func NewEmptyFinallyClauseContext() *FinallyClauseContext

+ func NewFinallyClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FinallyClauseContext

+ func (*FinallyClauseContext) IsFinallyClauseContext()

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

+ func (s *FinallyClauseContext) Block() IBlockContext

+ func (s *FinallyClauseContext) FINALLY() antlr.TerminalNode

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

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

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

+ type ForClauseContext struct

+ func NewEmptyForClauseContext() *ForClauseContext

+ func NewForClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForClauseContext

+ func (*ForClauseContext) IsForClauseContext()

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

+ func (s *ForClauseContext) AllExpression() []IExpressionContext

+ func (s *ForClauseContext) AllSEMI() []antlr.TerminalNode

+ func (s *ForClauseContext) Expression(i int) IExpressionContext

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

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

+ func (s *ForClauseContext) SEMI(i int) antlr.TerminalNode

+ func (s *ForClauseContext) Statement() IStatementContext

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

+ type ForStatementContext struct

+ func NewEmptyForStatementContext() *ForStatementContext

+ func NewForStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForStatementContext

+ func (*ForStatementContext) IsForStatementContext()

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

+ func (s *ForStatementContext) Block() IBlockContext

+ func (s *ForStatementContext) ForClause() IForClauseContext

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

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

+ func (s *ForStatementContext) LOOP() antlr.TerminalNode

+ func (s *ForStatementContext) LPAREN() antlr.TerminalNode

+ func (s *ForStatementContext) RPAREN() antlr.TerminalNode

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

+ type ForeachClauseContext struct

+ func NewEmptyForeachClauseContext() *ForeachClauseContext

+ func NewForeachClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForeachClauseContext

+ func (*ForeachClauseContext) IsForeachClauseContext()

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

+ func (s *ForeachClauseContext) AllForeachVariableName() []IForeachVariableNameContext

+ func (s *ForeachClauseContext) COMMA() antlr.TerminalNode

+ func (s *ForeachClauseContext) ForeachVariableName(i int) IForeachVariableNameContext

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

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

+ func (s *ForeachClauseContext) LPAREN() antlr.TerminalNode

+ func (s *ForeachClauseContext) RPAREN() antlr.TerminalNode

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

+ type ForeachStatementContext struct

+ func NewEmptyForeachStatementContext() *ForeachStatementContext

+ func NewForeachStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForeachStatementContext

+ func (*ForeachStatementContext) IsForeachStatementContext()

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

+ func (s *ForeachStatementContext) Block() IBlockContext

+ func (s *ForeachStatementContext) Expression() IExpressionContext

+ func (s *ForeachStatementContext) ForeachClause() IForeachClauseContext

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

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

+ func (s *ForeachStatementContext) IN() antlr.TerminalNode

+ func (s *ForeachStatementContext) LOOP() antlr.TerminalNode

+ func (s *ForeachStatementContext) OF() antlr.TerminalNode

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

+ type ForeachVariableNameContext struct

+ func NewEmptyForeachVariableNameContext() *ForeachVariableNameContext

+ func NewForeachVariableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForeachVariableNameContext

+ func (*ForeachVariableNameContext) IsForeachVariableNameContext()

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

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

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

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

+ func (s *ForeachVariableNameContext) VariableExpression() IVariableExpressionContext

+ func (s *ForeachVariableNameContext) VariableName() IVariableNameContext

+ type FunctionDeclarationContext struct

+ func NewEmptyFunctionDeclarationContext() *FunctionDeclarationContext

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

+ func (*FunctionDeclarationContext) IsFunctionDeclarationContext()

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

+ func (s *FunctionDeclarationContext) FunctionSignature() IFunctionSignatureContext

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

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

+ func (s *FunctionDeclarationContext) LambdaFunctionDeclaration() ILambdaFunctionDeclarationContext

+ func (s *FunctionDeclarationContext) StandardFunctionDeclaration() IStandardFunctionDeclarationContext

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

+ type FunctionModifierContext struct

+ func NewEmptyFunctionModifierContext() *FunctionModifierContext

+ func NewFunctionModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionModifierContext

+ func (*FunctionModifierContext) IsFunctionModifierContext()

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

+ func (s *FunctionModifierContext) COMPTIME() antlr.TerminalNode

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

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

+ func (s *FunctionModifierContext) PUB() antlr.TerminalNode

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

+ type FunctionReturnValueContext struct

+ func NewEmptyFunctionReturnValueContext() *FunctionReturnValueContext

+ func NewFunctionReturnValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionReturnValueContext

+ func (*FunctionReturnValueContext) IsFunctionReturnValueContext()

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

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

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

+ func (s *FunctionReturnValueContext) LPAREN() antlr.TerminalNode

+ func (s *FunctionReturnValueContext) RPAREN() antlr.TerminalNode

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

+ func (s *FunctionReturnValueContext) TypeList() ITypeListContext

+ func (s *FunctionReturnValueContext) Type_() ITypeContext

+ type FunctionSignatureContext struct

+ func NewEmptyFunctionSignatureContext() *FunctionSignatureContext

+ func NewFunctionSignatureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionSignatureContext

+ func (*FunctionSignatureContext) IsFunctionSignatureContext()

+ func (s *FunctionSignatureContext) ARROW() antlr.TerminalNode

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

+ func (s *FunctionSignatureContext) AllFunctionModifier() []IFunctionModifierContext

+ func (s *FunctionSignatureContext) FN() antlr.TerminalNode

+ func (s *FunctionSignatureContext) FunctionModifier(i int) IFunctionModifierContext

+ func (s *FunctionSignatureContext) FunctionReturnValue() IFunctionReturnValueContext

+ func (s *FunctionSignatureContext) GenericParameters() IGenericParametersContext

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

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

+ func (s *FunctionSignatureContext) Identifier() antlr.TerminalNode

+ func (s *FunctionSignatureContext) OperatorIdentifier() IOperatorIdentifierContext

+ func (s *FunctionSignatureContext) ReceiverParameters() IReceiverParametersContext

+ func (s *FunctionSignatureContext) THROWS() antlr.TerminalNode

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

+ type FunctionTypeContext struct

+ func NewEmptyFunctionTypeContext() *FunctionTypeContext

+ func NewFunctionTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionTypeContext

+ func (*FunctionTypeContext) IsFunctionTypeContext()

+ func (s *FunctionTypeContext) ARROW() antlr.TerminalNode

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

+ func (s *FunctionTypeContext) FunctionReturnValue() IFunctionReturnValueContext

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

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

+ func (s *FunctionTypeContext) ReceiverParameters() IReceiverParametersContext

+ func (s *FunctionTypeContext) THROWS() antlr.TerminalNode

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

+ type GenericArgumentsContext struct

+ func NewEmptyGenericArgumentsContext() *GenericArgumentsContext

+ func NewGenericArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenericArgumentsContext

+ func (*GenericArgumentsContext) IsGenericArgumentsContext()

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

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

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

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

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

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

+ func (s *GenericArgumentsContext) TypeList() ITypeListContext

+ type GenericParameterContext struct

+ func NewEmptyGenericParameterContext() *GenericParameterContext

+ func NewGenericParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenericParameterContext

+ func (*GenericParameterContext) IsGenericParameterContext()

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

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

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

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

+ func (s *GenericParameterContext) Identifier() antlr.TerminalNode

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

+ func (s *GenericParameterContext) Type_() ITypeContext

+ type GenericParameterListContext struct

+ func NewEmptyGenericParameterListContext() *GenericParameterListContext

+ func NewGenericParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenericParameterListContext

+ func (*GenericParameterListContext) IsGenericParameterListContext()

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

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

+ func (s *GenericParameterListContext) AllGenericParameter() []IGenericParameterContext

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

+ func (s *GenericParameterListContext) GenericParameter(i int) IGenericParameterContext

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

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

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

+ type GenericParametersContext struct

+ func NewEmptyGenericParametersContext() *GenericParametersContext

+ func NewGenericParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenericParametersContext

+ func (*GenericParametersContext) IsGenericParametersContext()

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

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

+ func (s *GenericParametersContext) GenericParameterList() IGenericParameterListContext

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

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

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

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

+ type IAddSubExpressionContext interface

+ ADD func(i int) antlr.TerminalNode

+ AllADD func() []antlr.TerminalNode

+ AllMulDivExpression func() []IMulDivExpressionContext

+ AllSUB func() []antlr.TerminalNode

+ GetAddSubOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsAddSubExpressionContext func()

+ MulDivExpression func(i int) IMulDivExpressionContext

+ SUB func(i int) antlr.TerminalNode

+ SetAddSubOp func(antlr.Token)

+ type IArrayTypeContext interface

+ GetParser func() antlr.Parser

+ IsArrayTypeContext func()

+ LBRACK func() antlr.TerminalNode

+ NumberLiteral func() antlr.TerminalNode

+ RBRACK func() antlr.TerminalNode

+ Type_ func() ITypeContext

+ type IAsExpressionContext interface

+ AS func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsAsExpressionContext func()

+ Type_ func() ITypeContext

+ VariableExpression func() IVariableExpressionContext

+ type IAsIdentifierContext interface

+ AS func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsAsIdentifierContext func()

+ type IAssignStatementContext interface

+ ADD_ASSIGN func() antlr.TerminalNode

+ AND_ASSIGN func() antlr.TerminalNode

+ ASSIGN func() antlr.TerminalNode

+ COLON func() antlr.TerminalNode

+ CONST func() antlr.TerminalNode

+ DIV_ASSIGN func() antlr.TerminalNode

+ EXP_ASSIGN func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetAssignModifier func() antlr.Token

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsAssignStatementContext func()

+ LET func() antlr.TerminalNode

+ MOD_ASSIGN func() antlr.TerminalNode

+ MUL_ASSIGN func() antlr.TerminalNode

+ MatchStatement func() IMatchStatementContext

+ SUB_ASSIGN func() antlr.TerminalNode

+ SetAssignModifier func(antlr.Token)

+ Type_ func() ITypeContext

+ VAR func() antlr.TerminalNode

+ VariableExpression func() IVariableExpressionContext

+ VariableNames func() IVariableNamesContext

+ VariableNullableExpressions func() IVariableNullableExpressionsContext

+ type IBlockContext interface

+ AllSEMI func() []antlr.TerminalNode

+ AllStatement func() []IStatementContext

+ GetParser func() antlr.Parser

+ IsBlockContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ SEMI func(i int) antlr.TerminalNode

+ Statement func(i int) IStatementContext

+ type IBreakStatementContext interface

+ BREAK func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsBreakStatementContext func()

+ type ICallExpressionContext interface

+ CallExpressionLinkedList func() ICallExpressionLinkedListContext

+ GetParser func() antlr.Parser

+ IsCallExpressionContext func()

+ LPAREN func() antlr.TerminalNode

+ MemberAccess func() IMemberAccessContext

+ NOT func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ ReceiverArgumentList func() IReceiverArgumentListContext

+ type ICallExpressionLinkedListContext interface

+ CallExpressionLinkedList func() ICallExpressionLinkedListContext

+ DOT func() antlr.TerminalNode

+ DOUBLE_DOT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsCallExpressionLinkedListContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ ReceiverArgumentList func() IReceiverArgumentListContext

+ type ICatchClauseContext interface

+ Block func() IBlockContext

+ CATCH func() antlr.TerminalNode

+ CatchClauseReceiver func() ICatchClauseReceiverContext

+ GetParser func() antlr.Parser

+ IsCatchClauseContext func()

+ MemberAccess func() IMemberAccessContext

+ type ICatchClauseReceiverContext interface

+ COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsCatchClauseReceiverContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ Type_ func() ITypeContext

+ type IChannelInputStatementContext interface

+ BACKARROW func() antlr.TerminalNode

+ BITAND func() antlr.TerminalNode

+ GetChannelPayload func() antlr.Token

+ GetParser func() antlr.Parser

+ IsChannelInputStatementContext func()

+ NumberLiteral func() antlr.TerminalNode

+ SetChannelPayload func(antlr.Token)

+ StringLiteral func() antlr.TerminalNode

+ VariableExpression func() IVariableExpressionContext

+ type IChannelOutputExpressionContext interface

+ BACKARROW func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsChannelOutputExpressionContext func()

+ VariableExpression func() IVariableExpressionContext

+ type IClassBodyContext interface

+ AllClassBuiltinMethod func() []IClassBuiltinMethodContext

+ AllClassMember func() []IClassMemberContext

+ AllClassMethod func() []IClassMethodContext

+ AllComment func() []ICommentContext

+ AllSEMI func() []antlr.TerminalNode

+ ClassBuiltinMethod func(i int) IClassBuiltinMethodContext

+ ClassMember func(i int) IClassMemberContext

+ ClassMethod func(i int) IClassMethodContext

+ Comment func(i int) ICommentContext

+ GetParser func() antlr.Parser

+ IsClassBodyContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ SEMI func(i int) antlr.TerminalNode

+ type IClassBuiltinMethodContext interface

+ AllMacroStatement func() []IMacroStatementContext

+ Block func() IBlockContext

+ ClassBuiltinMethodModifier func() IClassBuiltinMethodModifierContext

+ ClassBuiltinParameters func() IClassBuiltinParametersContext

+ DOUBLE_ARROW func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsClassBuiltinMethodContext func()

+ MacroStatement func(i int) IMacroStatementContext

+ THROWS func() antlr.TerminalNode

+ type IClassBuiltinMethodModifierContext interface

+ CONST func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsClassBuiltinMethodModifierContext func()

+ type IClassBuiltinParametersContext interface

+ COMMA func() antlr.TerminalNode

+ ClassNamedParameters func() IClassNamedParametersContext

+ GetParser func() antlr.Parser

+ IsClassBuiltinParametersContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ ReceiverParameterList func() IReceiverParameterListContext

+ type IClassDeclarationContext interface

+ AllClassModifier func() []IClassModifierContext

+ AllMacroStatement func() []IMacroStatementContext

+ CLASS func() antlr.TerminalNode

+ COLON func() antlr.TerminalNode

+ ClassBody func() IClassBodyContext

+ ClassModifier func(i int) IClassModifierContext

+ ClassSuper func() IClassSuperContext

+ GenericParameters func() IGenericParametersContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsClassDeclarationContext func()

+ MacroStatement func(i int) IMacroStatementContext

+ type IClassInitializeExpressionContext interface

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsClassInitializeExpressionContext func()

+ LBRACE func() antlr.TerminalNode

+ NamedArgumentList func() INamedArgumentListContext

+ RBRACE func() antlr.TerminalNode

+ type IClassMemberContext interface

+ ASSIGN func() antlr.TerminalNode

+ AllClassMemberModifier func() []IClassMemberModifierContext

+ AllMacroStatement func() []IMacroStatementContext

+ COLON func() antlr.TerminalNode

+ ClassMemberModifier func(i int) IClassMemberModifierContext

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsClassMemberContext func()

+ MacroStatement func(i int) IMacroStatementContext

+ Type_ func() ITypeContext

+ type IClassMemberModifierContext interface

+ CONST func() antlr.TerminalNode

+ FINAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsClassMemberModifierContext func()

+ PUB func() antlr.TerminalNode

+ STATIC func() antlr.TerminalNode

+ type IClassMethodContext interface

+ AllClassMethodModifier func() []IClassMethodModifierContext

+ AllMacroStatement func() []IMacroStatementContext

+ ClassMethodModifier func(i int) IClassMethodModifierContext

+ GetParser func() antlr.Parser

+ IsClassMethodContext func()

+ LambdaFunctionDeclaration func() ILambdaFunctionDeclarationContext

+ MacroStatement func(i int) IMacroStatementContext

+ StandardFunctionDeclaration func() IStandardFunctionDeclarationContext

+ type IClassMethodModifierContext interface

+ GetParser func() antlr.Parser

+ IsClassMethodModifierContext func()

+ PUB func() antlr.TerminalNode

+ STATIC func() antlr.TerminalNode

+ type IClassModifierContext interface

+ GetParser func() antlr.Parser

+ IsClassModifierContext func()

+ PUB func() antlr.TerminalNode

+ type IClassNamedParameterAccessPointContext interface

+ ClassNamedParameterAccessPoint func() IClassNamedParameterAccessPointContext

+ DOT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsClassNamedParameterAccessPointContext func()

+ type IClassNamedParameterContext interface

+ ASSIGN func() antlr.TerminalNode

+ ClassNamedParameterAccessPoint func() IClassNamedParameterAccessPointContext

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsClassNamedParameterContext func()

+ REQUIRED func() antlr.TerminalNode

+ ReceiverParameter func() IReceiverParameterContext

+ SUPER func() antlr.TerminalNode

+ THIS func() antlr.TerminalNode

+ type IClassNamedParameterListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllClassNamedParameter func() []IClassNamedParameterContext

+ COMMA func(i int) antlr.TerminalNode

+ ClassNamedParameter func(i int) IClassNamedParameterContext

+ GetParser func() antlr.Parser

+ IsClassNamedParameterListContext func()

+ type IClassNamedParametersContext interface

+ ClassNamedParameterList func() IClassNamedParameterListContext

+ GetParser func() antlr.Parser

+ IsClassNamedParametersContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ type IClassSuperContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllMemberAccess func() []IMemberAccessContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsClassSuperContext func()

+ MemberAccess func(i int) IMemberAccessContext

+ type ICommandAccessPointContext interface

+ CommandAccessPoint func() ICommandAccessPointContext

+ DOT func() antlr.TerminalNode

+ DOUBLE_COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsCommandAccessPointContext func()

+ type ICommandExpressionContext interface

+ AllConditionalExpression func() []IConditionalExpressionContext

+ AllMemberAccess func() []IMemberAccessContext

+ AllOption func() []IOptionContext

+ BITAND func() antlr.TerminalNode

+ CommandJoin func() ICommandJoinContext

+ CommandStream func() ICommandStreamContext

+ CommandStringLiteral func() antlr.TerminalNode

+ ConditionalExpression func(i int) IConditionalExpressionContext

+ DEC func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsCommandExpressionContext func()

+ MemberAccess func(i int) IMemberAccessContext

+ Option func(i int) IOptionContext

+ type ICommandJoinContext interface

+ AND func() antlr.TerminalNode

+ CommandExpression func() ICommandExpressionContext

+ GetParser func() antlr.Parser

+ IsCommandJoinContext func()

+ OR func() antlr.TerminalNode

+ type ICommandMemberAccessContext interface

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsCommandMemberAccessContext func()

+ MemberAccessPoint func() IMemberAccessPointContext

+ type ICommandStreamContext interface

+ BITOR func() antlr.TerminalNode

+ CommandExpression func() ICommandExpressionContext

+ GT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsCommandStreamContext func()

+ LT func() antlr.TerminalNode

+ SHL func() antlr.TerminalNode

+ SHR func() antlr.TerminalNode

+ type ICommentContext interface

+ BlockComment func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsCommentContext func()

+ LineComment func() antlr.TerminalNode

+ type ICompositeTypeContext interface

+ BITAND func() antlr.TerminalNode

+ BITOR func() antlr.TerminalNode

+ CompositeType func() ICompositeTypeContext

+ GetParser func() antlr.Parser

+ IsCompositeTypeContext func()

+ Type_ func() ITypeContext

+ type IComptimeExpressionContext interface

+ Block func() IBlockContext

+ COMPTIME func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsComptimeExpressionContext func()

+ type IConditionalBoolExpressionContext interface

+ AND func(i int) antlr.TerminalNode

+ AllAND func() []antlr.TerminalNode

+ AllBITAND func() []antlr.TerminalNode

+ AllBITOR func() []antlr.TerminalNode

+ AllBITXOR func() []antlr.TerminalNode

+ AllLogicalExpression func() []ILogicalExpressionContext

+ AllOR func() []antlr.TerminalNode

+ BITAND func(i int) antlr.TerminalNode

+ BITOR func(i int) antlr.TerminalNode

+ BITXOR func(i int) antlr.TerminalNode

+ GetConditionalOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsConditionalBoolExpressionContext func()

+ LogicalExpression func(i int) ILogicalExpressionContext

+ OR func(i int) antlr.TerminalNode

+ SetConditionalOp func(antlr.Token)

+ type IConditionalExpressionContext interface

+ AllConditionalExpression func() []IConditionalExpressionContext

+ COLON func() antlr.TerminalNode

+ ConditionalBoolExpression func() IConditionalBoolExpressionContext

+ ConditionalExpression func(i int) IConditionalExpressionContext

+ GetParser func() antlr.Parser

+ IsConditionalExpressionContext func()

+ QUEST func() antlr.TerminalNode

+ type IContinueStatementContext interface

+ CONTINUE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsContinueStatementContext func()

+ type IDeclareStatementContext interface

+ Block func() IBlockContext

+ ClassDeclaration func() IClassDeclarationContext

+ DECLARE func() antlr.TerminalNode

+ EnumDeclaration func() IEnumDeclarationContext

+ FunctionDeclaration func() IFunctionDeclarationContext

+ GetParser func() antlr.Parser

+ IsDeclareStatementContext func()

+ ModuleDeclaration func() IModuleDeclarationContext

+ TraitDeclaration func() ITraitDeclarationContext

+ TypeDeclaration func() ITypeDeclarationContext

+ type IDeferStatementContext interface

+ CallExpression func() ICallExpressionContext

+ DEFER func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsDeferStatementContext func()

+ type IDoWhileStatementContext interface

+ Block func() IBlockContext

+ DO func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsDoWhileStatementContext func()

+ LOOP func() antlr.TerminalNode

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IEnumAssociatedConstructorContext interface

+ AllEnumConstructor func() []IEnumConstructorContext

+ EnumConstructor func(i int) IEnumConstructorContext

+ GetParser func() antlr.Parser

+ IsEnumAssociatedConstructorContext func()

+ type IEnumAssociatedFieldContext interface

+ AllEnumFieldModifier func() []IEnumFieldModifierContext

+ COLON func() antlr.TerminalNode

+ EnumFieldModifier func(i int) IEnumFieldModifierContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsEnumAssociatedFieldContext func()

+ Type_ func() ITypeContext

+ type IEnumAssociatedFieldsContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllEnumAssociatedField func() []IEnumAssociatedFieldContext

+ COMMA func(i int) antlr.TerminalNode

+ EnumAssociatedField func(i int) IEnumAssociatedFieldContext

+ GetParser func() antlr.Parser

+ IsEnumAssociatedFieldsContext func()

+ SEMI func() antlr.TerminalNode

+ type IEnumAssociatedMethodsContext interface

+ AllEnumMethod func() []IEnumMethodContext

+ EnumMethod func(i int) IEnumMethodContext

+ GetParser func() antlr.Parser

+ IsEnumAssociatedMethodsContext func()

+ type IEnumAssociatedValueContext interface

+ ExpressionList func() IExpressionListContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsEnumAssociatedValueContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IEnumAssociatedValuesContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllComment func() []ICommentContext

+ AllEnumAssociatedValue func() []IEnumAssociatedValueContext

+ COMMA func(i int) antlr.TerminalNode

+ Comment func(i int) ICommentContext

+ EnumAssociatedValue func(i int) IEnumAssociatedValueContext

+ GetParser func() antlr.Parser

+ IsEnumAssociatedValuesContext func()

+ type IEnumBodyADTContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllComment func() []ICommentContext

+ AllEnumVariant func() []IEnumVariantContext

+ COMMA func(i int) antlr.TerminalNode

+ Comment func(i int) ICommentContext

+ EnumMethods func() IEnumMethodsContext

+ EnumVariant func(i int) IEnumVariantContext

+ GetParser func() antlr.Parser

+ IsEnumBodyADTContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ type IEnumBodyAssociatedContext interface

+ EnumAssociatedConstructor func() IEnumAssociatedConstructorContext

+ EnumAssociatedFields func() IEnumAssociatedFieldsContext

+ EnumAssociatedMethods func() IEnumAssociatedMethodsContext

+ EnumAssociatedValues func() IEnumAssociatedValuesContext

+ GetParser func() antlr.Parser

+ IsEnumBodyAssociatedContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ SEMI func() antlr.TerminalNode

+ type IEnumBodySimpleContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllComment func() []ICommentContext

+ AllEnumValue func() []IEnumValueContext

+ COMMA func(i int) antlr.TerminalNode

+ Comment func(i int) ICommentContext

+ EnumValue func(i int) IEnumValueContext

+ GetParser func() antlr.Parser

+ IsEnumBodySimpleContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ type IEnumBuiltinMethodModifierContext interface

+ CONST func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsEnumBuiltinMethodModifierContext func()

+ type IEnumConstructorContext interface

+ AllMacroStatement func() []IMacroStatementContext

+ Block func() IBlockContext

+ DOUBLE_ARROW func() antlr.TerminalNode

+ EnumBuiltinMethodModifier func() IEnumBuiltinMethodModifierContext

+ EnumConstructorInit func() IEnumConstructorInitContext

+ EnumConstructorName func() IEnumConstructorNameContext

+ EnumConstructorParameters func() IEnumConstructorParametersContext

+ GetParser func() antlr.Parser

+ IsEnumConstructorContext func()

+ MacroStatement func(i int) IMacroStatementContext

+ SEMI func() antlr.TerminalNode

+ THROWS func() antlr.TerminalNode

+ type IEnumConstructorDirectInitContext interface

+ ASSIGN func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsEnumConstructorDirectInitContext func()

+ VariableExpression func() IVariableExpressionContext

+ type IEnumConstructorInitContext interface

+ COLON func() antlr.TerminalNode

+ EnumConstructorDirectInit func() IEnumConstructorDirectInitContext

+ GetParser func() antlr.Parser

+ IsEnumConstructorInitContext func()

+ type IEnumConstructorNameContext interface

+ AllIdentifier func() []antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func(i int) antlr.TerminalNode

+ IsEnumConstructorNameContext func()

+ type IEnumConstructorParametersContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllEnumConstructorDirectInit func() []IEnumConstructorDirectInitContext

+ COMMA func(i int) antlr.TerminalNode

+ EnumConstructorDirectInit func(i int) IEnumConstructorDirectInitContext

+ GetParser func() antlr.Parser

+ IsEnumConstructorParametersContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ ReceiverParameterList func() IReceiverParameterListContext

+ type IEnumDeclarationContext interface

+ AllMacroStatement func() []IMacroStatementContext

+ ENUM func() antlr.TerminalNode

+ EnumBodyADT func() IEnumBodyADTContext

+ EnumBodyAssociated func() IEnumBodyAssociatedContext

+ EnumBodySimple func() IEnumBodySimpleContext

+ EnumModifier func() IEnumModifierContext

+ GenericParameters func() IGenericParametersContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsEnumDeclarationContext func()

+ MacroStatement func(i int) IMacroStatementContext

+ type IEnumFieldContext interface

+ COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsEnumFieldContext func()

+ Type_ func() ITypeContext

+ type IEnumFieldModifierContext interface

+ CONST func() antlr.TerminalNode

+ FINAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsEnumFieldModifierContext func()

+ type IEnumInitializeContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllEnumInitializeMember func() []IEnumInitializeMemberContext

+ COMMA func(i int) antlr.TerminalNode

+ EnumInitializeMember func(i int) IEnumInitializeMemberContext

+ GetParser func() antlr.Parser

+ IsEnumInitializeContext func()

+ SEMI func() antlr.TerminalNode

+ type IEnumInitializeMemberContext interface

+ ExpressionList func() IExpressionListContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsEnumInitializeMemberContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IEnumMemberContext interface

+ AllEnumMemberModifier func() []IEnumMemberModifierContext

+ AllMacroStatement func() []IMacroStatementContext

+ COLON func() antlr.TerminalNode

+ EnumMemberModifier func(i int) IEnumMemberModifierContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsEnumMemberContext func()

+ MacroStatement func(i int) IMacroStatementContext

+ Type_ func() ITypeContext

+ type IEnumMemberModifierContext interface

+ FINAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsEnumMemberModifierContext func()

+ PUB func() antlr.TerminalNode

+ type IEnumMethodContext interface

+ AllEnumMethodModifier func() []IEnumMethodModifierContext

+ AllMacroStatement func() []IMacroStatementContext

+ EnumMethodModifier func(i int) IEnumMethodModifierContext

+ GetParser func() antlr.Parser

+ IsEnumMethodContext func()

+ LambdaFunctionDeclaration func() ILambdaFunctionDeclarationContext

+ MacroStatement func(i int) IMacroStatementContext

+ StandardFunctionDeclaration func() IStandardFunctionDeclarationContext

+ type IEnumMethodModifierContext interface

+ GetParser func() antlr.Parser

+ IsEnumMethodModifierContext func()

+ PUB func() antlr.TerminalNode

+ STATIC func() antlr.TerminalNode

+ type IEnumMethodsContext interface

+ AllEnumMethod func() []IEnumMethodContext

+ EnumMethod func(i int) IEnumMethodContext

+ GetParser func() antlr.Parser

+ IsEnumMethodsContext func()

+ type IEnumModifierContext interface

+ FINAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsEnumModifierContext func()

+ PUB func() antlr.TerminalNode

+ type IEnumValueContext interface

+ ASSIGN func() antlr.TerminalNode

+ Comment func() ICommentContext

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsEnumValueContext func()

+ type IEnumVariantContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllEnumField func() []IEnumFieldContext

+ COMMA func(i int) antlr.TerminalNode

+ EnumField func(i int) IEnumFieldContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsEnumVariantContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ type IExpressionContext interface

+ ChannelOutputExpression func() IChannelOutputExpressionContext

+ ClassInitializeExpression func() IClassInitializeExpressionContext

+ CommandExpression func() ICommandExpressionContext

+ ComptimeExpression func() IComptimeExpressionContext

+ ConditionalExpression func() IConditionalExpressionContext

+ GetParser func() antlr.Parser

+ IsExpressionContext func()

+ LambdaExpression func() ILambdaExpressionContext

+ NewDelExpression func() INewDelExpressionContext

+ TypeofExpression func() ITypeofExpressionContext

+ UnsafeExpression func() IUnsafeExpressionContext

+ type IExpressionListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpression func() []IExpressionContext

+ COMMA func(i int) antlr.TerminalNode

+ Expression func(i int) IExpressionContext

+ GetParser func() antlr.Parser

+ IsExpressionListContext func()

+ type IExpressionStatementContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsExpressionStatementContext func()

+ type IExtendClassContext interface

+ CLASS func() antlr.TerminalNode

+ ClassBody func() IClassBodyContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsExtendClassContext func()

+ type IExtendDeclarationContext interface

+ EXTEND func() antlr.TerminalNode

+ ExtendClass func() IExtendClassContext

+ ExtendEnum func() IExtendEnumContext

+ ExtendMod func() IExtendModContext

+ ExtendTrait func() IExtendTraitContext

+ ExtendType func() IExtendTypeContext

+ GetParser func() antlr.Parser

+ IsExtendDeclarationContext func()

+ type IExtendEnumContext interface

+ ENUM func() antlr.TerminalNode

+ EnumBodyADT func() IEnumBodyADTContext

+ EnumBodyAssociated func() IEnumBodyAssociatedContext

+ EnumBodySimple func() IEnumBodySimpleContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsExtendEnumContext func()

+ type IExtendModContext interface

+ AllModuleStatement func() []IModuleStatementContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsExtendModContext func()

+ LBRACE func() antlr.TerminalNode

+ MOD_LIT func() antlr.TerminalNode

+ ModuleStatement func(i int) IModuleStatementContext

+ RBRACE func() antlr.TerminalNode

+ type IExtendTraitContext interface

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsExtendTraitContext func()

+ TRAIT func() antlr.TerminalNode

+ TraitBody func() ITraitBodyContext

+ type IExtendTypeContext interface

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsExtendTypeContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ TYPE func() antlr.TerminalNode

+ Type_ func() ITypeContext

+ type IExternDeclarationContext interface

+ EXTERN func() antlr.TerminalNode

+ ExternList func() IExternListContext

+ GetParser func() antlr.Parser

+ IsExternDeclarationContext func()

+ type IExternItemContext interface

+ COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsExternItemContext func()

+ Type_ func() ITypeContext

+ type IExternListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllExternItem func() []IExternItemContext

+ COMMA func(i int) antlr.TerminalNode

+ ExternItem func(i int) IExternItemContext

+ GetParser func() antlr.Parser

+ IsExternListContext func()

+ type IFactorContext interface

+ CallExpression func() ICallExpressionContext

+ Factor func() IFactorContext

+ FileExpression func() IFileExpressionContext

+ GetParser func() antlr.Parser

+ IsFactorContext func()

+ LPAREN func() antlr.TerminalNode

+ ListExpression func() IListExpressionContext

+ Literal func() ILiteralContext

+ MapExpression func() IMapExpressionContext

+ MethodExpression func() IMethodExpressionContext

+ RPAREN func() antlr.TerminalNode

+ SUB func() antlr.TerminalNode

+ TripleExpression func() ITripleExpressionContext

+ VariableExpression func() IVariableExpressionContext

+ type IFileContext interface

+ AllSEMI func() []antlr.TerminalNode

+ AllStatement func() []IStatementContext

+ GetParser func() antlr.Parser

+ IsFileContext func()

+ SEMI func(i int) antlr.TerminalNode

+ Statement func(i int) IStatementContext

+ type IFileExpressionContext interface

+ CallExpressionLinkedList func() ICallExpressionLinkedListContext

+ FileStringLiteral func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsFileExpressionContext func()

+ type IFinallyClauseContext interface

+ Block func() IBlockContext

+ FINALLY func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsFinallyClauseContext func()

+ type IForClauseContext interface

+ AllExpression func() []IExpressionContext

+ AllSEMI func() []antlr.TerminalNode

+ Expression func(i int) IExpressionContext

+ GetParser func() antlr.Parser

+ IsForClauseContext func()

+ SEMI func(i int) antlr.TerminalNode

+ Statement func() IStatementContext

+ type IForStatementContext interface

+ Block func() IBlockContext

+ ForClause func() IForClauseContext

+ GetParser func() antlr.Parser

+ IsForStatementContext func()

+ LOOP func() antlr.TerminalNode

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IForeachClauseContext interface

+ AllForeachVariableName func() []IForeachVariableNameContext

+ COMMA func() antlr.TerminalNode

+ ForeachVariableName func(i int) IForeachVariableNameContext

+ GetParser func() antlr.Parser

+ IsForeachClauseContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IForeachStatementContext interface

+ Block func() IBlockContext

+ Expression func() IExpressionContext

+ ForeachClause func() IForeachClauseContext

+ GetParser func() antlr.Parser

+ IN func() antlr.TerminalNode

+ IsForeachStatementContext func()

+ LOOP func() antlr.TerminalNode

+ OF func() antlr.TerminalNode

+ type IForeachVariableNameContext interface

+ GetParser func() antlr.Parser

+ IsForeachVariableNameContext func()

+ VariableExpression func() IVariableExpressionContext

+ VariableName func() IVariableNameContext

+ type IFunctionDeclarationContext interface

+ FunctionSignature func() IFunctionSignatureContext

+ GetParser func() antlr.Parser

+ IsFunctionDeclarationContext func()

+ LambdaFunctionDeclaration func() ILambdaFunctionDeclarationContext

+ StandardFunctionDeclaration func() IStandardFunctionDeclarationContext

+ type IFunctionModifierContext interface

+ COMPTIME func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsFunctionModifierContext func()

+ PUB func() antlr.TerminalNode

+ type IFunctionReturnValueContext interface

+ GetParser func() antlr.Parser

+ IsFunctionReturnValueContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ TypeList func() ITypeListContext

+ Type_ func() ITypeContext

+ type IFunctionSignatureContext interface

+ ARROW func() antlr.TerminalNode

+ AllFunctionModifier func() []IFunctionModifierContext

+ FN func() antlr.TerminalNode

+ FunctionModifier func(i int) IFunctionModifierContext

+ FunctionReturnValue func() IFunctionReturnValueContext

+ GenericParameters func() IGenericParametersContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsFunctionSignatureContext func()

+ OperatorIdentifier func() IOperatorIdentifierContext

+ ReceiverParameters func() IReceiverParametersContext

+ THROWS func() antlr.TerminalNode

+ type IFunctionTypeContext interface

+ ARROW func() antlr.TerminalNode

+ FunctionReturnValue func() IFunctionReturnValueContext

+ GetParser func() antlr.Parser

+ IsFunctionTypeContext func()

+ ReceiverParameters func() IReceiverParametersContext

+ THROWS func() antlr.TerminalNode

+ type IGenericArgumentsContext interface

+ GT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsGenericArgumentsContext func()

+ LT func() antlr.TerminalNode

+ TypeList func() ITypeListContext

+ type IGenericParameterContext interface

+ COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsGenericParameterContext func()

+ Type_ func() ITypeContext

+ type IGenericParameterListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllGenericParameter func() []IGenericParameterContext

+ COMMA func(i int) antlr.TerminalNode

+ GenericParameter func(i int) IGenericParameterContext

+ GetParser func() antlr.Parser

+ IsGenericParameterListContext func()

+ type IGenericParametersContext interface

+ GT func() antlr.TerminalNode

+ GenericParameterList func() IGenericParameterListContext

+ GetParser func() antlr.Parser

+ IsGenericParametersContext func()

+ LT func() antlr.TerminalNode

+ type IIdentifierAsIdentifierContext interface

+ AsIdentifier func() IAsIdentifierContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsIdentifierAsIdentifierContext func()

+ type IIfStatementContext interface

+ AllBlock func() []IBlockContext

+ Block func(i int) IBlockContext

+ ConditionalExpression func() IConditionalExpressionContext

+ ELSE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IF func() antlr.TerminalNode

+ IfStatement func() IIfStatementContext

+ IsIfStatementContext func()

+ type IImplDeclarationBindingContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllMemberAccess func() []IMemberAccessContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsImplDeclarationBindingContext func()

+ MemberAccess func(i int) IMemberAccessContext

+ type IImplDeclarationBodyContext interface

+ ClassBody func() IClassBodyContext

+ GetParser func() antlr.Parser

+ IsImplDeclarationBodyContext func()

+ MemberAccess func() IMemberAccessContext

+ type IImplDeclarationContext interface

+ FOR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IMPL func() antlr.TerminalNode

+ ImplDeclarationBinding func() IImplDeclarationBindingContext

+ ImplDeclarationBody func() IImplDeclarationBodyContext

+ IsImplDeclarationContext func()

+ MemberAccess func() IMemberAccessContext

+ type IImportAllContext interface

+ AsIdentifier func() IAsIdentifierContext

+ FROM func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsImportAllContext func()

+ MUL func() antlr.TerminalNode

+ StringLiteral func() antlr.TerminalNode

+ type IImportDeclarationContext interface

+ GetParser func() antlr.Parser

+ IMPORT func() antlr.TerminalNode

+ ImportAll func() IImportAllContext

+ ImportMulti func() IImportMultiContext

+ ImportSingle func() IImportSingleContext

+ IsImportDeclarationContext func()

+ type IImportMultiContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllIdentifierAsIdentifier func() []IIdentifierAsIdentifierContext

+ COMMA func(i int) antlr.TerminalNode

+ FROM func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IdentifierAsIdentifier func(i int) IIdentifierAsIdentifierContext

+ IsImportMultiContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ StringLiteral func() antlr.TerminalNode

+ type IImportSingleContext interface

+ AsIdentifier func() IAsIdentifierContext

+ GetParser func() antlr.Parser

+ IsImportSingleContext func()

+ StringLiteral func() antlr.TerminalNode

+ type IIncDecExpressionContext interface

+ GetParser func() antlr.Parser

+ IsIncDecExpressionContext func()

+ PostIncDecExpression func() IPostIncDecExpressionContext

+ PreIncDecExpression func() IPreIncDecExpressionContext

+ type IIntersectionTypeContext interface

+ AllBITAND func() []antlr.TerminalNode

+ AllType_ func() []ITypeContext

+ BITAND func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsIntersectionTypeContext func()

+ Type_ func(i int) ITypeContext

+ type ILambdaAssignStatementContext interface

+ COLON_ASSIGN func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsLambdaAssignStatementContext func()

+ MatchStatement func() IMatchStatementContext

+ VariableExpression func() IVariableExpressionContext

+ type ILambdaBodyContext interface

+ Block func() IBlockContext

+ Expression func() IExpressionContext

+ ExpressionList func() IExpressionListContext

+ GetParser func() antlr.Parser

+ IsLambdaBodyContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ type ILambdaExpressionContext interface

+ DOUBLE_ARROW func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsLambdaExpressionContext func()

+ LambdaBody func() ILambdaBodyContext

+ ReceiverParameters func() IReceiverParametersContext

+ type ILambdaFunctionDeclarationContext interface

+ AllFunctionModifier func() []IFunctionModifierContext

+ FN func() antlr.TerminalNode

+ FunctionModifier func(i int) IFunctionModifierContext

+ GenericParameters func() IGenericParametersContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsLambdaFunctionDeclarationContext func()

+ LambdaExpression func() ILambdaExpressionContext

+ OperatorIdentifier func() IOperatorIdentifierContext

+ type IListExpressionContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpression func() []IExpressionContext

+ COMMA func(i int) antlr.TerminalNode

+ Expression func(i int) IExpressionContext

+ GetParser func() antlr.Parser

+ IsListExpressionContext func()

+ LBRACK func() antlr.TerminalNode

+ RBRACK func() antlr.TerminalNode

+ type ILiteralContext interface

+ BoolLiteral func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsLiteralContext func()

+ NULL func() antlr.TerminalNode

+ NumberLiteral func() antlr.TerminalNode

+ StringLiteral func() antlr.TerminalNode

+ type ILogicalExpressionContext interface

+ AllEQ func() []antlr.TerminalNode

+ AllGE func() []antlr.TerminalNode

+ AllGT func() []antlr.TerminalNode

+ AllLE func() []antlr.TerminalNode

+ AllLT func() []antlr.TerminalNode

+ AllMOD func() []antlr.TerminalNode

+ AllNEQ func() []antlr.TerminalNode

+ AllShiftExpression func() []IShiftExpressionContext

+ EQ func(i int) antlr.TerminalNode

+ GE func(i int) antlr.TerminalNode

+ GT func(i int) antlr.TerminalNode

+ GetLogicalOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IsLogicalExpressionContext func()

+ LE func(i int) antlr.TerminalNode

+ LT func(i int) antlr.TerminalNode

+ MOD func(i int) antlr.TerminalNode

+ NEQ func(i int) antlr.TerminalNode

+ SetLogicalOp func(antlr.Token)

+ ShiftExpression func(i int) IShiftExpressionContext

+ StringLiteral func() antlr.TerminalNode

+ TypeofExpression func() ITypeofExpressionContext

+ type ILongOptionContext interface

+ DEC func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsLongOptionContext func()

+ type ILoopLabelContext interface

+ COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsLoopLabelContext func()

+ type ILoopStatementContext interface

+ DoWhileStatement func() IDoWhileStatementContext

+ ForStatement func() IForStatementContext

+ ForeachStatement func() IForeachStatementContext

+ GetParser func() antlr.Parser

+ IsLoopStatementContext func()

+ LoopLabel func() ILoopLabelContext

+ RangeStatement func() IRangeStatementContext

+ WhileStatement func() IWhileStatementContext

+ type IMacroStatementContext interface

+ AT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMacroStatementContext func()

+ LPAREN func() antlr.TerminalNode

+ MemberAccess func() IMemberAccessContext

+ RPAREN func() antlr.TerminalNode

+ ReceiverArgumentList func() IReceiverArgumentListContext

+ type IMapExpressionContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllPair func() []IPairContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMapExpressionContext func()

+ LBRACE func() antlr.TerminalNode

+ Pair func(i int) IPairContext

+ RBRACE func() antlr.TerminalNode

+ type IMatchCaseBodyContext interface

+ Block func() IBlockContext

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsMatchCaseBodyContext func()

+ ReturnStatement func() IReturnStatementContext

+ type IMatchCaseClauseContext interface

+ DOUBLE_ARROW func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsMatchCaseClauseContext func()

+ MatchCaseBody func() IMatchCaseBodyContext

+ MatchEnum func() IMatchEnumContext

+ MatchTriple func() IMatchTripleContext

+ MemberAccess func() IMemberAccessContext

+ RangeExpression func() IRangeExpressionContext

+ Type_ func() ITypeContext

+ type IMatchDefaultClauseContext interface

+ DOUBLE_ARROW func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMatchDefaultClauseContext func()

+ MatchCaseBody func() IMatchCaseBodyContext

+ WILDCARD func() antlr.TerminalNode

+ type IMatchEnumContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllMatchEnumMember func() []IMatchEnumMemberContext

+ COMMA func(i int) antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IF func() antlr.TerminalNode

+ IsMatchEnumContext func()

+ LPAREN func() antlr.TerminalNode

+ MatchEnumMember func(i int) IMatchEnumMemberContext

+ MemberAccess func() IMemberAccessContext

+ RPAREN func() antlr.TerminalNode

+ type IMatchEnumMemberContext interface

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsMatchEnumMemberContext func()

+ Literal func() ILiteralContext

+ WILDCARD func() antlr.TerminalNode

+ type IMatchStatementContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllComment func() []ICommentContext

+ AllMatchCaseClause func() []IMatchCaseClauseContext

+ COMMA func(i int) antlr.TerminalNode

+ Comment func(i int) ICommentContext

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsMatchStatementContext func()

+ LBRACE func() antlr.TerminalNode

+ MATCH func() antlr.TerminalNode

+ MatchCaseClause func(i int) IMatchCaseClauseContext

+ MatchDefaultClause func() IMatchDefaultClauseContext

+ RBRACE func() antlr.TerminalNode

+ type IMatchTripleContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllMatchTripleValue func() []IMatchTripleValueContext

+ COMMA func(i int) antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IF func() antlr.TerminalNode

+ IsMatchTripleContext func()

+ LPAREN func() antlr.TerminalNode

+ MatchTripleValue func(i int) IMatchTripleValueContext

+ RPAREN func() antlr.TerminalNode

+ type IMatchTripleValueContext interface

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsMatchTripleValueContext func()

+ WILDCARD func() antlr.TerminalNode

+ type IMemberAccessContext interface

+ BOOL func() antlr.TerminalNode

+ GenericArguments func() IGenericArgumentsContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsMemberAccessContext func()

+ Literal func() ILiteralContext

+ MemberAccessPoint func() IMemberAccessPointContext

+ NOT func() antlr.TerminalNode

+ NUM func() antlr.TerminalNode

+ STR func() antlr.TerminalNode

+ SUPER func() antlr.TerminalNode

+ THIS func() antlr.TerminalNode

+ type IMemberAccessPointContext interface

+ DOT func() antlr.TerminalNode

+ DOUBLE_COLON func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GenericArguments func() IGenericArgumentsContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsMemberAccessPointContext func()

+ LBRACK func() antlr.TerminalNode

+ MemberAccessPoint func() IMemberAccessPointContext

+ RBRACK func() antlr.TerminalNode

+ VariableExpression func() IVariableExpressionContext

+ type IMethodExpressionContext interface

+ DOLLAR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMethodExpressionContext func()

+ LPAREN func() antlr.TerminalNode

+ MemberAccess func() IMemberAccessContext

+ RPAREN func() antlr.TerminalNode

+ ReceiverArgumentList func() IReceiverArgumentListContext

+ type IModuleDeclarationContext interface

+ AllModuleStatement func() []IModuleStatementContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsModuleDeclarationContext func()

+ LBRACE func() antlr.TerminalNode

+ MOD_LIT func() antlr.TerminalNode

+ ModuleStatement func(i int) IModuleStatementContext

+ PUB func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ type IModuleStatementContext interface

+ AssignStatement func() IAssignStatementContext

+ ClassDeclaration func() IClassDeclarationContext

+ EnumDeclaration func() IEnumDeclarationContext

+ ExtendDeclaration func() IExtendDeclarationContext

+ FunctionDeclaration func() IFunctionDeclarationContext

+ GetParser func() antlr.Parser

+ IsModuleStatementContext func()

+ ModuleDeclaration func() IModuleDeclarationContext

+ TraitDeclaration func() ITraitDeclarationContext

+ UseDeclaration func() IUseDeclarationContext

+ type IMulDivExpressionContext interface

+ AllDIV func() []antlr.TerminalNode

+ AllIncDecExpression func() []IIncDecExpressionContext

+ AllMUL func() []antlr.TerminalNode

+ DIV func(i int) antlr.TerminalNode

+ GetMulDivOp func() antlr.Token

+ GetParser func() antlr.Parser

+ IncDecExpression func(i int) IIncDecExpressionContext

+ IsMulDivExpressionContext func()

+ MUL func(i int) antlr.TerminalNode

+ SetMulDivOp func(antlr.Token)

+ type INamedArgumentContext interface

+ COLON func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsNamedArgumentContext func()

+ type INamedArgumentListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllNamedArgument func() []INamedArgumentContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsNamedArgumentListContext func()

+ NamedArgument func(i int) INamedArgumentContext

+ type INamedParameterContext interface

+ GetParser func() antlr.Parser

+ IsNamedParameterContext func()

+ REQUIRED func() antlr.TerminalNode

+ ReceiverParameter func() IReceiverParameterContext

+ type INamedParameterListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllNamedParameter func() []INamedParameterContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsNamedParameterListContext func()

+ NamedParameter func(i int) INamedParameterContext

+ type INamedParametersContext interface

+ GetParser func() antlr.Parser

+ IsNamedParametersContext func()

+ LBRACE func() antlr.TerminalNode

+ NamedParameterList func() INamedParameterListContext

+ RBRACE func() antlr.TerminalNode

+ type INewDelExpressionContext interface

+ CallExpression func() ICallExpressionContext

+ DELETE func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsNewDelExpressionContext func()

+ NEW func() antlr.TerminalNode

+ type INullableTypeContext interface

+ GetParser func() antlr.Parser

+ IsNullableTypeContext func()

+ QUEST func() antlr.TerminalNode

+ Type_ func() ITypeContext

+ type IObjectTypeContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllObjectTypeMember func() []IObjectTypeMemberContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsObjectTypeContext func()

+ LBRACE func() antlr.TerminalNode

+ ObjectTypeMember func(i int) IObjectTypeMemberContext

+ RBRACE func() antlr.TerminalNode

+ type IObjectTypeMemberContext interface

+ COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsObjectTypeMemberContext func()

+ Type_ func() ITypeContext

+ type IOperatorIdentifierContext interface

+ ADD func() antlr.TerminalNode

+ DELETE func() antlr.TerminalNode

+ DIV func() antlr.TerminalNode

+ GT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ HASH func() antlr.TerminalNode

+ IsOperatorIdentifierContext func()

+ LBRACK func() antlr.TerminalNode

+ LT func() antlr.TerminalNode

+ MOD func() antlr.TerminalNode

+ MUL func() antlr.TerminalNode

+ NEW func() antlr.TerminalNode

+ OPERATOR func() antlr.TerminalNode

+ RBRACK func() antlr.TerminalNode

+ SHL func() antlr.TerminalNode

+ SHR func() antlr.TerminalNode

+ SUB func() antlr.TerminalNode

+ type IOptionContext interface

+ GetParser func() antlr.Parser

+ IsOptionContext func()

+ LongOption func() ILongOptionContext

+ ShortOption func() IShortOptionContext

+ type IPairContext interface

+ BoolLiteral func() antlr.TerminalNode

+ COLON func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsPairContext func()

+ NumberLiteral func() antlr.TerminalNode

+ StringLiteral func() antlr.TerminalNode

+ type IPostIncDecExpressionContext interface

+ DEC func() antlr.TerminalNode

+ Factor func() IFactorContext

+ GetParser func() antlr.Parser

+ INC func() antlr.TerminalNode

+ IsPostIncDecExpressionContext func()

+ type IPreIncDecExpressionContext interface

+ DEC func() antlr.TerminalNode

+ Factor func() IFactorContext

+ GetParser func() antlr.Parser

+ INC func() antlr.TerminalNode

+ IsPreIncDecExpressionContext func()

+ type IRangeClauseContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpression func() []IExpressionContext

+ COMMA func(i int) antlr.TerminalNode

+ Expression func(i int) IExpressionContext

+ GetParser func() antlr.Parser

+ IsRangeClauseContext func()

+ LPAREN func() antlr.TerminalNode

+ RANGE func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type IRangeExpressionContext interface

+ AllNumberLiteral func() []antlr.TerminalNode

+ DOUBLE_DOT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsRangeExpressionContext func()

+ NumberLiteral func(i int) antlr.TerminalNode

+ type IRangeStatementContext interface

+ Block func() IBlockContext

+ GetParser func() antlr.Parser

+ IN func() antlr.TerminalNode

+ Identifier func() antlr.TerminalNode

+ IsRangeStatementContext func()

+ LOOP func() antlr.TerminalNode

+ RangeClause func() IRangeClauseContext

+ type IReceiverArgumentListContext interface

+ COMMA func() antlr.TerminalNode

+ ExpressionList func() IExpressionListContext

+ GetParser func() antlr.Parser

+ IsReceiverArgumentListContext func()

+ NamedArgumentList func() INamedArgumentListContext

+ type IReceiverParameterContext interface

+ ASSIGN func() antlr.TerminalNode

+ AllComment func() []ICommentContext

+ COLON func() antlr.TerminalNode

+ Comment func(i int) ICommentContext

+ ELLIPSIS func() antlr.TerminalNode

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsReceiverParameterContext func()

+ QUEST func() antlr.TerminalNode

+ Type_ func() ITypeContext

+ type IReceiverParameterListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllReceiverParameter func() []IReceiverParameterContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsReceiverParameterListContext func()

+ ReceiverParameter func(i int) IReceiverParameterContext

+ type IReceiverParametersContext interface

+ COMMA func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsReceiverParametersContext func()

+ LPAREN func() antlr.TerminalNode

+ NamedParameters func() INamedParametersContext

+ RPAREN func() antlr.TerminalNode

+ ReceiverParameterList func() IReceiverParameterListContext

+ type IReturnStatementContext interface

+ ExpressionList func() IExpressionListContext

+ GetParser func() antlr.Parser

+ IsReturnStatementContext func()

+ RETURN func() antlr.TerminalNode

+ type IShiftExpressionContext interface

+ AddSubExpression func(i int) IAddSubExpressionContext

+ AllAddSubExpression func() []IAddSubExpressionContext

+ AllSHL func() []antlr.TerminalNode

+ AllSHR func() []antlr.TerminalNode

+ GetParser func() antlr.Parser

+ GetShiftOp func() antlr.Token

+ IsShiftExpressionContext func()

+ SHL func(i int) antlr.TerminalNode

+ SHR func(i int) antlr.TerminalNode

+ SetShiftOp func(antlr.Token)

+ type IShortOptionContext interface

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsShortOptionContext func()

+ SUB func() antlr.TerminalNode

+ type IStandardFunctionDeclarationContext interface

+ ARROW func() antlr.TerminalNode

+ AllFunctionModifier func() []IFunctionModifierContext

+ Block func() IBlockContext

+ FN func() antlr.TerminalNode

+ FunctionModifier func(i int) IFunctionModifierContext

+ FunctionReturnValue func() IFunctionReturnValueContext

+ GenericParameters func() IGenericParametersContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsStandardFunctionDeclarationContext func()

+ OperatorIdentifier func() IOperatorIdentifierContext

+ ReceiverParameters func() IReceiverParametersContext

+ THROWS func() antlr.TerminalNode

+ type IStatementContext interface

+ AssignStatement func() IAssignStatementContext

+ BreakStatement func() IBreakStatementContext

+ ChannelInputStatement func() IChannelInputStatementContext

+ ClassDeclaration func() IClassDeclarationContext

+ Comment func() ICommentContext

+ ContinueStatement func() IContinueStatementContext

+ DeclareStatement func() IDeclareStatementContext

+ DeferStatement func() IDeferStatementContext

+ EnumDeclaration func() IEnumDeclarationContext

+ ExpressionStatement func() IExpressionStatementContext

+ ExtendDeclaration func() IExtendDeclarationContext

+ ExternDeclaration func() IExternDeclarationContext

+ FunctionDeclaration func() IFunctionDeclarationContext

+ GetParser func() antlr.Parser

+ IfStatement func() IIfStatementContext

+ ImplDeclaration func() IImplDeclarationContext

+ ImportDeclaration func() IImportDeclarationContext

+ IsStatementContext func()

+ LambdaAssignStatement func() ILambdaAssignStatementContext

+ LoopStatement func() ILoopStatementContext

+ MacroStatement func() IMacroStatementContext

+ MatchStatement func() IMatchStatementContext

+ ModuleDeclaration func() IModuleDeclarationContext

+ ReturnStatement func() IReturnStatementContext

+ ThrowStatement func() IThrowStatementContext

+ TraitDeclaration func() ITraitDeclarationContext

+ TryStatement func() ITryStatementContext

+ TypeDeclaration func() ITypeDeclarationContext

+ type IThrowStatementContext interface

+ CallExpression func() ICallExpressionContext

+ GetParser func() antlr.Parser

+ IsThrowStatementContext func()

+ NewDelExpression func() INewDelExpressionContext

+ THROW func() antlr.TerminalNode

+ type ITraitBodyContext interface

+ AllComment func() []ICommentContext

+ AllSEMI func() []antlr.TerminalNode

+ AllTraitMember func() []ITraitMemberContext

+ Comment func(i int) ICommentContext

+ GetParser func() antlr.Parser

+ IsTraitBodyContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ SEMI func(i int) antlr.TerminalNode

+ TraitMember func(i int) ITraitMemberContext

+ type ITraitDeclarationContext interface

+ AllMacroStatement func() []IMacroStatementContext

+ GenericParameters func() IGenericParametersContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsTraitDeclarationContext func()

+ MacroStatement func(i int) IMacroStatementContext

+ TRAIT func() antlr.TerminalNode

+ TraitBody func() ITraitBodyContext

+ TraitModifier func() ITraitModifierContext

+ type ITraitMemberContext interface

+ AllTraitMemberModifier func() []ITraitMemberModifierContext

+ COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsTraitMemberContext func()

+ OperatorIdentifier func() IOperatorIdentifierContext

+ TraitMemberModifier func(i int) ITraitMemberModifierContext

+ Type_ func() ITypeContext

+ type ITraitMemberModifierContext interface

+ CONST func() antlr.TerminalNode

+ FINAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsTraitMemberModifierContext func()

+ PUB func() antlr.TerminalNode

+ STATIC func() antlr.TerminalNode

+ type ITraitModifierContext interface

+ GetParser func() antlr.Parser

+ IsTraitModifierContext func()

+ PUB func() antlr.TerminalNode

+ type ITripleExpressionContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpression func() []IExpressionContext

+ COMMA func(i int) antlr.TerminalNode

+ Expression func(i int) IExpressionContext

+ GetParser func() antlr.Parser

+ IsTripleExpressionContext func()

+ LPAREN func() antlr.TerminalNode

+ RPAREN func() antlr.TerminalNode

+ type ITryStatementContext interface

+ AllCatchClause func() []ICatchClauseContext

+ Block func() IBlockContext

+ CatchClause func(i int) ICatchClauseContext

+ FinallyClause func() IFinallyClauseContext

+ GetParser func() antlr.Parser

+ IsTryStatementContext func()

+ TRY func() antlr.TerminalNode

+ type ITupleTypeContext interface

+ GetParser func() antlr.Parser

+ IsTupleTypeContext func()

+ LBRACK func() antlr.TerminalNode

+ RBRACK func() antlr.TerminalNode

+ TypeList func() ITypeListContext

+ type ITypeAccessPointContext interface

+ GetParser func() antlr.Parser

+ IsTypeAccessPointContext func()

+ LBRACK func() antlr.TerminalNode

+ NumberLiteral func() antlr.TerminalNode

+ RBRACK func() antlr.TerminalNode

+ TypeAccessPoint func() ITypeAccessPointContext

+ type ITypeContext interface

+ ANY func() antlr.TerminalNode

+ BOOL func() antlr.TerminalNode

+ Comment func() ICommentContext

+ CompositeType func() ICompositeTypeContext

+ FunctionType func() IFunctionTypeContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsTypeContext func()

+ MemberAccess func() IMemberAccessContext

+ NUM func() antlr.TerminalNode

+ ObjectType func() IObjectTypeContext

+ QUEST func() antlr.TerminalNode

+ STR func() antlr.TerminalNode

+ StringLiteral func() antlr.TerminalNode

+ TupleType func() ITupleTypeContext

+ TypeAccessPoint func() ITypeAccessPointContext

+ VOID func() antlr.TerminalNode

+ type ITypeDeclarationContext interface

+ ASSIGN func() antlr.TerminalNode

+ GenericParameters func() IGenericParametersContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsTypeDeclarationContext func()

+ TYPE func() antlr.TerminalNode

+ Type_ func() ITypeContext

+ type ITypeListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllType_ func() []ITypeContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsTypeListContext func()

+ Type_ func(i int) ITypeContext

+ type ITypeLiteralContext interface

+ ANY func() antlr.TerminalNode

+ BOOL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsTypeLiteralContext func()

+ NUM func() antlr.TerminalNode

+ STR func() antlr.TerminalNode

+ type ITypeofExpressionContext interface

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsTypeofExpressionContext func()

+ TYPEOF func() antlr.TerminalNode

+ type IUnionTypeContext interface

+ AllBITOR func() []antlr.TerminalNode

+ AllType_ func() []ITypeContext

+ BITOR func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsUnionTypeContext func()

+ Type_ func(i int) ITypeContext

+ type IUnsafeExpressionContext interface

+ GetParser func() antlr.Parser

+ IsUnsafeExpressionContext func()

+ UnsafeLiteral func() antlr.TerminalNode

+ type IUseAllContext interface

+ AsIdentifier func() IAsIdentifierContext

+ FROM func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsUseAllContext func()

+ MUL func() antlr.TerminalNode

+ StringLiteral func() antlr.TerminalNode

+ type IUseDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsUseDeclarationContext func()

+ USE func() antlr.TerminalNode

+ UseAll func() IUseAllContext

+ UseMulti func() IUseMultiContext

+ UseSingle func() IUseSingleContext

+ type IUseMultiContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllIdentifierAsIdentifier func() []IIdentifierAsIdentifierContext

+ COMMA func(i int) antlr.TerminalNode

+ FROM func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IdentifierAsIdentifier func(i int) IIdentifierAsIdentifierContext

+ IsUseMultiContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ StringLiteral func() antlr.TerminalNode

+ type IUseSingleContext interface

+ AsIdentifier func() IAsIdentifierContext

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsUseSingleContext func()

+ type IVariableExpressionContext interface

+ DOLLAR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsVariableExpressionContext func()

+ MemberAccess func() IMemberAccessContext

+ type IVariableNameContext interface

+ COLON func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Identifier func() antlr.TerminalNode

+ IsVariableNameContext func()

+ Type_ func() ITypeContext

+ WILDCARD func() antlr.TerminalNode

+ type IVariableNameListContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllVariableName func() []IVariableNameContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsVariableNameListContext func()

+ VariableName func(i int) IVariableNameContext

+ type IVariableNamesContext interface

+ GetParser func() antlr.Parser

+ IsVariableNamesContext func()

+ LBRACE func() antlr.TerminalNode

+ RBRACE func() antlr.TerminalNode

+ VariableNameList func() IVariableNameListContext

+ type IVariableNullableExpressionContext interface

+ GetParser func() antlr.Parser

+ IsVariableNullableExpressionContext func()

+ VariableExpression func() IVariableExpressionContext

+ WILDCARD func() antlr.TerminalNode

+ type IVariableNullableExpressionsContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllVariableNullableExpression func() []IVariableNullableExpressionContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsVariableNullableExpressionsContext func()

+ VariableNullableExpression func(i int) IVariableNullableExpressionContext

+ type IWhileStatementContext interface

+ Block func() IBlockContext

+ Expression func() IExpressionContext

+ GetParser func() antlr.Parser

+ IsWhileStatementContext func()

+ LOOP func() antlr.TerminalNode

+ type IdentifierAsIdentifierContext struct

+ func NewEmptyIdentifierAsIdentifierContext() *IdentifierAsIdentifierContext

+ func NewIdentifierAsIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierAsIdentifierContext

+ func (*IdentifierAsIdentifierContext) IsIdentifierAsIdentifierContext()

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

+ func (s *IdentifierAsIdentifierContext) AsIdentifier() IAsIdentifierContext

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

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

+ func (s *IdentifierAsIdentifierContext) Identifier() antlr.TerminalNode

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

+ type IfStatementContext struct

+ func NewEmptyIfStatementContext() *IfStatementContext

+ func NewIfStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStatementContext

+ func (*IfStatementContext) IsIfStatementContext()

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

+ func (s *IfStatementContext) AllBlock() []IBlockContext

+ func (s *IfStatementContext) Block(i int) IBlockContext

+ func (s *IfStatementContext) ConditionalExpression() IConditionalExpressionContext

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

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

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

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

+ func (s *IfStatementContext) IfStatement() IIfStatementContext

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

+ type ImplDeclarationBindingContext struct

+ func NewEmptyImplDeclarationBindingContext() *ImplDeclarationBindingContext

+ func NewImplDeclarationBindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImplDeclarationBindingContext

+ func (*ImplDeclarationBindingContext) IsImplDeclarationBindingContext()

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

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

+ func (s *ImplDeclarationBindingContext) AllMemberAccess() []IMemberAccessContext

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

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

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

+ func (s *ImplDeclarationBindingContext) MemberAccess(i int) IMemberAccessContext

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

+ type ImplDeclarationBodyContext struct

+ func NewEmptyImplDeclarationBodyContext() *ImplDeclarationBodyContext

+ func NewImplDeclarationBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImplDeclarationBodyContext

+ func (*ImplDeclarationBodyContext) IsImplDeclarationBodyContext()

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

+ func (s *ImplDeclarationBodyContext) ClassBody() IClassBodyContext

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

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

+ func (s *ImplDeclarationBodyContext) MemberAccess() IMemberAccessContext

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

+ type ImplDeclarationContext struct

+ func NewEmptyImplDeclarationContext() *ImplDeclarationContext

+ func NewImplDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImplDeclarationContext

+ func (*ImplDeclarationContext) IsImplDeclarationContext()

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

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

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

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

+ func (s *ImplDeclarationContext) IMPL() antlr.TerminalNode

+ func (s *ImplDeclarationContext) ImplDeclarationBinding() IImplDeclarationBindingContext

+ func (s *ImplDeclarationContext) ImplDeclarationBody() IImplDeclarationBodyContext

+ func (s *ImplDeclarationContext) MemberAccess() IMemberAccessContext

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

+ type ImportAllContext struct

+ func NewEmptyImportAllContext() *ImportAllContext

+ func NewImportAllContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportAllContext

+ func (*ImportAllContext) IsImportAllContext()

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

+ func (s *ImportAllContext) AsIdentifier() IAsIdentifierContext

+ func (s *ImportAllContext) FROM() antlr.TerminalNode

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

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

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

+ func (s *ImportAllContext) StringLiteral() antlr.TerminalNode

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

+ type ImportDeclarationContext struct

+ func NewEmptyImportDeclarationContext() *ImportDeclarationContext

+ func NewImportDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportDeclarationContext

+ func (*ImportDeclarationContext) IsImportDeclarationContext()

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

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

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

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

+ func (s *ImportDeclarationContext) ImportAll() IImportAllContext

+ func (s *ImportDeclarationContext) ImportMulti() IImportMultiContext

+ func (s *ImportDeclarationContext) ImportSingle() IImportSingleContext

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

+ type ImportMultiContext struct

+ func NewEmptyImportMultiContext() *ImportMultiContext

+ func NewImportMultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportMultiContext

+ func (*ImportMultiContext) IsImportMultiContext()

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

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

+ func (s *ImportMultiContext) AllIdentifierAsIdentifier() []IIdentifierAsIdentifierContext

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

+ func (s *ImportMultiContext) FROM() antlr.TerminalNode

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

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

+ func (s *ImportMultiContext) IdentifierAsIdentifier(i int) IIdentifierAsIdentifierContext

+ func (s *ImportMultiContext) LBRACE() antlr.TerminalNode

+ func (s *ImportMultiContext) RBRACE() antlr.TerminalNode

+ func (s *ImportMultiContext) StringLiteral() antlr.TerminalNode

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

+ type ImportSingleContext struct

+ func NewEmptyImportSingleContext() *ImportSingleContext

+ func NewImportSingleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportSingleContext

+ func (*ImportSingleContext) IsImportSingleContext()

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

+ func (s *ImportSingleContext) AsIdentifier() IAsIdentifierContext

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

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

+ func (s *ImportSingleContext) StringLiteral() antlr.TerminalNode

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

+ type IncDecExpressionContext struct

+ func NewEmptyIncDecExpressionContext() *IncDecExpressionContext

+ func NewIncDecExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IncDecExpressionContext

+ func (*IncDecExpressionContext) IsIncDecExpressionContext()

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

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

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

+ func (s *IncDecExpressionContext) PostIncDecExpression() IPostIncDecExpressionContext

+ func (s *IncDecExpressionContext) PreIncDecExpression() IPreIncDecExpressionContext

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

+ type IntersectionTypeContext struct

+ func NewEmptyIntersectionTypeContext() *IntersectionTypeContext

+ func NewIntersectionTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntersectionTypeContext

+ func (*IntersectionTypeContext) IsIntersectionTypeContext()

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

+ func (s *IntersectionTypeContext) AllBITAND() []antlr.TerminalNode

+ func (s *IntersectionTypeContext) AllType_() []ITypeContext

+ func (s *IntersectionTypeContext) BITAND(i int) antlr.TerminalNode

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

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

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

+ func (s *IntersectionTypeContext) Type_(i int) ITypeContext

+ type LambdaAssignStatementContext struct

+ func NewEmptyLambdaAssignStatementContext() *LambdaAssignStatementContext

+ func NewLambdaAssignStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaAssignStatementContext

+ func (*LambdaAssignStatementContext) IsLambdaAssignStatementContext()

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

+ func (s *LambdaAssignStatementContext) COLON_ASSIGN() antlr.TerminalNode

+ func (s *LambdaAssignStatementContext) Expression() IExpressionContext

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

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

+ func (s *LambdaAssignStatementContext) MatchStatement() IMatchStatementContext

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

+ func (s *LambdaAssignStatementContext) VariableExpression() IVariableExpressionContext

+ type LambdaBodyContext struct

+ func NewEmptyLambdaBodyContext() *LambdaBodyContext

+ func NewLambdaBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaBodyContext

+ func (*LambdaBodyContext) IsLambdaBodyContext()

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

+ func (s *LambdaBodyContext) Block() IBlockContext

+ func (s *LambdaBodyContext) Expression() IExpressionContext

+ func (s *LambdaBodyContext) ExpressionList() IExpressionListContext

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

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

+ func (s *LambdaBodyContext) LBRACE() antlr.TerminalNode

+ func (s *LambdaBodyContext) RBRACE() antlr.TerminalNode

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

+ type LambdaExpressionContext struct

+ func NewEmptyLambdaExpressionContext() *LambdaExpressionContext

+ func NewLambdaExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaExpressionContext

+ func (*LambdaExpressionContext) IsLambdaExpressionContext()

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

+ func (s *LambdaExpressionContext) DOUBLE_ARROW() antlr.TerminalNode

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

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

+ func (s *LambdaExpressionContext) LambdaBody() ILambdaBodyContext

+ func (s *LambdaExpressionContext) ReceiverParameters() IReceiverParametersContext

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

+ type LambdaFunctionDeclarationContext struct

+ func NewEmptyLambdaFunctionDeclarationContext() *LambdaFunctionDeclarationContext

+ func NewLambdaFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaFunctionDeclarationContext

+ func (*LambdaFunctionDeclarationContext) IsLambdaFunctionDeclarationContext()

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

+ func (s *LambdaFunctionDeclarationContext) AllFunctionModifier() []IFunctionModifierContext

+ func (s *LambdaFunctionDeclarationContext) FN() antlr.TerminalNode

+ func (s *LambdaFunctionDeclarationContext) FunctionModifier(i int) IFunctionModifierContext

+ func (s *LambdaFunctionDeclarationContext) GenericParameters() IGenericParametersContext

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

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

+ func (s *LambdaFunctionDeclarationContext) Identifier() antlr.TerminalNode

+ func (s *LambdaFunctionDeclarationContext) LambdaExpression() ILambdaExpressionContext

+ func (s *LambdaFunctionDeclarationContext) OperatorIdentifier() IOperatorIdentifierContext

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

+ type ListExpressionContext struct

+ func NewEmptyListExpressionContext() *ListExpressionContext

+ func NewListExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListExpressionContext

+ func (*ListExpressionContext) IsListExpressionContext()

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

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

+ func (s *ListExpressionContext) AllExpression() []IExpressionContext

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

+ func (s *ListExpressionContext) Expression(i int) IExpressionContext

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

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

+ func (s *ListExpressionContext) LBRACK() antlr.TerminalNode

+ func (s *ListExpressionContext) RBRACK() antlr.TerminalNode

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

+ type LiteralContext struct

+ func NewEmptyLiteralContext() *LiteralContext

+ func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext

+ func (*LiteralContext) IsLiteralContext()

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

+ func (s *LiteralContext) BoolLiteral() antlr.TerminalNode

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

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

+ func (s *LiteralContext) NULL() antlr.TerminalNode

+ func (s *LiteralContext) NumberLiteral() antlr.TerminalNode

+ func (s *LiteralContext) StringLiteral() antlr.TerminalNode

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

+ type LogicalExpressionContext struct

+ func NewEmptyLogicalExpressionContext() *LogicalExpressionContext

+ func NewLogicalExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalExpressionContext

+ func (*LogicalExpressionContext) IsLogicalExpressionContext()

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

+ func (s *LogicalExpressionContext) AllEQ() []antlr.TerminalNode

+ func (s *LogicalExpressionContext) AllGE() []antlr.TerminalNode

+ func (s *LogicalExpressionContext) AllGT() []antlr.TerminalNode

+ func (s *LogicalExpressionContext) AllLE() []antlr.TerminalNode

+ func (s *LogicalExpressionContext) AllLT() []antlr.TerminalNode

+ func (s *LogicalExpressionContext) AllMOD() []antlr.TerminalNode

+ func (s *LogicalExpressionContext) AllNEQ() []antlr.TerminalNode

+ func (s *LogicalExpressionContext) AllShiftExpression() []IShiftExpressionContext

+ func (s *LogicalExpressionContext) EQ(i int) antlr.TerminalNode

+ func (s *LogicalExpressionContext) GE(i int) antlr.TerminalNode

+ func (s *LogicalExpressionContext) GT(i int) antlr.TerminalNode

+ func (s *LogicalExpressionContext) GetLogicalOp() antlr.Token

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

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

+ func (s *LogicalExpressionContext) LE(i int) antlr.TerminalNode

+ func (s *LogicalExpressionContext) LT(i int) antlr.TerminalNode

+ func (s *LogicalExpressionContext) MOD(i int) antlr.TerminalNode

+ func (s *LogicalExpressionContext) NEQ(i int) antlr.TerminalNode

+ func (s *LogicalExpressionContext) SetLogicalOp(v antlr.Token)

+ func (s *LogicalExpressionContext) ShiftExpression(i int) IShiftExpressionContext

+ func (s *LogicalExpressionContext) StringLiteral() antlr.TerminalNode

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

+ func (s *LogicalExpressionContext) TypeofExpression() ITypeofExpressionContext

+ type LongOptionContext struct

+ func NewEmptyLongOptionContext() *LongOptionContext

+ func NewLongOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LongOptionContext

+ func (*LongOptionContext) IsLongOptionContext()

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

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

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

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

+ func (s *LongOptionContext) Identifier() antlr.TerminalNode

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

+ type LoopLabelContext struct

+ func NewEmptyLoopLabelContext() *LoopLabelContext

+ func NewLoopLabelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoopLabelContext

+ func (*LoopLabelContext) IsLoopLabelContext()

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

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

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

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

+ func (s *LoopLabelContext) Identifier() antlr.TerminalNode

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

+ type LoopStatementContext struct

+ func NewEmptyLoopStatementContext() *LoopStatementContext

+ func NewLoopStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoopStatementContext

+ func (*LoopStatementContext) IsLoopStatementContext()

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

+ func (s *LoopStatementContext) DoWhileStatement() IDoWhileStatementContext

+ func (s *LoopStatementContext) ForStatement() IForStatementContext

+ func (s *LoopStatementContext) ForeachStatement() IForeachStatementContext

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

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

+ func (s *LoopStatementContext) LoopLabel() ILoopLabelContext

+ func (s *LoopStatementContext) RangeStatement() IRangeStatementContext

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

+ func (s *LoopStatementContext) WhileStatement() IWhileStatementContext

+ type MacroStatementContext struct

+ func NewEmptyMacroStatementContext() *MacroStatementContext

+ func NewMacroStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MacroStatementContext

+ func (*MacroStatementContext) IsMacroStatementContext()

+ func (s *MacroStatementContext) AT() antlr.TerminalNode

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

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

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

+ func (s *MacroStatementContext) LPAREN() antlr.TerminalNode

+ func (s *MacroStatementContext) MemberAccess() IMemberAccessContext

+ func (s *MacroStatementContext) RPAREN() antlr.TerminalNode

+ func (s *MacroStatementContext) ReceiverArgumentList() IReceiverArgumentListContext

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

+ type MapExpressionContext struct

+ func NewEmptyMapExpressionContext() *MapExpressionContext

+ func NewMapExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapExpressionContext

+ func (*MapExpressionContext) IsMapExpressionContext()

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

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

+ func (s *MapExpressionContext) AllPair() []IPairContext

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

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

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

+ func (s *MapExpressionContext) LBRACE() antlr.TerminalNode

+ func (s *MapExpressionContext) Pair(i int) IPairContext

+ func (s *MapExpressionContext) RBRACE() antlr.TerminalNode

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

+ type MatchCaseBodyContext struct

+ func NewEmptyMatchCaseBodyContext() *MatchCaseBodyContext

+ func NewMatchCaseBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchCaseBodyContext

+ func (*MatchCaseBodyContext) IsMatchCaseBodyContext()

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

+ func (s *MatchCaseBodyContext) Block() IBlockContext

+ func (s *MatchCaseBodyContext) Expression() IExpressionContext

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

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

+ func (s *MatchCaseBodyContext) ReturnStatement() IReturnStatementContext

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

+ type MatchCaseClauseContext struct

+ func NewEmptyMatchCaseClauseContext() *MatchCaseClauseContext

+ func NewMatchCaseClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchCaseClauseContext

+ func (*MatchCaseClauseContext) IsMatchCaseClauseContext()

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

+ func (s *MatchCaseClauseContext) DOUBLE_ARROW() antlr.TerminalNode

+ func (s *MatchCaseClauseContext) Expression() IExpressionContext

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

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

+ func (s *MatchCaseClauseContext) MatchCaseBody() IMatchCaseBodyContext

+ func (s *MatchCaseClauseContext) MatchEnum() IMatchEnumContext

+ func (s *MatchCaseClauseContext) MatchTriple() IMatchTripleContext

+ func (s *MatchCaseClauseContext) MemberAccess() IMemberAccessContext

+ func (s *MatchCaseClauseContext) RangeExpression() IRangeExpressionContext

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

+ func (s *MatchCaseClauseContext) Type_() ITypeContext

+ type MatchDefaultClauseContext struct

+ func NewEmptyMatchDefaultClauseContext() *MatchDefaultClauseContext

+ func NewMatchDefaultClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchDefaultClauseContext

+ func (*MatchDefaultClauseContext) IsMatchDefaultClauseContext()

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

+ func (s *MatchDefaultClauseContext) DOUBLE_ARROW() antlr.TerminalNode

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

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

+ func (s *MatchDefaultClauseContext) MatchCaseBody() IMatchCaseBodyContext

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

+ func (s *MatchDefaultClauseContext) WILDCARD() antlr.TerminalNode

+ type MatchEnumContext struct

+ func NewEmptyMatchEnumContext() *MatchEnumContext

+ func NewMatchEnumContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchEnumContext

+ func (*MatchEnumContext) IsMatchEnumContext()

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

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

+ func (s *MatchEnumContext) AllMatchEnumMember() []IMatchEnumMemberContext

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

+ func (s *MatchEnumContext) Expression() IExpressionContext

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

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

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

+ func (s *MatchEnumContext) LPAREN() antlr.TerminalNode

+ func (s *MatchEnumContext) MatchEnumMember(i int) IMatchEnumMemberContext

+ func (s *MatchEnumContext) MemberAccess() IMemberAccessContext

+ func (s *MatchEnumContext) RPAREN() antlr.TerminalNode

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

+ type MatchEnumMemberContext struct

+ func NewEmptyMatchEnumMemberContext() *MatchEnumMemberContext

+ func NewMatchEnumMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchEnumMemberContext

+ func (*MatchEnumMemberContext) IsMatchEnumMemberContext()

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

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

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

+ func (s *MatchEnumMemberContext) Identifier() antlr.TerminalNode

+ func (s *MatchEnumMemberContext) Literal() ILiteralContext

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

+ func (s *MatchEnumMemberContext) WILDCARD() antlr.TerminalNode

+ type MatchStatementContext struct

+ func NewEmptyMatchStatementContext() *MatchStatementContext

+ func NewMatchStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchStatementContext

+ func (*MatchStatementContext) IsMatchStatementContext()

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

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

+ func (s *MatchStatementContext) AllComment() []ICommentContext

+ func (s *MatchStatementContext) AllMatchCaseClause() []IMatchCaseClauseContext

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

+ func (s *MatchStatementContext) Comment(i int) ICommentContext

+ func (s *MatchStatementContext) Expression() IExpressionContext

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

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

+ func (s *MatchStatementContext) LBRACE() antlr.TerminalNode

+ func (s *MatchStatementContext) MATCH() antlr.TerminalNode

+ func (s *MatchStatementContext) MatchCaseClause(i int) IMatchCaseClauseContext

+ func (s *MatchStatementContext) MatchDefaultClause() IMatchDefaultClauseContext

+ func (s *MatchStatementContext) RBRACE() antlr.TerminalNode

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

+ type MatchTripleContext struct

+ func NewEmptyMatchTripleContext() *MatchTripleContext

+ func NewMatchTripleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchTripleContext

+ func (*MatchTripleContext) IsMatchTripleContext()

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

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

+ func (s *MatchTripleContext) AllMatchTripleValue() []IMatchTripleValueContext

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

+ func (s *MatchTripleContext) Expression() IExpressionContext

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

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

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

+ func (s *MatchTripleContext) LPAREN() antlr.TerminalNode

+ func (s *MatchTripleContext) MatchTripleValue(i int) IMatchTripleValueContext

+ func (s *MatchTripleContext) RPAREN() antlr.TerminalNode

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

+ type MatchTripleValueContext struct

+ func NewEmptyMatchTripleValueContext() *MatchTripleValueContext

+ func NewMatchTripleValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchTripleValueContext

+ func (*MatchTripleValueContext) IsMatchTripleValueContext()

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

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

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

+ func (s *MatchTripleValueContext) Identifier() antlr.TerminalNode

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

+ func (s *MatchTripleValueContext) WILDCARD() antlr.TerminalNode

+ type MemberAccessContext struct

+ func NewEmptyMemberAccessContext() *MemberAccessContext

+ func NewMemberAccessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberAccessContext

+ func (*MemberAccessContext) IsMemberAccessContext()

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

+ func (s *MemberAccessContext) BOOL() antlr.TerminalNode

+ func (s *MemberAccessContext) GenericArguments() IGenericArgumentsContext

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

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

+ func (s *MemberAccessContext) Identifier() antlr.TerminalNode

+ func (s *MemberAccessContext) Literal() ILiteralContext

+ func (s *MemberAccessContext) MemberAccessPoint() IMemberAccessPointContext

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

+ func (s *MemberAccessContext) NUM() antlr.TerminalNode

+ func (s *MemberAccessContext) STR() antlr.TerminalNode

+ func (s *MemberAccessContext) SUPER() antlr.TerminalNode

+ func (s *MemberAccessContext) THIS() antlr.TerminalNode

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

+ type MemberAccessPointContext struct

+ func NewEmptyMemberAccessPointContext() *MemberAccessPointContext

+ func NewMemberAccessPointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberAccessPointContext

+ func (*MemberAccessPointContext) IsMemberAccessPointContext()

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

+ func (s *MemberAccessPointContext) DOT() antlr.TerminalNode

+ func (s *MemberAccessPointContext) DOUBLE_COLON() antlr.TerminalNode

+ func (s *MemberAccessPointContext) Expression() IExpressionContext

+ func (s *MemberAccessPointContext) GenericArguments() IGenericArgumentsContext

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

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

+ func (s *MemberAccessPointContext) Identifier() antlr.TerminalNode

+ func (s *MemberAccessPointContext) LBRACK() antlr.TerminalNode

+ func (s *MemberAccessPointContext) MemberAccessPoint() IMemberAccessPointContext

+ func (s *MemberAccessPointContext) RBRACK() antlr.TerminalNode

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

+ func (s *MemberAccessPointContext) VariableExpression() IVariableExpressionContext

+ type MethodExpressionContext struct

+ func NewEmptyMethodExpressionContext() *MethodExpressionContext

+ func NewMethodExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodExpressionContext

+ func (*MethodExpressionContext) IsMethodExpressionContext()

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

+ func (s *MethodExpressionContext) DOLLAR() antlr.TerminalNode

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

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

+ func (s *MethodExpressionContext) LPAREN() antlr.TerminalNode

+ func (s *MethodExpressionContext) MemberAccess() IMemberAccessContext

+ func (s *MethodExpressionContext) RPAREN() antlr.TerminalNode

+ func (s *MethodExpressionContext) ReceiverArgumentList() IReceiverArgumentListContext

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

+ type ModuleDeclarationContext struct

+ func NewEmptyModuleDeclarationContext() *ModuleDeclarationContext

+ func NewModuleDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleDeclarationContext

+ func (*ModuleDeclarationContext) IsModuleDeclarationContext()

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

+ func (s *ModuleDeclarationContext) AllModuleStatement() []IModuleStatementContext

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

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

+ func (s *ModuleDeclarationContext) Identifier() antlr.TerminalNode

+ func (s *ModuleDeclarationContext) LBRACE() antlr.TerminalNode

+ func (s *ModuleDeclarationContext) MOD_LIT() antlr.TerminalNode

+ func (s *ModuleDeclarationContext) ModuleStatement(i int) IModuleStatementContext

+ func (s *ModuleDeclarationContext) PUB() antlr.TerminalNode

+ func (s *ModuleDeclarationContext) RBRACE() antlr.TerminalNode

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

+ type ModuleStatementContext struct

+ func NewEmptyModuleStatementContext() *ModuleStatementContext

+ func NewModuleStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleStatementContext

+ func (*ModuleStatementContext) IsModuleStatementContext()

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

+ func (s *ModuleStatementContext) AssignStatement() IAssignStatementContext

+ func (s *ModuleStatementContext) ClassDeclaration() IClassDeclarationContext

+ func (s *ModuleStatementContext) EnumDeclaration() IEnumDeclarationContext

+ func (s *ModuleStatementContext) ExtendDeclaration() IExtendDeclarationContext

+ func (s *ModuleStatementContext) FunctionDeclaration() IFunctionDeclarationContext

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

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

+ func (s *ModuleStatementContext) ModuleDeclaration() IModuleDeclarationContext

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

+ func (s *ModuleStatementContext) TraitDeclaration() ITraitDeclarationContext

+ func (s *ModuleStatementContext) UseDeclaration() IUseDeclarationContext

+ type MulDivExpressionContext struct

+ func NewEmptyMulDivExpressionContext() *MulDivExpressionContext

+ func NewMulDivExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MulDivExpressionContext

+ func (*MulDivExpressionContext) IsMulDivExpressionContext()

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

+ func (s *MulDivExpressionContext) AllDIV() []antlr.TerminalNode

+ func (s *MulDivExpressionContext) AllIncDecExpression() []IIncDecExpressionContext

+ func (s *MulDivExpressionContext) AllMUL() []antlr.TerminalNode

+ func (s *MulDivExpressionContext) DIV(i int) antlr.TerminalNode

+ func (s *MulDivExpressionContext) GetMulDivOp() antlr.Token

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

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

+ func (s *MulDivExpressionContext) IncDecExpression(i int) IIncDecExpressionContext

+ func (s *MulDivExpressionContext) MUL(i int) antlr.TerminalNode

+ func (s *MulDivExpressionContext) SetMulDivOp(v antlr.Token)

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

+ type NamedArgumentContext struct

+ func NewEmptyNamedArgumentContext() *NamedArgumentContext

+ func NewNamedArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedArgumentContext

+ func (*NamedArgumentContext) IsNamedArgumentContext()

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

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

+ func (s *NamedArgumentContext) Expression() IExpressionContext

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

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

+ func (s *NamedArgumentContext) Identifier() antlr.TerminalNode

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

+ type NamedArgumentListContext struct

+ func NewEmptyNamedArgumentListContext() *NamedArgumentListContext

+ func NewNamedArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedArgumentListContext

+ func (*NamedArgumentListContext) IsNamedArgumentListContext()

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

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

+ func (s *NamedArgumentListContext) AllNamedArgument() []INamedArgumentContext

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

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

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

+ func (s *NamedArgumentListContext) NamedArgument(i int) INamedArgumentContext

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

+ type NamedParameterContext struct

+ func NewEmptyNamedParameterContext() *NamedParameterContext

+ func NewNamedParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedParameterContext

+ func (*NamedParameterContext) IsNamedParameterContext()

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

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

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

+ func (s *NamedParameterContext) REQUIRED() antlr.TerminalNode

+ func (s *NamedParameterContext) ReceiverParameter() IReceiverParameterContext

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

+ type NamedParameterListContext struct

+ func NewEmptyNamedParameterListContext() *NamedParameterListContext

+ func NewNamedParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedParameterListContext

+ func (*NamedParameterListContext) IsNamedParameterListContext()

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

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

+ func (s *NamedParameterListContext) AllNamedParameter() []INamedParameterContext

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

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

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

+ func (s *NamedParameterListContext) NamedParameter(i int) INamedParameterContext

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

+ type NamedParametersContext struct

+ func NewEmptyNamedParametersContext() *NamedParametersContext

+ func NewNamedParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedParametersContext

+ func (*NamedParametersContext) IsNamedParametersContext()

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

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

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

+ func (s *NamedParametersContext) LBRACE() antlr.TerminalNode

+ func (s *NamedParametersContext) NamedParameterList() INamedParameterListContext

+ func (s *NamedParametersContext) RBRACE() antlr.TerminalNode

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

+ type NewDelExpressionContext struct

+ func NewEmptyNewDelExpressionContext() *NewDelExpressionContext

+ func NewNewDelExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NewDelExpressionContext

+ func (*NewDelExpressionContext) IsNewDelExpressionContext()

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

+ func (s *NewDelExpressionContext) CallExpression() ICallExpressionContext

+ func (s *NewDelExpressionContext) DELETE() antlr.TerminalNode

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

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

+ func (s *NewDelExpressionContext) NEW() antlr.TerminalNode

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

+ type NullableTypeContext struct

+ func NewEmptyNullableTypeContext() *NullableTypeContext

+ func NewNullableTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullableTypeContext

+ func (*NullableTypeContext) IsNullableTypeContext()

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

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

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

+ func (s *NullableTypeContext) QUEST() antlr.TerminalNode

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

+ func (s *NullableTypeContext) Type_() ITypeContext

+ type ObjectTypeContext struct

+ func NewEmptyObjectTypeContext() *ObjectTypeContext

+ func NewObjectTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectTypeContext

+ func (*ObjectTypeContext) IsObjectTypeContext()

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

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

+ func (s *ObjectTypeContext) AllObjectTypeMember() []IObjectTypeMemberContext

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

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

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

+ func (s *ObjectTypeContext) LBRACE() antlr.TerminalNode

+ func (s *ObjectTypeContext) ObjectTypeMember(i int) IObjectTypeMemberContext

+ func (s *ObjectTypeContext) RBRACE() antlr.TerminalNode

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

+ type ObjectTypeMemberContext struct

+ func NewEmptyObjectTypeMemberContext() *ObjectTypeMemberContext

+ func NewObjectTypeMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectTypeMemberContext

+ func (*ObjectTypeMemberContext) IsObjectTypeMemberContext()

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

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

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

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

+ func (s *ObjectTypeMemberContext) Identifier() antlr.TerminalNode

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

+ func (s *ObjectTypeMemberContext) Type_() ITypeContext

+ type OperatorIdentifierContext struct

+ func NewEmptyOperatorIdentifierContext() *OperatorIdentifierContext

+ func NewOperatorIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OperatorIdentifierContext

+ func (*OperatorIdentifierContext) IsOperatorIdentifierContext()

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

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

+ func (s *OperatorIdentifierContext) DELETE() antlr.TerminalNode

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

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

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

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

+ func (s *OperatorIdentifierContext) HASH() antlr.TerminalNode

+ func (s *OperatorIdentifierContext) LBRACK() antlr.TerminalNode

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

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

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

+ func (s *OperatorIdentifierContext) NEW() antlr.TerminalNode

+ func (s *OperatorIdentifierContext) OPERATOR() antlr.TerminalNode

+ func (s *OperatorIdentifierContext) RBRACK() antlr.TerminalNode

+ func (s *OperatorIdentifierContext) SHL() antlr.TerminalNode

+ func (s *OperatorIdentifierContext) SHR() antlr.TerminalNode

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

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

+ type OptionContext struct

+ func NewEmptyOptionContext() *OptionContext

+ func NewOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionContext

+ func (*OptionContext) IsOptionContext()

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

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

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

+ func (s *OptionContext) LongOption() ILongOptionContext

+ func (s *OptionContext) ShortOption() IShortOptionContext

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

+ type PairContext struct

+ func NewEmptyPairContext() *PairContext

+ func NewPairContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PairContext

+ func (*PairContext) IsPairContext()

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

+ func (s *PairContext) BoolLiteral() antlr.TerminalNode

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

+ func (s *PairContext) Expression() IExpressionContext

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

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

+ func (s *PairContext) Identifier() antlr.TerminalNode

+ func (s *PairContext) NumberLiteral() antlr.TerminalNode

+ func (s *PairContext) StringLiteral() antlr.TerminalNode

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

+ type PostIncDecExpressionContext struct

+ func NewEmptyPostIncDecExpressionContext() *PostIncDecExpressionContext

+ func NewPostIncDecExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostIncDecExpressionContext

+ func (*PostIncDecExpressionContext) IsPostIncDecExpressionContext()

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

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

+ func (s *PostIncDecExpressionContext) Factor() IFactorContext

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

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

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

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

+ type PreIncDecExpressionContext struct

+ func NewEmptyPreIncDecExpressionContext() *PreIncDecExpressionContext

+ func NewPreIncDecExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreIncDecExpressionContext

+ func (*PreIncDecExpressionContext) IsPreIncDecExpressionContext()

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

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

+ func (s *PreIncDecExpressionContext) Factor() IFactorContext

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

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

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

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

+ type RangeClauseContext struct

+ func NewEmptyRangeClauseContext() *RangeClauseContext

+ func NewRangeClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeClauseContext

+ func (*RangeClauseContext) IsRangeClauseContext()

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

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

+ func (s *RangeClauseContext) AllExpression() []IExpressionContext

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

+ func (s *RangeClauseContext) Expression(i int) IExpressionContext

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

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

+ func (s *RangeClauseContext) LPAREN() antlr.TerminalNode

+ func (s *RangeClauseContext) RANGE() antlr.TerminalNode

+ func (s *RangeClauseContext) RPAREN() antlr.TerminalNode

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

+ type RangeExpressionContext struct

+ func NewEmptyRangeExpressionContext() *RangeExpressionContext

+ func NewRangeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeExpressionContext

+ func (*RangeExpressionContext) IsRangeExpressionContext()

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

+ func (s *RangeExpressionContext) AllNumberLiteral() []antlr.TerminalNode

+ func (s *RangeExpressionContext) DOUBLE_DOT() antlr.TerminalNode

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

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

+ func (s *RangeExpressionContext) NumberLiteral(i int) antlr.TerminalNode

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

+ type RangeStatementContext struct

+ func NewEmptyRangeStatementContext() *RangeStatementContext

+ func NewRangeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeStatementContext

+ func (*RangeStatementContext) IsRangeStatementContext()

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

+ func (s *RangeStatementContext) Block() IBlockContext

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

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

+ func (s *RangeStatementContext) IN() antlr.TerminalNode

+ func (s *RangeStatementContext) Identifier() antlr.TerminalNode

+ func (s *RangeStatementContext) LOOP() antlr.TerminalNode

+ func (s *RangeStatementContext) RangeClause() IRangeClauseContext

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

+ type ReceiverArgumentListContext struct

+ func NewEmptyReceiverArgumentListContext() *ReceiverArgumentListContext

+ func NewReceiverArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReceiverArgumentListContext

+ func (*ReceiverArgumentListContext) IsReceiverArgumentListContext()

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

+ func (s *ReceiverArgumentListContext) COMMA() antlr.TerminalNode

+ func (s *ReceiverArgumentListContext) ExpressionList() IExpressionListContext

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

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

+ func (s *ReceiverArgumentListContext) NamedArgumentList() INamedArgumentListContext

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

+ type ReceiverParameterContext struct

+ func NewEmptyReceiverParameterContext() *ReceiverParameterContext

+ func NewReceiverParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReceiverParameterContext

+ func (*ReceiverParameterContext) IsReceiverParameterContext()

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

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

+ func (s *ReceiverParameterContext) AllComment() []ICommentContext

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

+ func (s *ReceiverParameterContext) Comment(i int) ICommentContext

+ func (s *ReceiverParameterContext) ELLIPSIS() antlr.TerminalNode

+ func (s *ReceiverParameterContext) Expression() IExpressionContext

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

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

+ func (s *ReceiverParameterContext) Identifier() antlr.TerminalNode

+ func (s *ReceiverParameterContext) QUEST() antlr.TerminalNode

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

+ func (s *ReceiverParameterContext) Type_() ITypeContext

+ type ReceiverParameterListContext struct

+ func NewEmptyReceiverParameterListContext() *ReceiverParameterListContext

+ func NewReceiverParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReceiverParameterListContext

+ func (*ReceiverParameterListContext) IsReceiverParameterListContext()

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

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

+ func (s *ReceiverParameterListContext) AllReceiverParameter() []IReceiverParameterContext

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

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

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

+ func (s *ReceiverParameterListContext) ReceiverParameter(i int) IReceiverParameterContext

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

+ type ReceiverParametersContext struct

+ func NewEmptyReceiverParametersContext() *ReceiverParametersContext

+ func NewReceiverParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReceiverParametersContext

+ func (*ReceiverParametersContext) IsReceiverParametersContext()

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

+ func (s *ReceiverParametersContext) COMMA() antlr.TerminalNode

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

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

+ func (s *ReceiverParametersContext) LPAREN() antlr.TerminalNode

+ func (s *ReceiverParametersContext) NamedParameters() INamedParametersContext

+ func (s *ReceiverParametersContext) RPAREN() antlr.TerminalNode

+ func (s *ReceiverParametersContext) ReceiverParameterList() IReceiverParameterListContext

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

+ type ReturnStatementContext struct

+ func NewEmptyReturnStatementContext() *ReturnStatementContext

+ func NewReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStatementContext

+ func (*ReturnStatementContext) IsReturnStatementContext()

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

+ func (s *ReturnStatementContext) ExpressionList() IExpressionListContext

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

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

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

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

+ type ShiftExpressionContext struct

+ func NewEmptyShiftExpressionContext() *ShiftExpressionContext

+ func NewShiftExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShiftExpressionContext

+ func (*ShiftExpressionContext) IsShiftExpressionContext()

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

+ func (s *ShiftExpressionContext) AddSubExpression(i int) IAddSubExpressionContext

+ func (s *ShiftExpressionContext) AllAddSubExpression() []IAddSubExpressionContext

+ func (s *ShiftExpressionContext) AllSHL() []antlr.TerminalNode

+ func (s *ShiftExpressionContext) AllSHR() []antlr.TerminalNode

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

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

+ func (s *ShiftExpressionContext) GetShiftOp() antlr.Token

+ func (s *ShiftExpressionContext) SHL(i int) antlr.TerminalNode

+ func (s *ShiftExpressionContext) SHR(i int) antlr.TerminalNode

+ func (s *ShiftExpressionContext) SetShiftOp(v antlr.Token)

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

+ type ShortOptionContext struct

+ func NewEmptyShortOptionContext() *ShortOptionContext

+ func NewShortOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShortOptionContext

+ func (*ShortOptionContext) IsShortOptionContext()

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

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

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

+ func (s *ShortOptionContext) Identifier() antlr.TerminalNode

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

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

+ type StandardFunctionDeclarationContext struct

+ func NewEmptyStandardFunctionDeclarationContext() *StandardFunctionDeclarationContext

+ func NewStandardFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StandardFunctionDeclarationContext

+ func (*StandardFunctionDeclarationContext) IsStandardFunctionDeclarationContext()

+ func (s *StandardFunctionDeclarationContext) ARROW() antlr.TerminalNode

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

+ func (s *StandardFunctionDeclarationContext) AllFunctionModifier() []IFunctionModifierContext

+ func (s *StandardFunctionDeclarationContext) Block() IBlockContext

+ func (s *StandardFunctionDeclarationContext) FN() antlr.TerminalNode

+ func (s *StandardFunctionDeclarationContext) FunctionModifier(i int) IFunctionModifierContext

+ func (s *StandardFunctionDeclarationContext) FunctionReturnValue() IFunctionReturnValueContext

+ func (s *StandardFunctionDeclarationContext) GenericParameters() IGenericParametersContext

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

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

+ func (s *StandardFunctionDeclarationContext) Identifier() antlr.TerminalNode

+ func (s *StandardFunctionDeclarationContext) OperatorIdentifier() IOperatorIdentifierContext

+ func (s *StandardFunctionDeclarationContext) ReceiverParameters() IReceiverParametersContext

+ func (s *StandardFunctionDeclarationContext) THROWS() antlr.TerminalNode

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

+ type StatementContext struct

+ func NewEmptyStatementContext() *StatementContext

+ func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext

+ func (*StatementContext) IsStatementContext()

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

+ func (s *StatementContext) AssignStatement() IAssignStatementContext

+ func (s *StatementContext) BreakStatement() IBreakStatementContext

+ func (s *StatementContext) ChannelInputStatement() IChannelInputStatementContext

+ func (s *StatementContext) ClassDeclaration() IClassDeclarationContext

+ func (s *StatementContext) Comment() ICommentContext

+ func (s *StatementContext) ContinueStatement() IContinueStatementContext

+ func (s *StatementContext) DeclareStatement() IDeclareStatementContext

+ func (s *StatementContext) DeferStatement() IDeferStatementContext

+ func (s *StatementContext) EnumDeclaration() IEnumDeclarationContext

+ func (s *StatementContext) ExpressionStatement() IExpressionStatementContext

+ func (s *StatementContext) ExtendDeclaration() IExtendDeclarationContext

+ func (s *StatementContext) ExternDeclaration() IExternDeclarationContext

+ 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) ImplDeclaration() IImplDeclarationContext

+ func (s *StatementContext) ImportDeclaration() IImportDeclarationContext

+ func (s *StatementContext) LambdaAssignStatement() ILambdaAssignStatementContext

+ func (s *StatementContext) LoopStatement() ILoopStatementContext

+ func (s *StatementContext) MacroStatement() IMacroStatementContext

+ func (s *StatementContext) MatchStatement() IMatchStatementContext

+ func (s *StatementContext) ModuleDeclaration() IModuleDeclarationContext

+ func (s *StatementContext) ReturnStatement() IReturnStatementContext

+ func (s *StatementContext) ThrowStatement() IThrowStatementContext

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

+ func (s *StatementContext) TraitDeclaration() ITraitDeclarationContext

+ func (s *StatementContext) TryStatement() ITryStatementContext

+ func (s *StatementContext) TypeDeclaration() ITypeDeclarationContext

+ type ThrowStatementContext struct

+ func NewEmptyThrowStatementContext() *ThrowStatementContext

+ func NewThrowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThrowStatementContext

+ func (*ThrowStatementContext) IsThrowStatementContext()

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

+ func (s *ThrowStatementContext) CallExpression() ICallExpressionContext

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

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

+ func (s *ThrowStatementContext) NewDelExpression() INewDelExpressionContext

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

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

+ type TraitBodyContext struct

+ func NewEmptyTraitBodyContext() *TraitBodyContext

+ func NewTraitBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TraitBodyContext

+ func (*TraitBodyContext) IsTraitBodyContext()

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

+ func (s *TraitBodyContext) AllComment() []ICommentContext

+ func (s *TraitBodyContext) AllSEMI() []antlr.TerminalNode

+ func (s *TraitBodyContext) AllTraitMember() []ITraitMemberContext

+ func (s *TraitBodyContext) Comment(i int) ICommentContext

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

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

+ func (s *TraitBodyContext) LBRACE() antlr.TerminalNode

+ func (s *TraitBodyContext) RBRACE() antlr.TerminalNode

+ func (s *TraitBodyContext) SEMI(i int) antlr.TerminalNode

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

+ func (s *TraitBodyContext) TraitMember(i int) ITraitMemberContext

+ type TraitDeclarationContext struct

+ func NewEmptyTraitDeclarationContext() *TraitDeclarationContext

+ func NewTraitDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TraitDeclarationContext

+ func (*TraitDeclarationContext) IsTraitDeclarationContext()

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

+ func (s *TraitDeclarationContext) AllMacroStatement() []IMacroStatementContext

+ func (s *TraitDeclarationContext) GenericParameters() IGenericParametersContext

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

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

+ func (s *TraitDeclarationContext) Identifier() antlr.TerminalNode

+ func (s *TraitDeclarationContext) MacroStatement(i int) IMacroStatementContext

+ func (s *TraitDeclarationContext) TRAIT() antlr.TerminalNode

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

+ func (s *TraitDeclarationContext) TraitBody() ITraitBodyContext

+ func (s *TraitDeclarationContext) TraitModifier() ITraitModifierContext

+ type TraitMemberContext struct

+ func NewEmptyTraitMemberContext() *TraitMemberContext

+ func NewTraitMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TraitMemberContext

+ func (*TraitMemberContext) IsTraitMemberContext()

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

+ func (s *TraitMemberContext) AllTraitMemberModifier() []ITraitMemberModifierContext

+ func (s *TraitMemberContext) COLON() antlr.TerminalNode

+ func (s *TraitMemberContext) GetParser() antlr.Parser

+ func (s *TraitMemberContext) GetRuleContext() antlr.RuleContext

+ func (s *TraitMemberContext) Identifier() antlr.TerminalNode

+ func (s *TraitMemberContext) OperatorIdentifier() IOperatorIdentifierContext

+ func (s *TraitMemberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *TraitMemberContext) TraitMemberModifier(i int) ITraitMemberModifierContext

+ func (s *TraitMemberContext) Type_() ITypeContext

+ type TraitMemberModifierContext struct

+ func NewEmptyTraitMemberModifierContext() *TraitMemberModifierContext

+ func NewTraitMemberModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TraitMemberModifierContext

+ func (*TraitMemberModifierContext) IsTraitMemberModifierContext()

+ func (s *TraitMemberModifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TraitMemberModifierContext) CONST() antlr.TerminalNode

+ func (s *TraitMemberModifierContext) FINAL() antlr.TerminalNode

+ func (s *TraitMemberModifierContext) GetParser() antlr.Parser

+ func (s *TraitMemberModifierContext) GetRuleContext() antlr.RuleContext

+ func (s *TraitMemberModifierContext) PUB() antlr.TerminalNode

+ func (s *TraitMemberModifierContext) STATIC() antlr.TerminalNode

+ func (s *TraitMemberModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TraitModifierContext struct

+ func NewEmptyTraitModifierContext() *TraitModifierContext

+ func NewTraitModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TraitModifierContext

+ func (*TraitModifierContext) IsTraitModifierContext()

+ func (s *TraitModifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TraitModifierContext) GetParser() antlr.Parser

+ func (s *TraitModifierContext) GetRuleContext() antlr.RuleContext

+ func (s *TraitModifierContext) PUB() antlr.TerminalNode

+ func (s *TraitModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TripleExpressionContext struct

+ func NewEmptyTripleExpressionContext() *TripleExpressionContext

+ func NewTripleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TripleExpressionContext

+ func (*TripleExpressionContext) IsTripleExpressionContext()

+ func (s *TripleExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TripleExpressionContext) AllCOMMA() []antlr.TerminalNode

+ func (s *TripleExpressionContext) AllExpression() []IExpressionContext

+ func (s *TripleExpressionContext) COMMA(i int) antlr.TerminalNode

+ func (s *TripleExpressionContext) Expression(i int) IExpressionContext

+ func (s *TripleExpressionContext) GetParser() antlr.Parser

+ func (s *TripleExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *TripleExpressionContext) LPAREN() antlr.TerminalNode

+ func (s *TripleExpressionContext) RPAREN() antlr.TerminalNode

+ func (s *TripleExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TryStatementContext struct

+ func NewEmptyTryStatementContext() *TryStatementContext

+ func NewTryStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TryStatementContext

+ func (*TryStatementContext) IsTryStatementContext()

+ func (s *TryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TryStatementContext) AllCatchClause() []ICatchClauseContext

+ func (s *TryStatementContext) Block() IBlockContext

+ func (s *TryStatementContext) CatchClause(i int) ICatchClauseContext

+ func (s *TryStatementContext) FinallyClause() IFinallyClauseContext

+ func (s *TryStatementContext) GetParser() antlr.Parser

+ func (s *TryStatementContext) GetRuleContext() antlr.RuleContext

+ func (s *TryStatementContext) TRY() antlr.TerminalNode

+ func (s *TryStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TupleTypeContext struct

+ func NewEmptyTupleTypeContext() *TupleTypeContext

+ func NewTupleTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TupleTypeContext

+ func (*TupleTypeContext) IsTupleTypeContext()

+ func (s *TupleTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TupleTypeContext) GetParser() antlr.Parser

+ func (s *TupleTypeContext) GetRuleContext() antlr.RuleContext

+ func (s *TupleTypeContext) LBRACK() antlr.TerminalNode

+ func (s *TupleTypeContext) RBRACK() antlr.TerminalNode

+ func (s *TupleTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *TupleTypeContext) TypeList() ITypeListContext

+ type TypeAccessPointContext struct

+ func NewEmptyTypeAccessPointContext() *TypeAccessPointContext

+ func NewTypeAccessPointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeAccessPointContext

+ func (*TypeAccessPointContext) IsTypeAccessPointContext()

+ func (s *TypeAccessPointContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TypeAccessPointContext) GetParser() antlr.Parser

+ func (s *TypeAccessPointContext) GetRuleContext() antlr.RuleContext

+ func (s *TypeAccessPointContext) LBRACK() antlr.TerminalNode

+ func (s *TypeAccessPointContext) NumberLiteral() antlr.TerminalNode

+ func (s *TypeAccessPointContext) RBRACK() antlr.TerminalNode

+ func (s *TypeAccessPointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *TypeAccessPointContext) TypeAccessPoint() ITypeAccessPointContext

+ type TypeContext struct

+ func NewEmptyTypeContext() *TypeContext

+ func NewTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeContext

+ func (*TypeContext) IsTypeContext()

+ func (s *TypeContext) ANY() antlr.TerminalNode

+ func (s *TypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TypeContext) BOOL() antlr.TerminalNode

+ func (s *TypeContext) Comment() ICommentContext

+ func (s *TypeContext) CompositeType() ICompositeTypeContext

+ func (s *TypeContext) FunctionType() IFunctionTypeContext

+ func (s *TypeContext) GetParser() antlr.Parser

+ func (s *TypeContext) GetRuleContext() antlr.RuleContext

+ func (s *TypeContext) Identifier() antlr.TerminalNode

+ func (s *TypeContext) MemberAccess() IMemberAccessContext

+ func (s *TypeContext) NUM() antlr.TerminalNode

+ func (s *TypeContext) ObjectType() IObjectTypeContext

+ func (s *TypeContext) QUEST() antlr.TerminalNode

+ func (s *TypeContext) STR() antlr.TerminalNode

+ func (s *TypeContext) StringLiteral() antlr.TerminalNode

+ func (s *TypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *TypeContext) TupleType() ITupleTypeContext

+ func (s *TypeContext) TypeAccessPoint() ITypeAccessPointContext

+ func (s *TypeContext) VOID() antlr.TerminalNode

+ type TypeDeclarationContext struct

+ func NewEmptyTypeDeclarationContext() *TypeDeclarationContext

+ func NewTypeDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeDeclarationContext

+ func (*TypeDeclarationContext) IsTypeDeclarationContext()

+ func (s *TypeDeclarationContext) ASSIGN() antlr.TerminalNode

+ func (s *TypeDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TypeDeclarationContext) GenericParameters() IGenericParametersContext

+ func (s *TypeDeclarationContext) GetParser() antlr.Parser

+ func (s *TypeDeclarationContext) GetRuleContext() antlr.RuleContext

+ func (s *TypeDeclarationContext) Identifier() antlr.TerminalNode

+ func (s *TypeDeclarationContext) TYPE() antlr.TerminalNode

+ func (s *TypeDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *TypeDeclarationContext) Type_() ITypeContext

+ type TypeListContext struct

+ func NewEmptyTypeListContext() *TypeListContext

+ func NewTypeListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeListContext

+ func (*TypeListContext) IsTypeListContext()

+ func (s *TypeListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TypeListContext) AllCOMMA() []antlr.TerminalNode

+ func (s *TypeListContext) AllType_() []ITypeContext

+ func (s *TypeListContext) COMMA(i int) antlr.TerminalNode

+ func (s *TypeListContext) GetParser() antlr.Parser

+ func (s *TypeListContext) GetRuleContext() antlr.RuleContext

+ func (s *TypeListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *TypeListContext) Type_(i int) ITypeContext

+ type TypeLiteralContext struct

+ func NewEmptyTypeLiteralContext() *TypeLiteralContext

+ func NewTypeLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeLiteralContext

+ func (*TypeLiteralContext) IsTypeLiteralContext()

+ func (s *TypeLiteralContext) ANY() antlr.TerminalNode

+ func (s *TypeLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TypeLiteralContext) BOOL() antlr.TerminalNode

+ func (s *TypeLiteralContext) GetParser() antlr.Parser

+ func (s *TypeLiteralContext) GetRuleContext() antlr.RuleContext

+ func (s *TypeLiteralContext) Identifier() antlr.TerminalNode

+ func (s *TypeLiteralContext) NUM() antlr.TerminalNode

+ func (s *TypeLiteralContext) STR() antlr.TerminalNode

+ func (s *TypeLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type TypeofExpressionContext struct

+ func NewEmptyTypeofExpressionContext() *TypeofExpressionContext

+ func NewTypeofExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeofExpressionContext

+ func (*TypeofExpressionContext) IsTypeofExpressionContext()

+ func (s *TypeofExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *TypeofExpressionContext) Expression() IExpressionContext

+ func (s *TypeofExpressionContext) GetParser() antlr.Parser

+ func (s *TypeofExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *TypeofExpressionContext) TYPEOF() antlr.TerminalNode

+ func (s *TypeofExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type UnionTypeContext struct

+ func NewEmptyUnionTypeContext() *UnionTypeContext

+ func NewUnionTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnionTypeContext

+ func (*UnionTypeContext) IsUnionTypeContext()

+ func (s *UnionTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UnionTypeContext) AllBITOR() []antlr.TerminalNode

+ func (s *UnionTypeContext) AllType_() []ITypeContext

+ func (s *UnionTypeContext) BITOR(i int) antlr.TerminalNode

+ func (s *UnionTypeContext) GetParser() antlr.Parser

+ func (s *UnionTypeContext) GetRuleContext() antlr.RuleContext

+ func (s *UnionTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *UnionTypeContext) Type_(i int) ITypeContext

+ type UnsafeExpressionContext struct

+ func NewEmptyUnsafeExpressionContext() *UnsafeExpressionContext

+ func NewUnsafeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnsafeExpressionContext

+ func (*UnsafeExpressionContext) IsUnsafeExpressionContext()

+ func (s *UnsafeExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UnsafeExpressionContext) GetParser() antlr.Parser

+ func (s *UnsafeExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *UnsafeExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *UnsafeExpressionContext) UnsafeLiteral() antlr.TerminalNode

+ type UseAllContext struct

+ func NewEmptyUseAllContext() *UseAllContext

+ func NewUseAllContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseAllContext

+ func (*UseAllContext) IsUseAllContext()

+ func (s *UseAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UseAllContext) AsIdentifier() IAsIdentifierContext

+ func (s *UseAllContext) FROM() antlr.TerminalNode

+ func (s *UseAllContext) GetParser() antlr.Parser

+ func (s *UseAllContext) GetRuleContext() antlr.RuleContext

+ func (s *UseAllContext) MUL() antlr.TerminalNode

+ func (s *UseAllContext) StringLiteral() antlr.TerminalNode

+ func (s *UseAllContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type UseDeclarationContext struct

+ func NewEmptyUseDeclarationContext() *UseDeclarationContext

+ func NewUseDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseDeclarationContext

+ func (*UseDeclarationContext) IsUseDeclarationContext()

+ func (s *UseDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UseDeclarationContext) GetParser() antlr.Parser

+ func (s *UseDeclarationContext) GetRuleContext() antlr.RuleContext

+ func (s *UseDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *UseDeclarationContext) USE() antlr.TerminalNode

+ func (s *UseDeclarationContext) UseAll() IUseAllContext

+ func (s *UseDeclarationContext) UseMulti() IUseMultiContext

+ func (s *UseDeclarationContext) UseSingle() IUseSingleContext

+ type UseMultiContext struct

+ func NewEmptyUseMultiContext() *UseMultiContext

+ func NewUseMultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseMultiContext

+ func (*UseMultiContext) IsUseMultiContext()

+ func (s *UseMultiContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UseMultiContext) AllCOMMA() []antlr.TerminalNode

+ func (s *UseMultiContext) AllIdentifierAsIdentifier() []IIdentifierAsIdentifierContext

+ func (s *UseMultiContext) COMMA(i int) antlr.TerminalNode

+ func (s *UseMultiContext) FROM() antlr.TerminalNode

+ func (s *UseMultiContext) GetParser() antlr.Parser

+ func (s *UseMultiContext) GetRuleContext() antlr.RuleContext

+ func (s *UseMultiContext) IdentifierAsIdentifier(i int) IIdentifierAsIdentifierContext

+ func (s *UseMultiContext) LBRACE() antlr.TerminalNode

+ func (s *UseMultiContext) RBRACE() antlr.TerminalNode

+ func (s *UseMultiContext) StringLiteral() antlr.TerminalNode

+ func (s *UseMultiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type UseSingleContext struct

+ func NewEmptyUseSingleContext() *UseSingleContext

+ func NewUseSingleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseSingleContext

+ func (*UseSingleContext) IsUseSingleContext()

+ func (s *UseSingleContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *UseSingleContext) AsIdentifier() IAsIdentifierContext

+ func (s *UseSingleContext) GetParser() antlr.Parser

+ func (s *UseSingleContext) GetRuleContext() antlr.RuleContext

+ func (s *UseSingleContext) Identifier() antlr.TerminalNode

+ func (s *UseSingleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type VariableExpressionContext struct

+ func NewEmptyVariableExpressionContext() *VariableExpressionContext

+ func NewVariableExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableExpressionContext

+ func (*VariableExpressionContext) IsVariableExpressionContext()

+ func (s *VariableExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *VariableExpressionContext) DOLLAR() antlr.TerminalNode

+ func (s *VariableExpressionContext) GetParser() antlr.Parser

+ func (s *VariableExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *VariableExpressionContext) MemberAccess() IMemberAccessContext

+ func (s *VariableExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type VariableNameContext struct

+ func NewEmptyVariableNameContext() *VariableNameContext

+ func NewVariableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableNameContext

+ func (*VariableNameContext) IsVariableNameContext()

+ func (s *VariableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *VariableNameContext) COLON() antlr.TerminalNode

+ func (s *VariableNameContext) GetParser() antlr.Parser

+ func (s *VariableNameContext) GetRuleContext() antlr.RuleContext

+ func (s *VariableNameContext) Identifier() antlr.TerminalNode

+ func (s *VariableNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *VariableNameContext) Type_() ITypeContext

+ func (s *VariableNameContext) WILDCARD() antlr.TerminalNode

+ type VariableNameListContext struct

+ func NewEmptyVariableNameListContext() *VariableNameListContext

+ func NewVariableNameListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableNameListContext

+ func (*VariableNameListContext) IsVariableNameListContext()

+ func (s *VariableNameListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *VariableNameListContext) AllCOMMA() []antlr.TerminalNode

+ func (s *VariableNameListContext) AllVariableName() []IVariableNameContext

+ func (s *VariableNameListContext) COMMA(i int) antlr.TerminalNode

+ func (s *VariableNameListContext) GetParser() antlr.Parser

+ func (s *VariableNameListContext) GetRuleContext() antlr.RuleContext

+ func (s *VariableNameListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *VariableNameListContext) VariableName(i int) IVariableNameContext

+ type VariableNamesContext struct

+ func NewEmptyVariableNamesContext() *VariableNamesContext

+ func NewVariableNamesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableNamesContext

+ func (*VariableNamesContext) IsVariableNamesContext()

+ func (s *VariableNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *VariableNamesContext) GetParser() antlr.Parser

+ func (s *VariableNamesContext) GetRuleContext() antlr.RuleContext

+ func (s *VariableNamesContext) LBRACE() antlr.TerminalNode

+ func (s *VariableNamesContext) RBRACE() antlr.TerminalNode

+ func (s *VariableNamesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *VariableNamesContext) VariableNameList() IVariableNameListContext

+ type VariableNullableExpressionContext struct

+ func NewEmptyVariableNullableExpressionContext() *VariableNullableExpressionContext

+ func NewVariableNullableExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableNullableExpressionContext

+ func (*VariableNullableExpressionContext) IsVariableNullableExpressionContext()

+ func (s *VariableNullableExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *VariableNullableExpressionContext) GetParser() antlr.Parser

+ func (s *VariableNullableExpressionContext) GetRuleContext() antlr.RuleContext

+ func (s *VariableNullableExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *VariableNullableExpressionContext) VariableExpression() IVariableExpressionContext

+ func (s *VariableNullableExpressionContext) WILDCARD() antlr.TerminalNode

+ type VariableNullableExpressionsContext struct

+ func NewEmptyVariableNullableExpressionsContext() *VariableNullableExpressionsContext

+ func NewVariableNullableExpressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableNullableExpressionsContext

+ func (*VariableNullableExpressionsContext) IsVariableNullableExpressionsContext()

+ func (s *VariableNullableExpressionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *VariableNullableExpressionsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *VariableNullableExpressionsContext) AllVariableNullableExpression() []IVariableNullableExpressionContext

+ func (s *VariableNullableExpressionsContext) COMMA(i int) antlr.TerminalNode

+ func (s *VariableNullableExpressionsContext) GetParser() antlr.Parser

+ func (s *VariableNullableExpressionsContext) GetRuleContext() antlr.RuleContext

+ func (s *VariableNullableExpressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *VariableNullableExpressionsContext) VariableNullableExpression(i int) IVariableNullableExpressionContext

+ type WhileStatementContext struct

+ func NewEmptyWhileStatementContext() *WhileStatementContext

+ func NewWhileStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileStatementContext

+ func (*WhileStatementContext) IsWhileStatementContext()

+ func (s *WhileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *WhileStatementContext) Block() IBlockContext

+ func (s *WhileStatementContext) Expression() IExpressionContext

+ func (s *WhileStatementContext) GetParser() antlr.Parser

+ func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext

+ func (s *WhileStatementContext) LOOP() antlr.TerminalNode

+ func (s *WhileStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL