parser

package

Go to main page

Versions in this module

v1

v1.0.3

Nov 21, 2024

v1.0.2

Oct 30, 2024

v1.0.1

Oct 8, 2024

v1.0.0

Sep 26, 2024

Changes in this version

+ const KeywordAttach

+ const KeywordAttachment

+ const KeywordCatch

+ const KeywordConst

+ const KeywordEntitlement

+ const KeywordExport

+ const KeywordFinal

+ const KeywordFinally

+ const KeywordGoto

+ const KeywordGuard

+ const KeywordInclude

+ const KeywordInternal

+ const KeywordIs

+ const KeywordMapping

+ const KeywordRemove

+ const KeywordRepeat

+ const KeywordRequire

+ const KeywordRequires

+ const KeywordThrow

+ const KeywordThrows

+ const KeywordTo

+ const KeywordTry

+ const KeywordType

+ const KeywordTypealias

+ const KeywordWhere

+ var HardKeywords = filter(allKeywords, func(keyword string) bool { ... })

+ var SoftKeywords = []string

+ func IsHardKeyword(identifier string) bool

+ type CustomDestructorError struct

+ Pos ast.Position

+ func (*CustomDestructorError) IsUserError()

+ func (e *CustomDestructorError) EndPosition(_ common.MemoryGauge) ast.Position

+ func (e *CustomDestructorError) Error() string

+ func (e *CustomDestructorError) SecondaryError() string

+ func (e *CustomDestructorError) StartPosition() ast.Position

+ type RestrictedTypeError struct

+ func (*RestrictedTypeError) IsUserError()

+ func (e *RestrictedTypeError) Error() string

+ type SyntaxErrorWithSuggestedReplacement struct

+ Message string

+ SuggestedFix string

+ func NewSyntaxErrorWithSuggestedReplacement(r ast.Range, message string, suggestedFix string) *SyntaxErrorWithSuggestedReplacement

+ func (*SyntaxErrorWithSuggestedReplacement) IsUserError()

+ func (e *SyntaxErrorWithSuggestedReplacement) Error() string

+ func (e *SyntaxErrorWithSuggestedReplacement) SuggestFixes(_ string) []errors.SuggestedFix[ast.TextEdit]

v1.0.0-preview-atree-register-inlining.39

Jul 24, 2024

v1.0.0-preview-atree-register-inlining.38

Jul 16, 2024

v1.0.0-preview-atree-register-inlining.37

Jul 12, 2024

v1.0.0-preview-atree-register-inlining.36

Jul 8, 2024

v1.0.0-preview-atree-register-inlining.35

Jun 25, 2024

v1.0.0-preview-atree-register-inlining.34

Jun 12, 2024

v1.0.0-preview-atree-register-inlining.32

Jun 4, 2024

v1.0.0-preview-atree-register-inlining.30

May 28, 2024

v1.0.0-preview-atree-register-inlining.29

May 17, 2024

v1.0.0-preview-atree-register-inlining.28

May 15, 2024

v1.0.0-preview-atree-register-inlining.27

May 15, 2024

v1.0.0-preview-atree-register-inlining.26

May 7, 2024

v1.0.0-preview-atree-register-inlining.25

May 2, 2024

v1.0.0-preview-atree-register-inlining.24

May 1, 2024

v1.0.0-preview-atree-register-inlining.23

Apr 26, 2024

v1.0.0-preview-atree-register-inlining.22

Apr 24, 2024

v1.0.0-preview-atree-register-inlining.21

Apr 18, 2024

v1.0.0-preview.52

Aug 31, 2024

v1.0.0-preview.51

Aug 29, 2024

v1.0.0-preview.50

Aug 22, 2024

v1.0.0-preview.49

Aug 21, 2024

v1.0.0-preview.48

Aug 13, 2024

v1.0.0-preview.47

Aug 13, 2024

v1.0.0-preview.46

Aug 12, 2024

v1.0.0-preview.45

Aug 12, 2024

v1.0.0-preview.44

Aug 9, 2024

v1.0.0-preview.43

Aug 8, 2024

v1.0.0-preview.42

Jul 31, 2024

v1.0.0-preview.41

Jul 29, 2024

v1.0.0-preview.40

Jul 25, 2024

v1.0.0-preview.39

Jul 24, 2024

v1.0.0-preview.38

Jul 16, 2024

v1.0.0-preview.37

Jul 12, 2024

v1.0.0-preview.36

Jul 8, 2024

v1.0.0-preview.35

Jun 24, 2024

v1.0.0-preview.34

Jun 12, 2024

v1.0.0-preview.33

Jun 5, 2024

v1.0.0-preview.32

Jun 4, 2024

v1.0.0-preview.31

May 29, 2024

v1.0.0-preview.30

May 28, 2024

v1.0.0-preview.29

May 17, 2024

v1.0.0-preview.28

May 15, 2024

v1.0.0-preview.27

May 15, 2024

v1.0.0-preview.26

May 7, 2024

v1.0.0-preview.25

May 1, 2024

v1.0.0-preview.24

Apr 30, 2024

v1.0.0-preview.23

Apr 26, 2024

v1.0.0-preview.22

Apr 24, 2024

v1.0.0-preview.21

Apr 18, 2024

v1.0.0-preview.20

Apr 12, 2024

v1.0.0-preview.19

Apr 3, 2024

v1.0.0-preview.18

Mar 27, 2024

v1.0.0-preview.17

Mar 27, 2024

v1.0.0-preview.16

Mar 20, 2024

v1.0.0-preview.15

Mar 18, 2024

v1.0.0-preview.14

Mar 13, 2024

v1.0.0-preview.13

Mar 13, 2024

v1.0.0-preview.12

Mar 11, 2024

v1.0.0-preview.11

Mar 11, 2024

v1.0.0-preview.10

Mar 8, 2024

v1.0.0-preview.2

Jan 16, 2024

v1.0.0-preview.1

Sep 18, 2023

v1.0.0-M9

Mar 4, 2024

v1.0.0-M8

Feb 22, 2024

v1.0.0-M7

Feb 14, 2024

v1.0.0-M6

Feb 12, 2024

v1.0.0-M5

Feb 2, 2024

v1.0.0-M4

Jan 26, 2024

v1.0.0-M3

Jan 24, 2024

v1.0.0-M10

Mar 8, 2024

v0

v0.42.12

Jun 13, 2024

v0.42.11

May 9, 2024

v0.42.11-atree-register-inlining.2

Apr 29, 2024

v0.42.11-atree-register-inlining

Apr 17, 2024

v0.42.10

Apr 10, 2024

v0.42.9

Feb 7, 2024

v0.42.8

Jan 26, 2024

Changes in this version

type Error

+ func (e Error) Unwrap() []error

v0.42.7

Jan 5, 2024

v0.42.6

Nov 30, 2023

v0.42.5

Nov 9, 2023

v0.42.4

Nov 8, 2023

v0.42.3

Oct 30, 2023

v0.42.2

Oct 26, 2023

v0.42.1

Oct 23, 2023

v0.42.0

Oct 5, 2023

v0.41.1

Sep 19, 2023

v0.41.0

Sep 14, 2023

v0.41.0-stable-cadence.1

Aug 15, 2023

v0.40.0

Aug 3, 2023

v0.39.17

Oct 26, 2023

v0.39.16

Oct 5, 2023

v0.39.15

Sep 19, 2023

v0.39.14

Jul 11, 2023

v0.39.13-stable-cadence

Jun 26, 2023

v0.39.12

Jun 21, 2023

v0.39.11

Jun 20, 2023

v0.39.10

Jun 17, 2023

v0.39.9

Jun 13, 2023

v0.39.8

Jun 12, 2023

v0.39.8-patch.1

Jun 13, 2023

v0.39.7

Jun 12, 2023

v0.39.6

Jun 9, 2023

v0.39.5

Jun 8, 2023

v0.39.4

Jun 7, 2023

v0.39.3

Jun 7, 2023

v0.39.2

Jun 6, 2023

v0.39.1

May 31, 2023

v0.39.0

May 31, 2023

Changes in this version

+ func ParseStatementsFromTokenStream(memoryGauge common.MemoryGauge, tokens lexer.TokenStream, config Config) (statements []ast.Statement, errs []error)

v0.38.1

Apr 12, 2023

v0.38.0

Mar 30, 2023

v0.37.0

Mar 23, 2023

v0.36.0

Mar 8, 2023

v0.35.0

Feb 24, 2023

v0.34.0

Feb 16, 2023

v0.33.1

Feb 15, 2023

v0.33.0

Feb 8, 2023

v0.32.0

Feb 7, 2023

Changes in this version

+ const KeywordAccess

+ const KeywordAccount

+ const KeywordAll

+ const KeywordAs

+ const KeywordAuth

+ const KeywordBreak

+ const KeywordCase

+ const KeywordContinue

+ const KeywordContract

+ const KeywordCreate

+ const KeywordDefault

+ const KeywordDestroy

+ const KeywordElse

+ const KeywordEmit

+ const KeywordEnum

+ const KeywordEvent

+ const KeywordExecute

+ const KeywordFalse

+ const KeywordFor

+ const KeywordFrom

+ const KeywordFun

+ const KeywordIf

+ const KeywordImport

+ const KeywordIn

+ const KeywordInit

+ const KeywordInterface

+ const KeywordLet

+ const KeywordNative

+ const KeywordNil

+ const KeywordPost

+ const KeywordPre

+ const KeywordPrepare

+ const KeywordPriv

+ const KeywordPub

+ const KeywordResource

+ const KeywordReturn

+ const KeywordSelf

+ const KeywordSet

+ const KeywordStatic

+ const KeywordStruct

+ const KeywordSwitch

+ const KeywordTrue

+ const KeywordVar

+ const KeywordView

+ const KeywordWhile

type Config

+ IgnoreLeadingIdentifierEnabled bool

+ TypeParametersEnabled bool

v0.31.6

Jun 6, 2023

v0.31.5

Feb 23, 2023

v0.31.5-account-linking-improved-pragma-patch.2

Apr 12, 2023

v0.31.5-account-linking-improved-pragma-patch.1

Mar 30, 2023

v0.31.5-account-linking-improved-pragma

Mar 13, 2023

v0.31.5-account-link-pragma

Feb 28, 2023

v0.31.5-account-link-improvements

Mar 6, 2023

v0.31.3

Jan 13, 2023

v0.31.3-attachments-2

Jan 30, 2023

v0.31.2

Jan 5, 2023

v0.31.1

Jan 4, 2023

v0.31.0

Dec 22, 2022

v0.30.0

Dec 13, 2022

Changes in this version

+ type Config struct

+ NativeModifierEnabled bool

+ StaticModifierEnabled bool

v0.30.0-attachments-2

Jan 30, 2023

v0.30.0-attachments

Dec 13, 2022

v0.29.0

Oct 27, 2022

v0.29.0-stable-cadence-5

Nov 21, 2022

v0.29.0-stable-cadence-4

Nov 10, 2022

v0.29.0-stable-cadence-3

Nov 8, 2022

v0.29.0-stable-cadence-2

Nov 4, 2022

v0.29.0-stable-cadence

Oct 27, 2022

v0.29.0-attachments

Dec 12, 2022

v0.28.0

Oct 6, 2022

v0.27.1

Oct 3, 2022

v0.27.0

Sep 23, 2022

v0.26.2

Sep 23, 2022

v0.26.1

Sep 16, 2022

v0.26.0

Aug 23, 2022

v0.25.2

Sep 20, 2022

v0.25.1

Sep 20, 2022

v0.25.0

Aug 3, 2022

Changes in this version

+ const KeywordTransaction

+ func Parse(input string, parse func(*parser) (any, error), memoryGauge common.MemoryGauge) (result any, errors []error)

+ func ParseArgumentList(input string, memoryGauge common.MemoryGauge) (arguments ast.Arguments, errs []error)

+ func ParseDeclarations(input string, memoryGauge common.MemoryGauge) (declarations []ast.Declaration, errs []error)

+ func ParseDocstringPragmaArguments(docString string) []string

+ func ParseDocstringPragmaSigners(docString string) []string

+ func ParseProgramFromTokenStream(input lexer.TokenStream, memoryGauge common.MemoryGauge) (program *ast.Program, err error)

+ func ParseStatements(input string, memoryGauge common.MemoryGauge) (statements []ast.Statement, errs []error)

+ func ParseTokenStream(memoryGauge common.MemoryGauge, tokens lexer.TokenStream, ...) (result any, errs []error)

+ func ParseType(input string, memoryGauge common.MemoryGauge) (ty ast.Type, errs []error)

type Error

+ Code string

+ type ExpressionDepthLimitReachedError struct

+ Pos ast.Position

+ func (ExpressionDepthLimitReachedError) IsUserError()

+ func (e ExpressionDepthLimitReachedError) EndPosition(_ common.MemoryGauge) ast.Position

+ func (e ExpressionDepthLimitReachedError) Error() string

+ func (e ExpressionDepthLimitReachedError) StartPosition() ast.Position

type InvalidIntegerLiteralError

+ func (*InvalidIntegerLiteralError) IsUserError()

type InvalidNumberLiteralKind

+ const InvalidNumberLiteralKindMissingDigits

type JuxtaposedUnaryOperatorsError

+ func (*JuxtaposedUnaryOperatorsError) IsUserError()

+ type MissingCommaInParameterListError struct

+ Pos ast.Position

+ func (*MissingCommaInParameterListError) IsUserError()

+ func (e *MissingCommaInParameterListError) EndPosition(_ common.MemoryGauge) ast.Position

+ func (e *MissingCommaInParameterListError) Error() string

+ func (e *MissingCommaInParameterListError) StartPosition() ast.Position

type SyntaxError

+ func NewSyntaxError(pos ast.Position, message string, params ...any) *SyntaxError

+ func NewUnpositionedSyntaxError(message string, params ...any) *SyntaxError

+ func (*SyntaxError) IsUserError()

+ type TypeDepthLimitReachedError struct

+ Pos ast.Position

+ func (TypeDepthLimitReachedError) IsUserError()

+ func (e TypeDepthLimitReachedError) EndPosition(_ common.MemoryGauge) ast.Position

+ func (e TypeDepthLimitReachedError) Error() string

+ func (e TypeDepthLimitReachedError) StartPosition() ast.Position

v0.6.0

Jul 14, 2020

v0.5.1

Jul 10, 2020

v0.5.0

Jul 7, 2020

Changes in this version

type IImportDeclarationContext

+ GetIds func() []IIdentifierContext

+ GetLocation func() IIdentifierContext

+ Get_identifier func() IIdentifierContext

+ SetIds func([]IIdentifierContext)

+ SetLocation func(IIdentifierContext)

+ Set_identifier func(IIdentifierContext)

type ImportDeclarationContext

+ func (s *ImportDeclarationContext) GetIds() []IIdentifierContext

+ func (s *ImportDeclarationContext) GetLocation() IIdentifierContext

+ func (s *ImportDeclarationContext) Get_identifier() IIdentifierContext

+ func (s *ImportDeclarationContext) SetIds(v []IIdentifierContext)

+ func (s *ImportDeclarationContext) SetLocation(v IIdentifierContext)

+ func (s *ImportDeclarationContext) Set_identifier(v IIdentifierContext)

type NominalTypeContext

+ func (s *NominalTypeContext) AllTypeAnnotation() []ITypeAnnotationContext

+ func (s *NominalTypeContext) Greater() antlr.TerminalNode

+ func (s *NominalTypeContext) Less() antlr.TerminalNode

+ func (s *NominalTypeContext) TypeAnnotation(i int) ITypeAnnotationContext

v0.5.0-beta4

Jul 6, 2020

v0.5.0-beta3

Jul 4, 2020

v0.5.0-beta2

Jul 3, 2020

v0.5.0-beta1

Jun 30, 2020

v0.4.0

Jun 2, 2020

v0.4.0-beta2

Jun 2, 2020

v0.4.0-beta1

May 26, 2020

v0.3.0

May 26, 2020

Changes in this version

type AssignmentContext

+ func (s *AssignmentContext) AllExpression() []IExpressionContext

+ func (s *AssignmentContext) GetTarget() IExpressionContext

+ func (s *AssignmentContext) GetValue() IExpressionContext

+ func (s *AssignmentContext) SetTarget(v IExpressionContext)

+ func (s *AssignmentContext) SetValue(v IExpressionContext)

type IAssignmentContext

+ GetTarget func() IExpressionContext

+ GetValue func() IExpressionContext

+ SetTarget func(IExpressionContext)

+ SetValue func(IExpressionContext)

v0.3.0-beta4

May 24, 2020

v0.3.0-beta3

May 22, 2020

v0.3.0-beta2

May 21, 2020

v0.3.0-beta1

May 20, 2020

v0.2.1

May 12, 2020

v0.2.0

May 6, 2020

Changes in this version

+ const CadenceLexerShiftLeft

+ const CadenceLexerShiftRight

+ const CadenceLexerT__12

+ const CadenceLexerT__13

+ const CadenceParserRULE_bitwiseAndExpression

+ const CadenceParserRULE_bitwiseOrExpression

+ const CadenceParserRULE_bitwiseShiftExpression

+ const CadenceParserRULE_bitwiseShiftOp

+ const CadenceParserRULE_bitwiseXorExpression

+ const CadenceParserShiftLeft

+ const CadenceParserShiftRight

+ const CadenceParserT__12

+ const CadenceParserT__13

type BaseCadenceListener

+ func (s *BaseCadenceListener) EnterBitwiseAndExpression(ctx *BitwiseAndExpressionContext)

+ func (s *BaseCadenceListener) EnterBitwiseOrExpression(ctx *BitwiseOrExpressionContext)

+ func (s *BaseCadenceListener) EnterBitwiseShiftExpression(ctx *BitwiseShiftExpressionContext)

+ func (s *BaseCadenceListener) EnterBitwiseShiftOp(ctx *BitwiseShiftOpContext)

+ func (s *BaseCadenceListener) EnterBitwiseXorExpression(ctx *BitwiseXorExpressionContext)

+ func (s *BaseCadenceListener) ExitBitwiseAndExpression(ctx *BitwiseAndExpressionContext)

+ func (s *BaseCadenceListener) ExitBitwiseOrExpression(ctx *BitwiseOrExpressionContext)

+ func (s *BaseCadenceListener) ExitBitwiseShiftExpression(ctx *BitwiseShiftExpressionContext)

+ func (s *BaseCadenceListener) ExitBitwiseShiftOp(ctx *BitwiseShiftOpContext)

+ func (s *BaseCadenceListener) ExitBitwiseXorExpression(ctx *BitwiseXorExpressionContext)

type BaseCadenceVisitor

+ func (v *BaseCadenceVisitor) VisitBitwiseAndExpression(ctx *BitwiseAndExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitBitwiseOrExpression(ctx *BitwiseOrExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitBitwiseShiftExpression(ctx *BitwiseShiftExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitBitwiseShiftOp(ctx *BitwiseShiftOpContext) interface{}

+ func (v *BaseCadenceVisitor) VisitBitwiseXorExpression(ctx *BitwiseXorExpressionContext) interface{}

+ type BitwiseAndExpressionContext struct

+ func NewBitwiseAndExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwiseAndExpressionContext

+ func NewEmptyBitwiseAndExpressionContext() *BitwiseAndExpressionContext

+ func (*BitwiseAndExpressionContext) IsBitwiseAndExpressionContext()

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

+ func (s *BitwiseAndExpressionContext) Ampersand() antlr.TerminalNode

+ func (s *BitwiseAndExpressionContext) BitwiseAndExpression() IBitwiseAndExpressionContext

+ func (s *BitwiseAndExpressionContext) BitwiseShiftExpression() IBitwiseShiftExpressionContext

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

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

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

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

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

+ type BitwiseOrExpressionContext struct

+ func NewBitwiseOrExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwiseOrExpressionContext

+ func NewEmptyBitwiseOrExpressionContext() *BitwiseOrExpressionContext

+ func (*BitwiseOrExpressionContext) IsBitwiseOrExpressionContext()

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

+ func (s *BitwiseOrExpressionContext) BitwiseOrExpression() IBitwiseOrExpressionContext

+ func (s *BitwiseOrExpressionContext) BitwiseXorExpression() IBitwiseXorExpressionContext

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

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

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

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

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

+ type BitwiseShiftExpressionContext struct

+ func NewBitwiseShiftExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwiseShiftExpressionContext

+ func NewEmptyBitwiseShiftExpressionContext() *BitwiseShiftExpressionContext

+ func (*BitwiseShiftExpressionContext) IsBitwiseShiftExpressionContext()

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

+ func (s *BitwiseShiftExpressionContext) AdditiveExpression() IAdditiveExpressionContext

+ func (s *BitwiseShiftExpressionContext) BitwiseShiftExpression() IBitwiseShiftExpressionContext

+ func (s *BitwiseShiftExpressionContext) BitwiseShiftOp() IBitwiseShiftOpContext

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

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

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

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

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

+ type BitwiseShiftOpContext struct

+ func NewBitwiseShiftOpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwiseShiftOpContext

+ func NewEmptyBitwiseShiftOpContext() *BitwiseShiftOpContext

+ func (*BitwiseShiftOpContext) IsBitwiseShiftOpContext()

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

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

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

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

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

+ func (s *BitwiseShiftOpContext) ShiftLeft() antlr.TerminalNode

+ func (s *BitwiseShiftOpContext) ShiftRight() antlr.TerminalNode

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

+ type BitwiseXorExpressionContext struct

+ func NewBitwiseXorExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwiseXorExpressionContext

+ func NewEmptyBitwiseXorExpressionContext() *BitwiseXorExpressionContext

+ func (*BitwiseXorExpressionContext) IsBitwiseXorExpressionContext()

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

+ func (s *BitwiseXorExpressionContext) BitwiseAndExpression() IBitwiseAndExpressionContext

+ func (s *BitwiseXorExpressionContext) BitwiseXorExpression() IBitwiseXorExpressionContext

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

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

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

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

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

type CadenceListener

+ EnterBitwiseAndExpression func(c *BitwiseAndExpressionContext)

+ EnterBitwiseOrExpression func(c *BitwiseOrExpressionContext)

+ EnterBitwiseShiftExpression func(c *BitwiseShiftExpressionContext)

+ EnterBitwiseShiftOp func(c *BitwiseShiftOpContext)

+ EnterBitwiseXorExpression func(c *BitwiseXorExpressionContext)

+ ExitBitwiseAndExpression func(c *BitwiseAndExpressionContext)

+ ExitBitwiseOrExpression func(c *BitwiseOrExpressionContext)

+ ExitBitwiseShiftExpression func(c *BitwiseShiftExpressionContext)

+ ExitBitwiseShiftOp func(c *BitwiseShiftOpContext)

+ ExitBitwiseXorExpression func(c *BitwiseXorExpressionContext)

type CadenceParser

+ func (p *CadenceParser) BitwiseAndExpression() (localctx IBitwiseAndExpressionContext)

+ func (p *CadenceParser) BitwiseAndExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) BitwiseOrExpression() (localctx IBitwiseOrExpressionContext)

+ func (p *CadenceParser) BitwiseOrExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) BitwiseShiftExpression() (localctx IBitwiseShiftExpressionContext)

+ func (p *CadenceParser) BitwiseShiftExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) BitwiseShiftOp() (localctx IBitwiseShiftOpContext)

+ func (p *CadenceParser) BitwiseXorExpression() (localctx IBitwiseXorExpressionContext)

+ func (p *CadenceParser) BitwiseXorExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

type CadenceVisitor

+ VisitBitwiseAndExpression func(ctx *BitwiseAndExpressionContext) interface{}

+ VisitBitwiseOrExpression func(ctx *BitwiseOrExpressionContext) interface{}

+ VisitBitwiseShiftExpression func(ctx *BitwiseShiftExpressionContext) interface{}

+ VisitBitwiseShiftOp func(ctx *BitwiseShiftOpContext) interface{}

+ VisitBitwiseXorExpression func(ctx *BitwiseXorExpressionContext) interface{}

type CastingExpressionContext

+ func (s *CastingExpressionContext) UnaryExpression() IUnaryExpressionContext

+ type IBitwiseAndExpressionContext interface

+ GetParser func() antlr.Parser

+ IsBitwiseAndExpressionContext func()

+ type IBitwiseOrExpressionContext interface

+ GetParser func() antlr.Parser

+ IsBitwiseOrExpressionContext func()

+ type IBitwiseShiftExpressionContext interface

+ GetParser func() antlr.Parser

+ IsBitwiseShiftExpressionContext func()

+ type IBitwiseShiftOpContext interface

+ GetParser func() antlr.Parser

+ IsBitwiseShiftOpContext func()

+ type IBitwiseXorExpressionContext interface

+ GetParser func() antlr.Parser

+ IsBitwiseXorExpressionContext func()

type MultiplicativeExpressionContext

+ func (s *MultiplicativeExpressionContext) CastingExpression() ICastingExpressionContext

type NilCoalescingExpressionContext

+ func (s *NilCoalescingExpressionContext) BitwiseOrExpression() IBitwiseOrExpressionContext

type ProgramVisitor

+ func (v *ProgramVisitor) VisitBitwiseAndExpression(ctx *BitwiseAndExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitBitwiseOrExpression(ctx *BitwiseOrExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitBitwiseShiftExpression(ctx *BitwiseShiftExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitBitwiseShiftOp(ctx *BitwiseShiftOpContext) interface{}

+ func (v *ProgramVisitor) VisitBitwiseXorExpression(ctx *BitwiseXorExpressionContext) interface{}

v0.1.0

Apr 21, 2020

Changes in this version

+ const CadenceLexerAccess

+ const CadenceLexerAccount

+ const CadenceLexerAll

+ const CadenceLexerAmpersand

+ const CadenceLexerAuth

+ const CadenceLexerBinaryLiteral

+ const CadenceLexerBlockComment

+ const CadenceLexerBreak

+ const CadenceLexerCasting

+ const CadenceLexerCloseParen

+ const CadenceLexerContinue

+ const CadenceLexerContract

+ const CadenceLexerCreate

+ const CadenceLexerDecimalLiteral

+ const CadenceLexerDestroy

+ const CadenceLexerDiv

+ const CadenceLexerElse

+ const CadenceLexerEmit

+ const CadenceLexerEqual

+ const CadenceLexerEvent

+ const CadenceLexerFailableCasting

+ const CadenceLexerFalse

+ const CadenceLexerFor

+ const CadenceLexerForceCasting

+ const CadenceLexerFrom

+ const CadenceLexerFun

+ const CadenceLexerGreater

+ const CadenceLexerGreaterEqual

+ const CadenceLexerHexadecimalLiteral

+ const CadenceLexerIdentifier

+ const CadenceLexerIf

+ const CadenceLexerImport

+ const CadenceLexerIn

+ const CadenceLexerInterface

+ const CadenceLexerInvalidNumberLiteral

+ const CadenceLexerLess

+ const CadenceLexerLessEqual

+ const CadenceLexerLet

+ const CadenceLexerLineComment

+ const CadenceLexerMinus

+ const CadenceLexerMod

+ const CadenceLexerMove

+ const CadenceLexerMoveForced

+ const CadenceLexerMul

+ const CadenceLexerNegate

+ const CadenceLexerNil

+ const CadenceLexerNilCoalescing

+ const CadenceLexerOctalLiteral

+ const CadenceLexerOpenParen

+ const CadenceLexerOptional

+ const CadenceLexerPlus

+ const CadenceLexerPositiveFixedPointLiteral

+ const CadenceLexerPost

+ const CadenceLexerPre

+ const CadenceLexerPriv

+ const CadenceLexerPub

+ const CadenceLexerResource

+ const CadenceLexerResourceAnnotation

+ const CadenceLexerReturn

+ const CadenceLexerSelf

+ const CadenceLexerSet

+ const CadenceLexerStringLiteral

+ const CadenceLexerStruct

+ const CadenceLexerT__0

+ const CadenceLexerT__1

+ const CadenceLexerT__10

+ const CadenceLexerT__11

+ const CadenceLexerT__2

+ const CadenceLexerT__3

+ const CadenceLexerT__4

+ const CadenceLexerT__5

+ const CadenceLexerT__6

+ const CadenceLexerT__7

+ const CadenceLexerT__8

+ const CadenceLexerT__9

+ const CadenceLexerTerminator

+ const CadenceLexerTransaction

+ const CadenceLexerTrue

+ const CadenceLexerUnequal

+ const CadenceLexerVar

+ const CadenceLexerWS

+ const CadenceLexerWhile

+ const CadenceParserAccess

+ const CadenceParserAccount

+ const CadenceParserAll

+ const CadenceParserAmpersand

+ const CadenceParserAuth

+ const CadenceParserBinaryLiteral

+ const CadenceParserBlockComment

+ const CadenceParserBreak

+ const CadenceParserCasting

+ const CadenceParserCloseParen

+ const CadenceParserContinue

+ const CadenceParserContract

+ const CadenceParserCreate

+ const CadenceParserDecimalLiteral

+ const CadenceParserDestroy

+ const CadenceParserDiv

+ const CadenceParserEOF

+ const CadenceParserElse

+ const CadenceParserEmit

+ const CadenceParserEqual

+ const CadenceParserEvent

+ const CadenceParserFailableCasting

+ const CadenceParserFalse

+ const CadenceParserFor

+ const CadenceParserForceCasting

+ const CadenceParserFrom

+ const CadenceParserFun

+ const CadenceParserGreater

+ const CadenceParserGreaterEqual

+ const CadenceParserHexadecimalLiteral

+ const CadenceParserIdentifier

+ const CadenceParserIf

+ const CadenceParserImport

+ const CadenceParserIn

+ const CadenceParserInterface

+ const CadenceParserInvalidNumberLiteral

+ const CadenceParserLess

+ const CadenceParserLessEqual

+ const CadenceParserLet

+ const CadenceParserLineComment

+ const CadenceParserMinus

+ const CadenceParserMod

+ const CadenceParserMove

+ const CadenceParserMoveForced

+ const CadenceParserMul

+ const CadenceParserNegate

+ const CadenceParserNil

+ const CadenceParserNilCoalescing

+ const CadenceParserOctalLiteral

+ const CadenceParserOpenParen

+ const CadenceParserOptional

+ const CadenceParserPlus

+ const CadenceParserPositiveFixedPointLiteral

+ const CadenceParserPost

+ const CadenceParserPre

+ const CadenceParserPriv

+ const CadenceParserPub

+ const CadenceParserRULE_access

+ const CadenceParserRULE_additiveExpression

+ const CadenceParserRULE_additiveOp

+ const CadenceParserRULE_andExpression

+ const CadenceParserRULE_argument

+ const CadenceParserRULE_arrayLiteral

+ const CadenceParserRULE_assignment

+ const CadenceParserRULE_baseType

+ const CadenceParserRULE_block

+ const CadenceParserRULE_booleanLiteral

+ const CadenceParserRULE_bracketExpression

+ const CadenceParserRULE_breakStatement

+ const CadenceParserRULE_castingExpression

+ const CadenceParserRULE_castingOp

+ const CadenceParserRULE_compositeDeclaration

+ const CadenceParserRULE_compositeKind

+ const CadenceParserRULE_concatenatingExpression

+ const CadenceParserRULE_condition

+ const CadenceParserRULE_conditionalExpression

+ const CadenceParserRULE_conditions

+ const CadenceParserRULE_conformances

+ const CadenceParserRULE_constantSizedType

+ const CadenceParserRULE_continueStatement

+ const CadenceParserRULE_createExpression

+ const CadenceParserRULE_declaration

+ const CadenceParserRULE_destroyExpression

+ const CadenceParserRULE_dictionaryEntry

+ const CadenceParserRULE_dictionaryLiteral

+ const CadenceParserRULE_dictionaryType

+ const CadenceParserRULE_emitStatement

+ const CadenceParserRULE_eos

+ const CadenceParserRULE_equalityExpression

+ const CadenceParserRULE_equalityOp

+ const CadenceParserRULE_eventDeclaration

+ const CadenceParserRULE_execute

+ const CadenceParserRULE_expression

+ const CadenceParserRULE_expressionAccess

+ const CadenceParserRULE_field

+ const CadenceParserRULE_fields

+ const CadenceParserRULE_fixedPointLiteral

+ const CadenceParserRULE_forStatement

+ const CadenceParserRULE_fullType

+ const CadenceParserRULE_functionBlock

+ const CadenceParserRULE_functionDeclaration

+ const CadenceParserRULE_functionType

+ const CadenceParserRULE_identifier

+ const CadenceParserRULE_ifStatement

+ const CadenceParserRULE_importDeclaration

+ const CadenceParserRULE_innerType

+ const CadenceParserRULE_integerLiteral

+ const CadenceParserRULE_interfaceDeclaration

+ const CadenceParserRULE_invocation

+ const CadenceParserRULE_literal

+ const CadenceParserRULE_memberAccess

+ const CadenceParserRULE_memberOrNestedDeclaration

+ const CadenceParserRULE_membersAndNestedDeclarations

+ const CadenceParserRULE_multiplicativeExpression

+ const CadenceParserRULE_multiplicativeOp

+ const CadenceParserRULE_nilCoalescingExpression

+ const CadenceParserRULE_nilLiteral

+ const CadenceParserRULE_nominalType

+ const CadenceParserRULE_orExpression

+ const CadenceParserRULE_parameter

+ const CadenceParserRULE_parameterList

+ const CadenceParserRULE_pathLiteral

+ const CadenceParserRULE_positiveIntegerLiteral

+ const CadenceParserRULE_postConditions

+ const CadenceParserRULE_postfixExpression

+ const CadenceParserRULE_preConditions

+ const CadenceParserRULE_prepare

+ const CadenceParserRULE_primaryExpression

+ const CadenceParserRULE_program

+ const CadenceParserRULE_referenceExpression

+ const CadenceParserRULE_relationalExpression

+ const CadenceParserRULE_relationalOp

+ const CadenceParserRULE_replDeclaration

+ const CadenceParserRULE_replElement

+ const CadenceParserRULE_replInput

+ const CadenceParserRULE_replStatement

+ const CadenceParserRULE_returnStatement

+ const CadenceParserRULE_specialFunctionDeclaration

+ const CadenceParserRULE_statement

+ const CadenceParserRULE_statements

+ const CadenceParserRULE_stringLiteral

+ const CadenceParserRULE_swap

+ const CadenceParserRULE_transactionDeclaration

+ const CadenceParserRULE_transfer

+ const CadenceParserRULE_typeAnnotation

+ const CadenceParserRULE_typeRestrictions

+ const CadenceParserRULE_unaryExpression

+ const CadenceParserRULE_unaryOp

+ const CadenceParserRULE_variableDeclaration

+ const CadenceParserRULE_variableKind

+ const CadenceParserRULE_variableSizedType

+ const CadenceParserRULE_whileStatement

+ const CadenceParserResource

+ const CadenceParserResourceAnnotation

+ const CadenceParserReturn

+ const CadenceParserSelf

+ const CadenceParserSet

+ const CadenceParserStringLiteral

+ const CadenceParserStruct

+ const CadenceParserT__0

+ const CadenceParserT__1

+ const CadenceParserT__10

+ const CadenceParserT__11

+ const CadenceParserT__2

+ const CadenceParserT__3

+ const CadenceParserT__4

+ const CadenceParserT__5

+ const CadenceParserT__6

+ const CadenceParserT__7

+ const CadenceParserT__8

+ const CadenceParserT__9

+ const CadenceParserTerminator

+ const CadenceParserTransaction

+ const CadenceParserTrue

+ const CadenceParserUnequal

+ const CadenceParserVar

+ const CadenceParserWS

+ const CadenceParserWhile

+ func ParseExpression(code string) (expression ast.Expression, inputIsComplete bool, err error)

+ func ParseProgram(code string) (program *ast.Program, inputIsComplete bool, err error)

+ func ParseProgramFromFile(filename string) (program *ast.Program, inputIsComplete bool, code string, err error)

+ func ParseReplInput(code string) (replInput []interface{}, inputIsComplete bool, err error)

+ func PositionFromToken(token antlr.Token) ast.Position

+ func PositionRangeFromContext(ctx antlr.ParserRuleContext) (start, end ast.Position)

+ type AccessContext struct

+ func NewAccessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AccessContext

+ func NewEmptyAccessContext() *AccessContext

+ func (*AccessContext) IsAccessContext()

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

+ func (s *AccessContext) Access() antlr.TerminalNode

+ func (s *AccessContext) Account() antlr.TerminalNode

+ func (s *AccessContext) All() antlr.TerminalNode

+ func (s *AccessContext) CloseParen() antlr.TerminalNode

+ func (s *AccessContext) Contract() antlr.TerminalNode

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

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

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

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

+ func (s *AccessContext) OpenParen() antlr.TerminalNode

+ func (s *AccessContext) Priv() antlr.TerminalNode

+ func (s *AccessContext) Pub() antlr.TerminalNode

+ func (s *AccessContext) Self() antlr.TerminalNode

+ func (s *AccessContext) Set() antlr.TerminalNode

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

+ type AccessExpressionContext struct

+ func NewAccessExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AccessExpressionContext

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

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

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

+ func (s *AccessExpressionContext) ExpressionAccess() IExpressionAccessContext

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

+ func (s *AccessExpressionContext) PostfixExpression() IPostfixExpressionContext

+ type AdditiveExpressionContext struct

+ func NewAdditiveExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdditiveExpressionContext

+ func NewEmptyAdditiveExpressionContext() *AdditiveExpressionContext

+ func (*AdditiveExpressionContext) IsAdditiveExpressionContext()

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

+ func (s *AdditiveExpressionContext) AdditiveExpression() IAdditiveExpressionContext

+ func (s *AdditiveExpressionContext) AdditiveOp() IAdditiveOpContext

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

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

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

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

+ func (s *AdditiveExpressionContext) MultiplicativeExpression() IMultiplicativeExpressionContext

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

+ type AdditiveOpContext struct

+ func NewAdditiveOpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdditiveOpContext

+ func NewEmptyAdditiveOpContext() *AdditiveOpContext

+ func (*AdditiveOpContext) IsAdditiveOpContext()

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

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

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

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

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

+ func (s *AdditiveOpContext) Minus() antlr.TerminalNode

+ func (s *AdditiveOpContext) Plus() antlr.TerminalNode

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

+ type AndExpressionContext struct

+ func NewAndExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AndExpressionContext

+ func NewEmptyAndExpressionContext() *AndExpressionContext

+ func (*AndExpressionContext) IsAndExpressionContext()

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

+ func (s *AndExpressionContext) AndExpression() IAndExpressionContext

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

+ func (s *AndExpressionContext) EqualityExpression() IEqualityExpressionContext

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

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

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

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

+ type ArgumentContext struct

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

+ func NewEmptyArgumentContext() *ArgumentContext

+ func (*ArgumentContext) IsArgumentContext()

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

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

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

+ func (s *ArgumentContext) Expression() IExpressionContext

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

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

+ func (s *ArgumentContext) Identifier() IIdentifierContext

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

+ type ArrayLiteralContext struct

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

+ func NewEmptyArrayLiteralContext() *ArrayLiteralContext

+ func (*ArrayLiteralContext) IsArrayLiteralContext()

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

+ func (s *ArrayLiteralContext) AllExpression() []IExpressionContext

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

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

+ func (s *ArrayLiteralContext) Expression(i int) IExpressionContext

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

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

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

+ type AssignmentContext struct

+ func NewAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentContext

+ func NewEmptyAssignmentContext() *AssignmentContext

+ func (*AssignmentContext) IsAssignmentContext()

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

+ func (s *AssignmentContext) AllExpressionAccess() []IExpressionAccessContext

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

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

+ func (s *AssignmentContext) Expression() IExpressionContext

+ func (s *AssignmentContext) ExpressionAccess(i int) IExpressionAccessContext

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

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

+ func (s *AssignmentContext) Identifier() IIdentifierContext

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

+ func (s *AssignmentContext) Transfer() ITransferContext

+ type BaseCadenceListener struct

+ func (s *BaseCadenceListener) EnterAccess(ctx *AccessContext)

+ func (s *BaseCadenceListener) EnterAccessExpression(ctx *AccessExpressionContext)

+ func (s *BaseCadenceListener) EnterAdditiveExpression(ctx *AdditiveExpressionContext)

+ func (s *BaseCadenceListener) EnterAdditiveOp(ctx *AdditiveOpContext)

+ func (s *BaseCadenceListener) EnterAndExpression(ctx *AndExpressionContext)

+ func (s *BaseCadenceListener) EnterArgument(ctx *ArgumentContext)

+ func (s *BaseCadenceListener) EnterArrayLiteral(ctx *ArrayLiteralContext)

+ func (s *BaseCadenceListener) EnterAssignment(ctx *AssignmentContext)

+ func (s *BaseCadenceListener) EnterBaseType(ctx *BaseTypeContext)

+ func (s *BaseCadenceListener) EnterBinaryLiteral(ctx *BinaryLiteralContext)

+ func (s *BaseCadenceListener) EnterBlock(ctx *BlockContext)

+ func (s *BaseCadenceListener) EnterBooleanLiteral(ctx *BooleanLiteralContext)

+ func (s *BaseCadenceListener) EnterBracketExpression(ctx *BracketExpressionContext)

+ func (s *BaseCadenceListener) EnterBreakStatement(ctx *BreakStatementContext)

+ func (s *BaseCadenceListener) EnterCastingExpression(ctx *CastingExpressionContext)

+ func (s *BaseCadenceListener) EnterCastingOp(ctx *CastingOpContext)

+ func (s *BaseCadenceListener) EnterCompositeDeclaration(ctx *CompositeDeclarationContext)

+ func (s *BaseCadenceListener) EnterCompositeKind(ctx *CompositeKindContext)

+ func (s *BaseCadenceListener) EnterConcatenatingExpression(ctx *ConcatenatingExpressionContext)

+ func (s *BaseCadenceListener) EnterCondition(ctx *ConditionContext)

+ func (s *BaseCadenceListener) EnterConditionalExpression(ctx *ConditionalExpressionContext)

+ func (s *BaseCadenceListener) EnterConditions(ctx *ConditionsContext)

+ func (s *BaseCadenceListener) EnterConformances(ctx *ConformancesContext)

+ func (s *BaseCadenceListener) EnterConstantSizedType(ctx *ConstantSizedTypeContext)

+ func (s *BaseCadenceListener) EnterContinueStatement(ctx *ContinueStatementContext)

+ func (s *BaseCadenceListener) EnterCreateExpression(ctx *CreateExpressionContext)

+ func (s *BaseCadenceListener) EnterDecimalLiteral(ctx *DecimalLiteralContext)

+ func (s *BaseCadenceListener) EnterDeclaration(ctx *DeclarationContext)

+ func (s *BaseCadenceListener) EnterDestroyExpression(ctx *DestroyExpressionContext)

+ func (s *BaseCadenceListener) EnterDictionaryEntry(ctx *DictionaryEntryContext)

+ func (s *BaseCadenceListener) EnterDictionaryLiteral(ctx *DictionaryLiteralContext)

+ func (s *BaseCadenceListener) EnterDictionaryType(ctx *DictionaryTypeContext)

+ func (s *BaseCadenceListener) EnterEmitStatement(ctx *EmitStatementContext)

+ func (s *BaseCadenceListener) EnterEos(ctx *EosContext)

+ func (s *BaseCadenceListener) EnterEqualityExpression(ctx *EqualityExpressionContext)

+ func (s *BaseCadenceListener) EnterEqualityOp(ctx *EqualityOpContext)

+ func (s *BaseCadenceListener) EnterEventDeclaration(ctx *EventDeclarationContext)

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

+ func (s *BaseCadenceListener) EnterExecute(ctx *ExecuteContext)

+ func (s *BaseCadenceListener) EnterExpression(ctx *ExpressionContext)

+ func (s *BaseCadenceListener) EnterExpressionAccess(ctx *ExpressionAccessContext)

+ func (s *BaseCadenceListener) EnterField(ctx *FieldContext)

+ func (s *BaseCadenceListener) EnterFields(ctx *FieldsContext)

+ func (s *BaseCadenceListener) EnterFixedPointLiteral(ctx *FixedPointLiteralContext)

+ func (s *BaseCadenceListener) EnterForStatement(ctx *ForStatementContext)

+ func (s *BaseCadenceListener) EnterForceExpression(ctx *ForceExpressionContext)

+ func (s *BaseCadenceListener) EnterFullType(ctx *FullTypeContext)

+ func (s *BaseCadenceListener) EnterFunctionBlock(ctx *FunctionBlockContext)

+ func (s *BaseCadenceListener) EnterFunctionDeclaration(ctx *FunctionDeclarationContext)

+ func (s *BaseCadenceListener) EnterFunctionExpression(ctx *FunctionExpressionContext)

+ func (s *BaseCadenceListener) EnterFunctionType(ctx *FunctionTypeContext)

+ func (s *BaseCadenceListener) EnterHexadecimalLiteral(ctx *HexadecimalLiteralContext)

+ func (s *BaseCadenceListener) EnterIdentifier(ctx *IdentifierContext)

+ func (s *BaseCadenceListener) EnterIdentifierExpression(ctx *IdentifierExpressionContext)

+ func (s *BaseCadenceListener) EnterIfStatement(ctx *IfStatementContext)

+ func (s *BaseCadenceListener) EnterImportDeclaration(ctx *ImportDeclarationContext)

+ func (s *BaseCadenceListener) EnterInnerType(ctx *InnerTypeContext)

+ func (s *BaseCadenceListener) EnterIntegerLiteral(ctx *IntegerLiteralContext)

+ func (s *BaseCadenceListener) EnterInterfaceDeclaration(ctx *InterfaceDeclarationContext)

+ func (s *BaseCadenceListener) EnterInvalidNumberLiteral(ctx *InvalidNumberLiteralContext)

+ func (s *BaseCadenceListener) EnterInvocation(ctx *InvocationContext)

+ func (s *BaseCadenceListener) EnterInvocationExpression(ctx *InvocationExpressionContext)

+ func (s *BaseCadenceListener) EnterLiteral(ctx *LiteralContext)

+ func (s *BaseCadenceListener) EnterLiteralExpression(ctx *LiteralExpressionContext)

+ func (s *BaseCadenceListener) EnterMemberAccess(ctx *MemberAccessContext)

+ func (s *BaseCadenceListener) EnterMemberOrNestedDeclaration(ctx *MemberOrNestedDeclarationContext)

+ func (s *BaseCadenceListener) EnterMembersAndNestedDeclarations(ctx *MembersAndNestedDeclarationsContext)

+ func (s *BaseCadenceListener) EnterMultiplicativeExpression(ctx *MultiplicativeExpressionContext)

+ func (s *BaseCadenceListener) EnterMultiplicativeOp(ctx *MultiplicativeOpContext)

+ func (s *BaseCadenceListener) EnterNestedExpression(ctx *NestedExpressionContext)

+ func (s *BaseCadenceListener) EnterNilCoalescingExpression(ctx *NilCoalescingExpressionContext)

+ func (s *BaseCadenceListener) EnterNilLiteral(ctx *NilLiteralContext)

+ func (s *BaseCadenceListener) EnterNominalType(ctx *NominalTypeContext)

+ func (s *BaseCadenceListener) EnterOctalLiteral(ctx *OctalLiteralContext)

+ func (s *BaseCadenceListener) EnterOrExpression(ctx *OrExpressionContext)

+ func (s *BaseCadenceListener) EnterParameter(ctx *ParameterContext)

+ func (s *BaseCadenceListener) EnterParameterList(ctx *ParameterListContext)

+ func (s *BaseCadenceListener) EnterPathLiteral(ctx *PathLiteralContext)

+ func (s *BaseCadenceListener) EnterPostConditions(ctx *PostConditionsContext)

+ func (s *BaseCadenceListener) EnterPreConditions(ctx *PreConditionsContext)

+ func (s *BaseCadenceListener) EnterPrepare(ctx *PrepareContext)

+ func (s *BaseCadenceListener) EnterPrimaryExpression(ctx *PrimaryExpressionContext)

+ func (s *BaseCadenceListener) EnterProgram(ctx *ProgramContext)

+ func (s *BaseCadenceListener) EnterReferenceExpression(ctx *ReferenceExpressionContext)

+ func (s *BaseCadenceListener) EnterRelationalExpression(ctx *RelationalExpressionContext)

+ func (s *BaseCadenceListener) EnterRelationalOp(ctx *RelationalOpContext)

+ func (s *BaseCadenceListener) EnterReplDeclaration(ctx *ReplDeclarationContext)

+ func (s *BaseCadenceListener) EnterReplElement(ctx *ReplElementContext)

+ func (s *BaseCadenceListener) EnterReplInput(ctx *ReplInputContext)

+ func (s *BaseCadenceListener) EnterReplStatement(ctx *ReplStatementContext)

+ func (s *BaseCadenceListener) EnterReturnStatement(ctx *ReturnStatementContext)

+ func (s *BaseCadenceListener) EnterSpecialFunctionDeclaration(ctx *SpecialFunctionDeclarationContext)

+ func (s *BaseCadenceListener) EnterStatement(ctx *StatementContext)

+ func (s *BaseCadenceListener) EnterStatements(ctx *StatementsContext)

+ func (s *BaseCadenceListener) EnterStringLiteral(ctx *StringLiteralContext)

+ func (s *BaseCadenceListener) EnterSwap(ctx *SwapContext)

+ func (s *BaseCadenceListener) EnterTransactionDeclaration(ctx *TransactionDeclarationContext)

+ func (s *BaseCadenceListener) EnterTransfer(ctx *TransferContext)

+ func (s *BaseCadenceListener) EnterTypeAnnotation(ctx *TypeAnnotationContext)

+ func (s *BaseCadenceListener) EnterTypeRestrictions(ctx *TypeRestrictionsContext)

+ func (s *BaseCadenceListener) EnterUnaryExpression(ctx *UnaryExpressionContext)

+ func (s *BaseCadenceListener) EnterUnaryOp(ctx *UnaryOpContext)

+ func (s *BaseCadenceListener) EnterVariableDeclaration(ctx *VariableDeclarationContext)

+ func (s *BaseCadenceListener) EnterVariableKind(ctx *VariableKindContext)

+ func (s *BaseCadenceListener) EnterVariableSizedType(ctx *VariableSizedTypeContext)

+ func (s *BaseCadenceListener) EnterWhileStatement(ctx *WhileStatementContext)

+ func (s *BaseCadenceListener) ExitAccess(ctx *AccessContext)

+ func (s *BaseCadenceListener) ExitAccessExpression(ctx *AccessExpressionContext)

+ func (s *BaseCadenceListener) ExitAdditiveExpression(ctx *AdditiveExpressionContext)

+ func (s *BaseCadenceListener) ExitAdditiveOp(ctx *AdditiveOpContext)

+ func (s *BaseCadenceListener) ExitAndExpression(ctx *AndExpressionContext)

+ func (s *BaseCadenceListener) ExitArgument(ctx *ArgumentContext)

+ func (s *BaseCadenceListener) ExitArrayLiteral(ctx *ArrayLiteralContext)

+ func (s *BaseCadenceListener) ExitAssignment(ctx *AssignmentContext)

+ func (s *BaseCadenceListener) ExitBaseType(ctx *BaseTypeContext)

+ func (s *BaseCadenceListener) ExitBinaryLiteral(ctx *BinaryLiteralContext)

+ func (s *BaseCadenceListener) ExitBlock(ctx *BlockContext)

+ func (s *BaseCadenceListener) ExitBooleanLiteral(ctx *BooleanLiteralContext)

+ func (s *BaseCadenceListener) ExitBracketExpression(ctx *BracketExpressionContext)

+ func (s *BaseCadenceListener) ExitBreakStatement(ctx *BreakStatementContext)

+ func (s *BaseCadenceListener) ExitCastingExpression(ctx *CastingExpressionContext)

+ func (s *BaseCadenceListener) ExitCastingOp(ctx *CastingOpContext)

+ func (s *BaseCadenceListener) ExitCompositeDeclaration(ctx *CompositeDeclarationContext)

+ func (s *BaseCadenceListener) ExitCompositeKind(ctx *CompositeKindContext)

+ func (s *BaseCadenceListener) ExitConcatenatingExpression(ctx *ConcatenatingExpressionContext)

+ func (s *BaseCadenceListener) ExitCondition(ctx *ConditionContext)

+ func (s *BaseCadenceListener) ExitConditionalExpression(ctx *ConditionalExpressionContext)

+ func (s *BaseCadenceListener) ExitConditions(ctx *ConditionsContext)

+ func (s *BaseCadenceListener) ExitConformances(ctx *ConformancesContext)

+ func (s *BaseCadenceListener) ExitConstantSizedType(ctx *ConstantSizedTypeContext)

+ func (s *BaseCadenceListener) ExitContinueStatement(ctx *ContinueStatementContext)

+ func (s *BaseCadenceListener) ExitCreateExpression(ctx *CreateExpressionContext)

+ func (s *BaseCadenceListener) ExitDecimalLiteral(ctx *DecimalLiteralContext)

+ func (s *BaseCadenceListener) ExitDeclaration(ctx *DeclarationContext)

+ func (s *BaseCadenceListener) ExitDestroyExpression(ctx *DestroyExpressionContext)

+ func (s *BaseCadenceListener) ExitDictionaryEntry(ctx *DictionaryEntryContext)

+ func (s *BaseCadenceListener) ExitDictionaryLiteral(ctx *DictionaryLiteralContext)

+ func (s *BaseCadenceListener) ExitDictionaryType(ctx *DictionaryTypeContext)

+ func (s *BaseCadenceListener) ExitEmitStatement(ctx *EmitStatementContext)

+ func (s *BaseCadenceListener) ExitEos(ctx *EosContext)

+ func (s *BaseCadenceListener) ExitEqualityExpression(ctx *EqualityExpressionContext)

+ func (s *BaseCadenceListener) ExitEqualityOp(ctx *EqualityOpContext)

+ func (s *BaseCadenceListener) ExitEventDeclaration(ctx *EventDeclarationContext)

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

+ func (s *BaseCadenceListener) ExitExecute(ctx *ExecuteContext)

+ func (s *BaseCadenceListener) ExitExpression(ctx *ExpressionContext)

+ func (s *BaseCadenceListener) ExitExpressionAccess(ctx *ExpressionAccessContext)

+ func (s *BaseCadenceListener) ExitField(ctx *FieldContext)

+ func (s *BaseCadenceListener) ExitFields(ctx *FieldsContext)

+ func (s *BaseCadenceListener) ExitFixedPointLiteral(ctx *FixedPointLiteralContext)

+ func (s *BaseCadenceListener) ExitForStatement(ctx *ForStatementContext)

+ func (s *BaseCadenceListener) ExitForceExpression(ctx *ForceExpressionContext)

+ func (s *BaseCadenceListener) ExitFullType(ctx *FullTypeContext)

+ func (s *BaseCadenceListener) ExitFunctionBlock(ctx *FunctionBlockContext)

+ func (s *BaseCadenceListener) ExitFunctionDeclaration(ctx *FunctionDeclarationContext)

+ func (s *BaseCadenceListener) ExitFunctionExpression(ctx *FunctionExpressionContext)

+ func (s *BaseCadenceListener) ExitFunctionType(ctx *FunctionTypeContext)

+ func (s *BaseCadenceListener) ExitHexadecimalLiteral(ctx *HexadecimalLiteralContext)

+ func (s *BaseCadenceListener) ExitIdentifier(ctx *IdentifierContext)

+ func (s *BaseCadenceListener) ExitIdentifierExpression(ctx *IdentifierExpressionContext)

+ func (s *BaseCadenceListener) ExitIfStatement(ctx *IfStatementContext)

+ func (s *BaseCadenceListener) ExitImportDeclaration(ctx *ImportDeclarationContext)

+ func (s *BaseCadenceListener) ExitInnerType(ctx *InnerTypeContext)

+ func (s *BaseCadenceListener) ExitIntegerLiteral(ctx *IntegerLiteralContext)

+ func (s *BaseCadenceListener) ExitInterfaceDeclaration(ctx *InterfaceDeclarationContext)

+ func (s *BaseCadenceListener) ExitInvalidNumberLiteral(ctx *InvalidNumberLiteralContext)

+ func (s *BaseCadenceListener) ExitInvocation(ctx *InvocationContext)

+ func (s *BaseCadenceListener) ExitInvocationExpression(ctx *InvocationExpressionContext)

+ func (s *BaseCadenceListener) ExitLiteral(ctx *LiteralContext)

+ func (s *BaseCadenceListener) ExitLiteralExpression(ctx *LiteralExpressionContext)

+ func (s *BaseCadenceListener) ExitMemberAccess(ctx *MemberAccessContext)

+ func (s *BaseCadenceListener) ExitMemberOrNestedDeclaration(ctx *MemberOrNestedDeclarationContext)

+ func (s *BaseCadenceListener) ExitMembersAndNestedDeclarations(ctx *MembersAndNestedDeclarationsContext)

+ func (s *BaseCadenceListener) ExitMultiplicativeExpression(ctx *MultiplicativeExpressionContext)

+ func (s *BaseCadenceListener) ExitMultiplicativeOp(ctx *MultiplicativeOpContext)

+ func (s *BaseCadenceListener) ExitNestedExpression(ctx *NestedExpressionContext)

+ func (s *BaseCadenceListener) ExitNilCoalescingExpression(ctx *NilCoalescingExpressionContext)

+ func (s *BaseCadenceListener) ExitNilLiteral(ctx *NilLiteralContext)

+ func (s *BaseCadenceListener) ExitNominalType(ctx *NominalTypeContext)

+ func (s *BaseCadenceListener) ExitOctalLiteral(ctx *OctalLiteralContext)

+ func (s *BaseCadenceListener) ExitOrExpression(ctx *OrExpressionContext)

+ func (s *BaseCadenceListener) ExitParameter(ctx *ParameterContext)

+ func (s *BaseCadenceListener) ExitParameterList(ctx *ParameterListContext)

+ func (s *BaseCadenceListener) ExitPathLiteral(ctx *PathLiteralContext)

+ func (s *BaseCadenceListener) ExitPostConditions(ctx *PostConditionsContext)

+ func (s *BaseCadenceListener) ExitPreConditions(ctx *PreConditionsContext)

+ func (s *BaseCadenceListener) ExitPrepare(ctx *PrepareContext)

+ func (s *BaseCadenceListener) ExitPrimaryExpression(ctx *PrimaryExpressionContext)

+ func (s *BaseCadenceListener) ExitProgram(ctx *ProgramContext)

+ func (s *BaseCadenceListener) ExitReferenceExpression(ctx *ReferenceExpressionContext)

+ func (s *BaseCadenceListener) ExitRelationalExpression(ctx *RelationalExpressionContext)

+ func (s *BaseCadenceListener) ExitRelationalOp(ctx *RelationalOpContext)

+ func (s *BaseCadenceListener) ExitReplDeclaration(ctx *ReplDeclarationContext)

+ func (s *BaseCadenceListener) ExitReplElement(ctx *ReplElementContext)

+ func (s *BaseCadenceListener) ExitReplInput(ctx *ReplInputContext)

+ func (s *BaseCadenceListener) ExitReplStatement(ctx *ReplStatementContext)

+ func (s *BaseCadenceListener) ExitReturnStatement(ctx *ReturnStatementContext)

+ func (s *BaseCadenceListener) ExitSpecialFunctionDeclaration(ctx *SpecialFunctionDeclarationContext)

+ func (s *BaseCadenceListener) ExitStatement(ctx *StatementContext)

+ func (s *BaseCadenceListener) ExitStatements(ctx *StatementsContext)

+ func (s *BaseCadenceListener) ExitStringLiteral(ctx *StringLiteralContext)

+ func (s *BaseCadenceListener) ExitSwap(ctx *SwapContext)

+ func (s *BaseCadenceListener) ExitTransactionDeclaration(ctx *TransactionDeclarationContext)

+ func (s *BaseCadenceListener) ExitTransfer(ctx *TransferContext)

+ func (s *BaseCadenceListener) ExitTypeAnnotation(ctx *TypeAnnotationContext)

+ func (s *BaseCadenceListener) ExitTypeRestrictions(ctx *TypeRestrictionsContext)

+ func (s *BaseCadenceListener) ExitUnaryExpression(ctx *UnaryExpressionContext)

+ func (s *BaseCadenceListener) ExitUnaryOp(ctx *UnaryOpContext)

+ func (s *BaseCadenceListener) ExitVariableDeclaration(ctx *VariableDeclarationContext)

+ func (s *BaseCadenceListener) ExitVariableKind(ctx *VariableKindContext)

+ func (s *BaseCadenceListener) ExitVariableSizedType(ctx *VariableSizedTypeContext)

+ func (s *BaseCadenceListener) ExitWhileStatement(ctx *WhileStatementContext)

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

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

+ type BaseCadenceVisitor struct

+ func (v *BaseCadenceVisitor) VisitAccess(ctx *AccessContext) interface{}

+ func (v *BaseCadenceVisitor) VisitAccessExpression(ctx *AccessExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitAdditiveExpression(ctx *AdditiveExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitAdditiveOp(ctx *AdditiveOpContext) interface{}

+ func (v *BaseCadenceVisitor) VisitAndExpression(ctx *AndExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitArgument(ctx *ArgumentContext) interface{}

+ func (v *BaseCadenceVisitor) VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitAssignment(ctx *AssignmentContext) interface{}

+ func (v *BaseCadenceVisitor) VisitBaseType(ctx *BaseTypeContext) interface{}

+ func (v *BaseCadenceVisitor) VisitBinaryLiteral(ctx *BinaryLiteralContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitBracketExpression(ctx *BracketExpressionContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitCastingExpression(ctx *CastingExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitCastingOp(ctx *CastingOpContext) interface{}

+ func (v *BaseCadenceVisitor) VisitCompositeDeclaration(ctx *CompositeDeclarationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitCompositeKind(ctx *CompositeKindContext) interface{}

+ func (v *BaseCadenceVisitor) VisitConcatenatingExpression(ctx *ConcatenatingExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitCondition(ctx *ConditionContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitConditions(ctx *ConditionsContext) interface{}

+ func (v *BaseCadenceVisitor) VisitConformances(ctx *ConformancesContext) interface{}

+ func (v *BaseCadenceVisitor) VisitConstantSizedType(ctx *ConstantSizedTypeContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitCreateExpression(ctx *CreateExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitDeclaration(ctx *DeclarationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitDestroyExpression(ctx *DestroyExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitDictionaryEntry(ctx *DictionaryEntryContext) interface{}

+ func (v *BaseCadenceVisitor) VisitDictionaryLiteral(ctx *DictionaryLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitDictionaryType(ctx *DictionaryTypeContext) interface{}

+ func (v *BaseCadenceVisitor) VisitEmitStatement(ctx *EmitStatementContext) interface{}

+ func (v *BaseCadenceVisitor) VisitEos(ctx *EosContext) interface{}

+ func (v *BaseCadenceVisitor) VisitEqualityExpression(ctx *EqualityExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitEqualityOp(ctx *EqualityOpContext) interface{}

+ func (v *BaseCadenceVisitor) VisitEventDeclaration(ctx *EventDeclarationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitExecute(ctx *ExecuteContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitExpressionAccess(ctx *ExpressionAccessContext) interface{}

+ func (v *BaseCadenceVisitor) VisitField(ctx *FieldContext) interface{}

+ func (v *BaseCadenceVisitor) VisitFields(ctx *FieldsContext) interface{}

+ func (v *BaseCadenceVisitor) VisitFixedPointLiteral(ctx *FixedPointLiteralContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitForceExpression(ctx *ForceExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitFullType(ctx *FullTypeContext) interface{}

+ func (v *BaseCadenceVisitor) VisitFunctionBlock(ctx *FunctionBlockContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitFunctionExpression(ctx *FunctionExpressionContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitHexadecimalLiteral(ctx *HexadecimalLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitIdentifier(ctx *IdentifierContext) interface{}

+ func (v *BaseCadenceVisitor) VisitIdentifierExpression(ctx *IdentifierExpressionContext) interface{}

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

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

+ func (v *BaseCadenceVisitor) VisitInnerType(ctx *InnerTypeContext) interface{}

+ func (v *BaseCadenceVisitor) VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitInterfaceDeclaration(ctx *InterfaceDeclarationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitInvalidNumberLiteral(ctx *InvalidNumberLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitInvocation(ctx *InvocationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitInvocationExpression(ctx *InvocationExpressionContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitLiteralExpression(ctx *LiteralExpressionContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitMemberOrNestedDeclaration(ctx *MemberOrNestedDeclarationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitMembersAndNestedDeclarations(ctx *MembersAndNestedDeclarationsContext) interface{}

+ func (v *BaseCadenceVisitor) VisitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitMultiplicativeOp(ctx *MultiplicativeOpContext) interface{}

+ func (v *BaseCadenceVisitor) VisitNestedExpression(ctx *NestedExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitNilCoalescingExpression(ctx *NilCoalescingExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitNilLiteral(ctx *NilLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitNominalType(ctx *NominalTypeContext) interface{}

+ func (v *BaseCadenceVisitor) VisitOctalLiteral(ctx *OctalLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitOrExpression(ctx *OrExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitParameter(ctx *ParameterContext) interface{}

+ func (v *BaseCadenceVisitor) VisitParameterList(ctx *ParameterListContext) interface{}

+ func (v *BaseCadenceVisitor) VisitPathLiteral(ctx *PathLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitPostConditions(ctx *PostConditionsContext) interface{}

+ func (v *BaseCadenceVisitor) VisitPreConditions(ctx *PreConditionsContext) interface{}

+ func (v *BaseCadenceVisitor) VisitPrepare(ctx *PrepareContext) interface{}

+ func (v *BaseCadenceVisitor) VisitPrimaryExpression(ctx *PrimaryExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitProgram(ctx *ProgramContext) interface{}

+ func (v *BaseCadenceVisitor) VisitReferenceExpression(ctx *ReferenceExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitRelationalExpression(ctx *RelationalExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitRelationalOp(ctx *RelationalOpContext) interface{}

+ func (v *BaseCadenceVisitor) VisitReplDeclaration(ctx *ReplDeclarationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitReplElement(ctx *ReplElementContext) interface{}

+ func (v *BaseCadenceVisitor) VisitReplInput(ctx *ReplInputContext) interface{}

+ func (v *BaseCadenceVisitor) VisitReplStatement(ctx *ReplStatementContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitSpecialFunctionDeclaration(ctx *SpecialFunctionDeclarationContext) interface{}

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

+ func (v *BaseCadenceVisitor) VisitStatements(ctx *StatementsContext) interface{}

+ func (v *BaseCadenceVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}

+ func (v *BaseCadenceVisitor) VisitSwap(ctx *SwapContext) interface{}

+ func (v *BaseCadenceVisitor) VisitTransactionDeclaration(ctx *TransactionDeclarationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitTransfer(ctx *TransferContext) interface{}

+ func (v *BaseCadenceVisitor) VisitTypeAnnotation(ctx *TypeAnnotationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitTypeRestrictions(ctx *TypeRestrictionsContext) interface{}

+ func (v *BaseCadenceVisitor) VisitUnaryExpression(ctx *UnaryExpressionContext) interface{}

+ func (v *BaseCadenceVisitor) VisitUnaryOp(ctx *UnaryOpContext) interface{}

+ func (v *BaseCadenceVisitor) VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

+ func (v *BaseCadenceVisitor) VisitVariableKind(ctx *VariableKindContext) interface{}

+ func (v *BaseCadenceVisitor) VisitVariableSizedType(ctx *VariableSizedTypeContext) interface{}

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

+ type BaseTypeContext struct

+ func NewBaseTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BaseTypeContext

+ func NewEmptyBaseTypeContext() *BaseTypeContext

+ func (*BaseTypeContext) IsBaseTypeContext()

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

+ func (s *BaseTypeContext) ConstantSizedType() IConstantSizedTypeContext

+ func (s *BaseTypeContext) DictionaryType() IDictionaryTypeContext

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

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

+ func (s *BaseTypeContext) FunctionType() IFunctionTypeContext

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

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

+ func (s *BaseTypeContext) NominalType() INominalTypeContext

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

+ func (s *BaseTypeContext) VariableSizedType() IVariableSizedTypeContext

+ type BinaryLiteralContext struct

+ func NewBinaryLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryLiteralContext

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

+ func (s *BinaryLiteralContext) BinaryLiteral() antlr.TerminalNode

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

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

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

+ 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) EnterRule(listener antlr.ParseTreeListener)

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

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

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

+ func (s *BlockContext) Statements() IStatementsContext

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

+ type BooleanLiteralContext struct

+ func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext

+ func NewEmptyBooleanLiteralContext() *BooleanLiteralContext

+ func (*BooleanLiteralContext) IsBooleanLiteralContext()

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

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

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

+ func (s *BooleanLiteralContext) False() antlr.TerminalNode

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

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

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

+ func (s *BooleanLiteralContext) True() antlr.TerminalNode

+ type BracketExpressionContext struct

+ func NewBracketExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BracketExpressionContext

+ func NewEmptyBracketExpressionContext() *BracketExpressionContext

+ func (*BracketExpressionContext) IsBracketExpressionContext()

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

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

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

+ func (s *BracketExpressionContext) Expression() IExpressionContext

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

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

+ func (s *BracketExpressionContext) 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) EnterRule(listener antlr.ParseTreeListener)

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

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

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

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

+ type CadenceLexer struct

+ func NewCadenceLexer(input antlr.CharStream) *CadenceLexer

+ type CadenceListener interface

+ EnterAccess func(c *AccessContext)

+ EnterAccessExpression func(c *AccessExpressionContext)

+ EnterAdditiveExpression func(c *AdditiveExpressionContext)

+ EnterAdditiveOp func(c *AdditiveOpContext)

+ EnterAndExpression func(c *AndExpressionContext)

+ EnterArgument func(c *ArgumentContext)

+ EnterArrayLiteral func(c *ArrayLiteralContext)

+ EnterAssignment func(c *AssignmentContext)

+ EnterBaseType func(c *BaseTypeContext)

+ EnterBinaryLiteral func(c *BinaryLiteralContext)

+ EnterBlock func(c *BlockContext)

+ EnterBooleanLiteral func(c *BooleanLiteralContext)

+ EnterBracketExpression func(c *BracketExpressionContext)

+ EnterBreakStatement func(c *BreakStatementContext)

+ EnterCastingExpression func(c *CastingExpressionContext)

+ EnterCastingOp func(c *CastingOpContext)

+ EnterCompositeDeclaration func(c *CompositeDeclarationContext)

+ EnterCompositeKind func(c *CompositeKindContext)

+ EnterConcatenatingExpression func(c *ConcatenatingExpressionContext)

+ EnterCondition func(c *ConditionContext)

+ EnterConditionalExpression func(c *ConditionalExpressionContext)

+ EnterConditions func(c *ConditionsContext)

+ EnterConformances func(c *ConformancesContext)

+ EnterConstantSizedType func(c *ConstantSizedTypeContext)

+ EnterContinueStatement func(c *ContinueStatementContext)

+ EnterCreateExpression func(c *CreateExpressionContext)

+ EnterDecimalLiteral func(c *DecimalLiteralContext)

+ EnterDeclaration func(c *DeclarationContext)

+ EnterDestroyExpression func(c *DestroyExpressionContext)

+ EnterDictionaryEntry func(c *DictionaryEntryContext)

+ EnterDictionaryLiteral func(c *DictionaryLiteralContext)

+ EnterDictionaryType func(c *DictionaryTypeContext)

+ EnterEmitStatement func(c *EmitStatementContext)

+ EnterEos func(c *EosContext)

+ EnterEqualityExpression func(c *EqualityExpressionContext)

+ EnterEqualityOp func(c *EqualityOpContext)

+ EnterEventDeclaration func(c *EventDeclarationContext)

+ EnterExecute func(c *ExecuteContext)

+ EnterExpression func(c *ExpressionContext)

+ EnterExpressionAccess func(c *ExpressionAccessContext)

+ EnterField func(c *FieldContext)

+ EnterFields func(c *FieldsContext)

+ EnterFixedPointLiteral func(c *FixedPointLiteralContext)

+ EnterForStatement func(c *ForStatementContext)

+ EnterForceExpression func(c *ForceExpressionContext)

+ EnterFullType func(c *FullTypeContext)

+ EnterFunctionBlock func(c *FunctionBlockContext)

+ EnterFunctionDeclaration func(c *FunctionDeclarationContext)

+ EnterFunctionExpression func(c *FunctionExpressionContext)

+ EnterFunctionType func(c *FunctionTypeContext)

+ EnterHexadecimalLiteral func(c *HexadecimalLiteralContext)

+ EnterIdentifier func(c *IdentifierContext)

+ EnterIdentifierExpression func(c *IdentifierExpressionContext)

+ EnterIfStatement func(c *IfStatementContext)

+ EnterImportDeclaration func(c *ImportDeclarationContext)

+ EnterInnerType func(c *InnerTypeContext)

+ EnterIntegerLiteral func(c *IntegerLiteralContext)

+ EnterInterfaceDeclaration func(c *InterfaceDeclarationContext)

+ EnterInvalidNumberLiteral func(c *InvalidNumberLiteralContext)

+ EnterInvocation func(c *InvocationContext)

+ EnterInvocationExpression func(c *InvocationExpressionContext)

+ EnterLiteral func(c *LiteralContext)

+ EnterLiteralExpression func(c *LiteralExpressionContext)

+ EnterMemberAccess func(c *MemberAccessContext)

+ EnterMemberOrNestedDeclaration func(c *MemberOrNestedDeclarationContext)

+ EnterMembersAndNestedDeclarations func(c *MembersAndNestedDeclarationsContext)

+ EnterMultiplicativeExpression func(c *MultiplicativeExpressionContext)

+ EnterMultiplicativeOp func(c *MultiplicativeOpContext)

+ EnterNestedExpression func(c *NestedExpressionContext)

+ EnterNilCoalescingExpression func(c *NilCoalescingExpressionContext)

+ EnterNilLiteral func(c *NilLiteralContext)

+ EnterNominalType func(c *NominalTypeContext)

+ EnterOctalLiteral func(c *OctalLiteralContext)

+ EnterOrExpression func(c *OrExpressionContext)

+ EnterParameter func(c *ParameterContext)

+ EnterParameterList func(c *ParameterListContext)

+ EnterPathLiteral func(c *PathLiteralContext)

+ EnterPostConditions func(c *PostConditionsContext)

+ EnterPreConditions func(c *PreConditionsContext)

+ EnterPrepare func(c *PrepareContext)

+ EnterPrimaryExpression func(c *PrimaryExpressionContext)

+ EnterProgram func(c *ProgramContext)

+ EnterReferenceExpression func(c *ReferenceExpressionContext)

+ EnterRelationalExpression func(c *RelationalExpressionContext)

+ EnterRelationalOp func(c *RelationalOpContext)

+ EnterReplDeclaration func(c *ReplDeclarationContext)

+ EnterReplElement func(c *ReplElementContext)

+ EnterReplInput func(c *ReplInputContext)

+ EnterReplStatement func(c *ReplStatementContext)

+ EnterReturnStatement func(c *ReturnStatementContext)

+ EnterSpecialFunctionDeclaration func(c *SpecialFunctionDeclarationContext)

+ EnterStatement func(c *StatementContext)

+ EnterStatements func(c *StatementsContext)

+ EnterStringLiteral func(c *StringLiteralContext)

+ EnterSwap func(c *SwapContext)

+ EnterTransactionDeclaration func(c *TransactionDeclarationContext)

+ EnterTransfer func(c *TransferContext)

+ EnterTypeAnnotation func(c *TypeAnnotationContext)

+ EnterTypeRestrictions func(c *TypeRestrictionsContext)

+ EnterUnaryExpression func(c *UnaryExpressionContext)

+ EnterUnaryOp func(c *UnaryOpContext)

+ EnterVariableDeclaration func(c *VariableDeclarationContext)

+ EnterVariableKind func(c *VariableKindContext)

+ EnterVariableSizedType func(c *VariableSizedTypeContext)

+ EnterWhileStatement func(c *WhileStatementContext)

+ ExitAccess func(c *AccessContext)

+ ExitAccessExpression func(c *AccessExpressionContext)

+ ExitAdditiveExpression func(c *AdditiveExpressionContext)

+ ExitAdditiveOp func(c *AdditiveOpContext)

+ ExitAndExpression func(c *AndExpressionContext)

+ ExitArgument func(c *ArgumentContext)

+ ExitArrayLiteral func(c *ArrayLiteralContext)

+ ExitAssignment func(c *AssignmentContext)

+ ExitBaseType func(c *BaseTypeContext)

+ ExitBinaryLiteral func(c *BinaryLiteralContext)

+ ExitBlock func(c *BlockContext)

+ ExitBooleanLiteral func(c *BooleanLiteralContext)

+ ExitBracketExpression func(c *BracketExpressionContext)

+ ExitBreakStatement func(c *BreakStatementContext)

+ ExitCastingExpression func(c *CastingExpressionContext)

+ ExitCastingOp func(c *CastingOpContext)

+ ExitCompositeDeclaration func(c *CompositeDeclarationContext)

+ ExitCompositeKind func(c *CompositeKindContext)

+ ExitConcatenatingExpression func(c *ConcatenatingExpressionContext)

+ ExitCondition func(c *ConditionContext)

+ ExitConditionalExpression func(c *ConditionalExpressionContext)

+ ExitConditions func(c *ConditionsContext)

+ ExitConformances func(c *ConformancesContext)

+ ExitConstantSizedType func(c *ConstantSizedTypeContext)

+ ExitContinueStatement func(c *ContinueStatementContext)

+ ExitCreateExpression func(c *CreateExpressionContext)

+ ExitDecimalLiteral func(c *DecimalLiteralContext)

+ ExitDeclaration func(c *DeclarationContext)

+ ExitDestroyExpression func(c *DestroyExpressionContext)

+ ExitDictionaryEntry func(c *DictionaryEntryContext)

+ ExitDictionaryLiteral func(c *DictionaryLiteralContext)

+ ExitDictionaryType func(c *DictionaryTypeContext)

+ ExitEmitStatement func(c *EmitStatementContext)

+ ExitEos func(c *EosContext)

+ ExitEqualityExpression func(c *EqualityExpressionContext)

+ ExitEqualityOp func(c *EqualityOpContext)

+ ExitEventDeclaration func(c *EventDeclarationContext)

+ ExitExecute func(c *ExecuteContext)

+ ExitExpression func(c *ExpressionContext)

+ ExitExpressionAccess func(c *ExpressionAccessContext)

+ ExitField func(c *FieldContext)

+ ExitFields func(c *FieldsContext)

+ ExitFixedPointLiteral func(c *FixedPointLiteralContext)

+ ExitForStatement func(c *ForStatementContext)

+ ExitForceExpression func(c *ForceExpressionContext)

+ ExitFullType func(c *FullTypeContext)

+ ExitFunctionBlock func(c *FunctionBlockContext)

+ ExitFunctionDeclaration func(c *FunctionDeclarationContext)

+ ExitFunctionExpression func(c *FunctionExpressionContext)

+ ExitFunctionType func(c *FunctionTypeContext)

+ ExitHexadecimalLiteral func(c *HexadecimalLiteralContext)

+ ExitIdentifier func(c *IdentifierContext)

+ ExitIdentifierExpression func(c *IdentifierExpressionContext)

+ ExitIfStatement func(c *IfStatementContext)

+ ExitImportDeclaration func(c *ImportDeclarationContext)

+ ExitInnerType func(c *InnerTypeContext)

+ ExitIntegerLiteral func(c *IntegerLiteralContext)

+ ExitInterfaceDeclaration func(c *InterfaceDeclarationContext)

+ ExitInvalidNumberLiteral func(c *InvalidNumberLiteralContext)

+ ExitInvocation func(c *InvocationContext)

+ ExitInvocationExpression func(c *InvocationExpressionContext)

+ ExitLiteral func(c *LiteralContext)

+ ExitLiteralExpression func(c *LiteralExpressionContext)

+ ExitMemberAccess func(c *MemberAccessContext)

+ ExitMemberOrNestedDeclaration func(c *MemberOrNestedDeclarationContext)

+ ExitMembersAndNestedDeclarations func(c *MembersAndNestedDeclarationsContext)

+ ExitMultiplicativeExpression func(c *MultiplicativeExpressionContext)

+ ExitMultiplicativeOp func(c *MultiplicativeOpContext)

+ ExitNestedExpression func(c *NestedExpressionContext)

+ ExitNilCoalescingExpression func(c *NilCoalescingExpressionContext)

+ ExitNilLiteral func(c *NilLiteralContext)

+ ExitNominalType func(c *NominalTypeContext)

+ ExitOctalLiteral func(c *OctalLiteralContext)

+ ExitOrExpression func(c *OrExpressionContext)

+ ExitParameter func(c *ParameterContext)

+ ExitParameterList func(c *ParameterListContext)

+ ExitPathLiteral func(c *PathLiteralContext)

+ ExitPostConditions func(c *PostConditionsContext)

+ ExitPreConditions func(c *PreConditionsContext)

+ ExitPrepare func(c *PrepareContext)

+ ExitPrimaryExpression func(c *PrimaryExpressionContext)

+ ExitProgram func(c *ProgramContext)

+ ExitReferenceExpression func(c *ReferenceExpressionContext)

+ ExitRelationalExpression func(c *RelationalExpressionContext)

+ ExitRelationalOp func(c *RelationalOpContext)

+ ExitReplDeclaration func(c *ReplDeclarationContext)

+ ExitReplElement func(c *ReplElementContext)

+ ExitReplInput func(c *ReplInputContext)

+ ExitReplStatement func(c *ReplStatementContext)

+ ExitReturnStatement func(c *ReturnStatementContext)

+ ExitSpecialFunctionDeclaration func(c *SpecialFunctionDeclarationContext)

+ ExitStatement func(c *StatementContext)

+ ExitStatements func(c *StatementsContext)

+ ExitStringLiteral func(c *StringLiteralContext)

+ ExitSwap func(c *SwapContext)

+ ExitTransactionDeclaration func(c *TransactionDeclarationContext)

+ ExitTransfer func(c *TransferContext)

+ ExitTypeAnnotation func(c *TypeAnnotationContext)

+ ExitTypeRestrictions func(c *TypeRestrictionsContext)

+ ExitUnaryExpression func(c *UnaryExpressionContext)

+ ExitUnaryOp func(c *UnaryOpContext)

+ ExitVariableDeclaration func(c *VariableDeclarationContext)

+ ExitVariableKind func(c *VariableKindContext)

+ ExitVariableSizedType func(c *VariableSizedTypeContext)

+ ExitWhileStatement func(c *WhileStatementContext)

+ type CadenceParser struct

+ func NewCadenceParser(input antlr.TokenStream) *CadenceParser

+ func (p *CadenceParser) Access() (localctx IAccessContext)

+ func (p *CadenceParser) AdditiveExpression() (localctx IAdditiveExpressionContext)

+ func (p *CadenceParser) AdditiveExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) AdditiveOp() (localctx IAdditiveOpContext)

+ func (p *CadenceParser) AndExpression() (localctx IAndExpressionContext)

+ func (p *CadenceParser) AndExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) Argument() (localctx IArgumentContext)

+ func (p *CadenceParser) ArrayLiteral() (localctx IArrayLiteralContext)

+ func (p *CadenceParser) Assignment() (localctx IAssignmentContext)

+ func (p *CadenceParser) BaseType() (localctx IBaseTypeContext)

+ func (p *CadenceParser) Block() (localctx IBlockContext)

+ func (p *CadenceParser) BooleanLiteral() (localctx IBooleanLiteralContext)

+ func (p *CadenceParser) BracketExpression() (localctx IBracketExpressionContext)

+ func (p *CadenceParser) BreakStatement() (localctx IBreakStatementContext)

+ func (p *CadenceParser) CastingExpression() (localctx ICastingExpressionContext)

+ func (p *CadenceParser) CastingExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) CastingOp() (localctx ICastingOpContext)

+ func (p *CadenceParser) CompositeDeclaration() (localctx ICompositeDeclarationContext)

+ func (p *CadenceParser) CompositeKind() (localctx ICompositeKindContext)

+ func (p *CadenceParser) ConcatenatingExpression() (localctx IConcatenatingExpressionContext)

+ func (p *CadenceParser) ConcatenatingExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) Condition() (localctx IConditionContext)

+ func (p *CadenceParser) ConditionalExpression() (localctx IConditionalExpressionContext)

+ func (p *CadenceParser) Conditions() (localctx IConditionsContext)

+ func (p *CadenceParser) Conformances() (localctx IConformancesContext)

+ func (p *CadenceParser) ConstantSizedType() (localctx IConstantSizedTypeContext)

+ func (p *CadenceParser) ContinueStatement() (localctx IContinueStatementContext)

+ func (p *CadenceParser) CreateExpression() (localctx ICreateExpressionContext)

+ func (p *CadenceParser) Declaration() (localctx IDeclarationContext)

+ func (p *CadenceParser) DestroyExpression() (localctx IDestroyExpressionContext)

+ func (p *CadenceParser) DictionaryEntry() (localctx IDictionaryEntryContext)

+ func (p *CadenceParser) DictionaryLiteral() (localctx IDictionaryLiteralContext)

+ func (p *CadenceParser) DictionaryType() (localctx IDictionaryTypeContext)

+ func (p *CadenceParser) EmitStatement() (localctx IEmitStatementContext)

+ func (p *CadenceParser) Eos() (localctx IEosContext)

+ func (p *CadenceParser) Eos_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) EqualityExpression() (localctx IEqualityExpressionContext)

+ func (p *CadenceParser) EqualityExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) EqualityOp() (localctx IEqualityOpContext)

+ func (p *CadenceParser) EventDeclaration() (localctx IEventDeclarationContext)

+ func (p *CadenceParser) Execute() (localctx IExecuteContext)

+ func (p *CadenceParser) Expression() (localctx IExpressionContext)

+ func (p *CadenceParser) ExpressionAccess() (localctx IExpressionAccessContext)

+ func (p *CadenceParser) ExpressionAccess_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) Field() (localctx IFieldContext)

+ func (p *CadenceParser) Fields() (localctx IFieldsContext)

+ func (p *CadenceParser) FixedPointLiteral() (localctx IFixedPointLiteralContext)

+ func (p *CadenceParser) ForStatement() (localctx IForStatementContext)

+ func (p *CadenceParser) FullType() (localctx IFullTypeContext)

+ func (p *CadenceParser) FullType_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) FunctionBlock() (localctx IFunctionBlockContext)

+ func (p *CadenceParser) FunctionDeclaration() (localctx IFunctionDeclarationContext)

+ func (p *CadenceParser) FunctionType() (localctx IFunctionTypeContext)

+ func (p *CadenceParser) Identifier() (localctx IIdentifierContext)

+ func (p *CadenceParser) IfStatement() (localctx IIfStatementContext)

+ func (p *CadenceParser) ImportDeclaration() (localctx IImportDeclarationContext)

+ func (p *CadenceParser) InnerType() (localctx IInnerTypeContext)

+ func (p *CadenceParser) InnerType_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) IntegerLiteral() (localctx IIntegerLiteralContext)

+ func (p *CadenceParser) InterfaceDeclaration() (localctx IInterfaceDeclarationContext)

+ func (p *CadenceParser) Invocation() (localctx IInvocationContext)

+ func (p *CadenceParser) Literal() (localctx ILiteralContext)

+ func (p *CadenceParser) MemberAccess() (localctx IMemberAccessContext)

+ func (p *CadenceParser) MemberOrNestedDeclaration() (localctx IMemberOrNestedDeclarationContext)

+ func (p *CadenceParser) MembersAndNestedDeclarations() (localctx IMembersAndNestedDeclarationsContext)

+ func (p *CadenceParser) MultiplicativeExpression() (localctx IMultiplicativeExpressionContext)

+ func (p *CadenceParser) MultiplicativeExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) MultiplicativeOp() (localctx IMultiplicativeOpContext)

+ func (p *CadenceParser) NilCoalescingExpression() (localctx INilCoalescingExpressionContext)

+ func (p *CadenceParser) NilLiteral() (localctx INilLiteralContext)

+ func (p *CadenceParser) NominalType() (localctx INominalTypeContext)

+ func (p *CadenceParser) OrExpression() (localctx IOrExpressionContext)

+ func (p *CadenceParser) OrExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) Parameter() (localctx IParameterContext)

+ func (p *CadenceParser) ParameterList() (localctx IParameterListContext)

+ func (p *CadenceParser) PathLiteral() (localctx IPathLiteralContext)

+ func (p *CadenceParser) PathLiteral_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) PositiveIntegerLiteral() (localctx IPositiveIntegerLiteralContext)

+ func (p *CadenceParser) PostConditions() (localctx IPostConditionsContext)

+ func (p *CadenceParser) PostfixExpression() (localctx IPostfixExpressionContext)

+ func (p *CadenceParser) PostfixExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) PreConditions() (localctx IPreConditionsContext)

+ func (p *CadenceParser) Prepare() (localctx IPrepareContext)

+ func (p *CadenceParser) PrimaryExpression() (localctx IPrimaryExpressionContext)

+ func (p *CadenceParser) Program() (localctx IProgramContext)

+ func (p *CadenceParser) ReferenceExpression() (localctx IReferenceExpressionContext)

+ func (p *CadenceParser) RelationalExpression() (localctx IRelationalExpressionContext)

+ func (p *CadenceParser) RelationalExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *CadenceParser) RelationalOp() (localctx IRelationalOpContext)

+ func (p *CadenceParser) ReplDeclaration() (localctx IReplDeclarationContext)

+ func (p *CadenceParser) ReplElement() (localctx IReplElementContext)

+ func (p *CadenceParser) ReplInput() (localctx IReplInputContext)

+ func (p *CadenceParser) ReplStatement() (localctx IReplStatementContext)

+ func (p *CadenceParser) ReturnStatement() (localctx IReturnStatementContext)

+ func (p *CadenceParser) ReturnStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool

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

+ func (p *CadenceParser) SpecialFunctionDeclaration() (localctx ISpecialFunctionDeclarationContext)

+ func (p *CadenceParser) Statement() (localctx IStatementContext)

+ func (p *CadenceParser) Statements() (localctx IStatementsContext)

+ func (p *CadenceParser) StringLiteral() (localctx IStringLiteralContext)

+ func (p *CadenceParser) Swap() (localctx ISwapContext)

+ func (p *CadenceParser) TransactionDeclaration() (localctx ITransactionDeclarationContext)

+ func (p *CadenceParser) Transfer() (localctx ITransferContext)

+ func (p *CadenceParser) TypeAnnotation() (localctx ITypeAnnotationContext)

+ func (p *CadenceParser) TypeRestrictions() (localctx ITypeRestrictionsContext)

+ func (p *CadenceParser) UnaryExpression() (localctx IUnaryExpressionContext)

+ func (p *CadenceParser) UnaryOp() (localctx IUnaryOpContext)

+ func (p *CadenceParser) VariableDeclaration() (localctx IVariableDeclarationContext)

+ func (p *CadenceParser) VariableKind() (localctx IVariableKindContext)

+ func (p *CadenceParser) VariableSizedType() (localctx IVariableSizedTypeContext)

+ func (p *CadenceParser) WhileStatement() (localctx IWhileStatementContext)

+ type CadenceVisitor interface

+ VisitAccess func(ctx *AccessContext) interface{}

+ VisitAccessExpression func(ctx *AccessExpressionContext) interface{}

+ VisitAdditiveExpression func(ctx *AdditiveExpressionContext) interface{}

+ VisitAdditiveOp func(ctx *AdditiveOpContext) interface{}

+ VisitAndExpression func(ctx *AndExpressionContext) interface{}

+ VisitArgument func(ctx *ArgumentContext) interface{}

+ VisitArrayLiteral func(ctx *ArrayLiteralContext) interface{}

+ VisitAssignment func(ctx *AssignmentContext) interface{}

+ VisitBaseType func(ctx *BaseTypeContext) interface{}

+ VisitBinaryLiteral func(ctx *BinaryLiteralContext) interface{}

+ VisitBlock func(ctx *BlockContext) interface{}

+ VisitBooleanLiteral func(ctx *BooleanLiteralContext) interface{}

+ VisitBracketExpression func(ctx *BracketExpressionContext) interface{}

+ VisitBreakStatement func(ctx *BreakStatementContext) interface{}

+ VisitCastingExpression func(ctx *CastingExpressionContext) interface{}

+ VisitCastingOp func(ctx *CastingOpContext) interface{}

+ VisitCompositeDeclaration func(ctx *CompositeDeclarationContext) interface{}

+ VisitCompositeKind func(ctx *CompositeKindContext) interface{}

+ VisitConcatenatingExpression func(ctx *ConcatenatingExpressionContext) interface{}

+ VisitCondition func(ctx *ConditionContext) interface{}

+ VisitConditionalExpression func(ctx *ConditionalExpressionContext) interface{}

+ VisitConditions func(ctx *ConditionsContext) interface{}

+ VisitConformances func(ctx *ConformancesContext) interface{}

+ VisitConstantSizedType func(ctx *ConstantSizedTypeContext) interface{}

+ VisitContinueStatement func(ctx *ContinueStatementContext) interface{}

+ VisitCreateExpression func(ctx *CreateExpressionContext) interface{}

+ VisitDecimalLiteral func(ctx *DecimalLiteralContext) interface{}

+ VisitDeclaration func(ctx *DeclarationContext) interface{}

+ VisitDestroyExpression func(ctx *DestroyExpressionContext) interface{}

+ VisitDictionaryEntry func(ctx *DictionaryEntryContext) interface{}

+ VisitDictionaryLiteral func(ctx *DictionaryLiteralContext) interface{}

+ VisitDictionaryType func(ctx *DictionaryTypeContext) interface{}

+ VisitEmitStatement func(ctx *EmitStatementContext) interface{}

+ VisitEos func(ctx *EosContext) interface{}

+ VisitEqualityExpression func(ctx *EqualityExpressionContext) interface{}

+ VisitEqualityOp func(ctx *EqualityOpContext) interface{}

+ VisitEventDeclaration func(ctx *EventDeclarationContext) interface{}

+ VisitExecute func(ctx *ExecuteContext) interface{}

+ VisitExpression func(ctx *ExpressionContext) interface{}

+ VisitExpressionAccess func(ctx *ExpressionAccessContext) interface{}

+ VisitField func(ctx *FieldContext) interface{}

+ VisitFields func(ctx *FieldsContext) interface{}

+ VisitFixedPointLiteral func(ctx *FixedPointLiteralContext) interface{}

+ VisitForStatement func(ctx *ForStatementContext) interface{}

+ VisitForceExpression func(ctx *ForceExpressionContext) interface{}

+ VisitFullType func(ctx *FullTypeContext) interface{}

+ VisitFunctionBlock func(ctx *FunctionBlockContext) interface{}

+ VisitFunctionDeclaration func(ctx *FunctionDeclarationContext) interface{}

+ VisitFunctionExpression func(ctx *FunctionExpressionContext) interface{}

+ VisitFunctionType func(ctx *FunctionTypeContext) interface{}

+ VisitHexadecimalLiteral func(ctx *HexadecimalLiteralContext) interface{}

+ VisitIdentifier func(ctx *IdentifierContext) interface{}

+ VisitIdentifierExpression func(ctx *IdentifierExpressionContext) interface{}

+ VisitIfStatement func(ctx *IfStatementContext) interface{}

+ VisitImportDeclaration func(ctx *ImportDeclarationContext) interface{}

+ VisitInnerType func(ctx *InnerTypeContext) interface{}

+ VisitIntegerLiteral func(ctx *IntegerLiteralContext) interface{}

+ VisitInterfaceDeclaration func(ctx *InterfaceDeclarationContext) interface{}

+ VisitInvalidNumberLiteral func(ctx *InvalidNumberLiteralContext) interface{}

+ VisitInvocation func(ctx *InvocationContext) interface{}

+ VisitInvocationExpression func(ctx *InvocationExpressionContext) interface{}

+ VisitLiteral func(ctx *LiteralContext) interface{}

+ VisitLiteralExpression func(ctx *LiteralExpressionContext) interface{}

+ VisitMemberAccess func(ctx *MemberAccessContext) interface{}

+ VisitMemberOrNestedDeclaration func(ctx *MemberOrNestedDeclarationContext) interface{}

+ VisitMembersAndNestedDeclarations func(ctx *MembersAndNestedDeclarationsContext) interface{}

+ VisitMultiplicativeExpression func(ctx *MultiplicativeExpressionContext) interface{}

+ VisitMultiplicativeOp func(ctx *MultiplicativeOpContext) interface{}

+ VisitNestedExpression func(ctx *NestedExpressionContext) interface{}

+ VisitNilCoalescingExpression func(ctx *NilCoalescingExpressionContext) interface{}

+ VisitNilLiteral func(ctx *NilLiteralContext) interface{}

+ VisitNominalType func(ctx *NominalTypeContext) interface{}

+ VisitOctalLiteral func(ctx *OctalLiteralContext) interface{}

+ VisitOrExpression func(ctx *OrExpressionContext) interface{}

+ VisitParameter func(ctx *ParameterContext) interface{}

+ VisitParameterList func(ctx *ParameterListContext) interface{}

+ VisitPathLiteral func(ctx *PathLiteralContext) interface{}

+ VisitPostConditions func(ctx *PostConditionsContext) interface{}

+ VisitPreConditions func(ctx *PreConditionsContext) interface{}

+ VisitPrepare func(ctx *PrepareContext) interface{}

+ VisitPrimaryExpression func(ctx *PrimaryExpressionContext) interface{}

+ VisitProgram func(ctx *ProgramContext) interface{}

+ VisitReferenceExpression func(ctx *ReferenceExpressionContext) interface{}

+ VisitRelationalExpression func(ctx *RelationalExpressionContext) interface{}

+ VisitRelationalOp func(ctx *RelationalOpContext) interface{}

+ VisitReplDeclaration func(ctx *ReplDeclarationContext) interface{}

+ VisitReplElement func(ctx *ReplElementContext) interface{}

+ VisitReplInput func(ctx *ReplInputContext) interface{}

+ VisitReplStatement func(ctx *ReplStatementContext) interface{}

+ VisitReturnStatement func(ctx *ReturnStatementContext) interface{}

+ VisitSpecialFunctionDeclaration func(ctx *SpecialFunctionDeclarationContext) interface{}

+ VisitStatement func(ctx *StatementContext) interface{}

+ VisitStatements func(ctx *StatementsContext) interface{}

+ VisitStringLiteral func(ctx *StringLiteralContext) interface{}

+ VisitSwap func(ctx *SwapContext) interface{}

+ VisitTransactionDeclaration func(ctx *TransactionDeclarationContext) interface{}

+ VisitTransfer func(ctx *TransferContext) interface{}

+ VisitTypeAnnotation func(ctx *TypeAnnotationContext) interface{}

+ VisitTypeRestrictions func(ctx *TypeRestrictionsContext) interface{}

+ VisitUnaryExpression func(ctx *UnaryExpressionContext) interface{}

+ VisitUnaryOp func(ctx *UnaryOpContext) interface{}

+ VisitVariableDeclaration func(ctx *VariableDeclarationContext) interface{}

+ VisitVariableKind func(ctx *VariableKindContext) interface{}

+ VisitVariableSizedType func(ctx *VariableSizedTypeContext) interface{}

+ VisitWhileStatement func(ctx *WhileStatementContext) interface{}

+ type CastingExpressionContext struct

+ func NewCastingExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CastingExpressionContext

+ func NewEmptyCastingExpressionContext() *CastingExpressionContext

+ func (*CastingExpressionContext) IsCastingExpressionContext()

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

+ func (s *CastingExpressionContext) CastingExpression() ICastingExpressionContext

+ func (s *CastingExpressionContext) CastingOp() ICastingOpContext

+ func (s *CastingExpressionContext) ConcatenatingExpression() IConcatenatingExpressionContext

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

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

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

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

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

+ func (s *CastingExpressionContext) TypeAnnotation() ITypeAnnotationContext

+ type CastingOpContext struct

+ func NewCastingOpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CastingOpContext

+ func NewEmptyCastingOpContext() *CastingOpContext

+ func (*CastingOpContext) IsCastingOpContext()

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

+ func (s *CastingOpContext) Casting() antlr.TerminalNode

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

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

+ func (s *CastingOpContext) FailableCasting() antlr.TerminalNode

+ func (s *CastingOpContext) ForceCasting() antlr.TerminalNode

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

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

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

+ type CompositeDeclarationContext struct

+ func NewCompositeDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompositeDeclarationContext

+ func NewEmptyCompositeDeclarationContext() *CompositeDeclarationContext

+ func (*CompositeDeclarationContext) IsCompositeDeclarationContext()

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

+ func (s *CompositeDeclarationContext) Access() IAccessContext

+ func (s *CompositeDeclarationContext) CompositeKind() ICompositeKindContext

+ func (s *CompositeDeclarationContext) Conformances() IConformancesContext

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

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

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

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

+ func (s *CompositeDeclarationContext) Identifier() IIdentifierContext

+ func (s *CompositeDeclarationContext) MembersAndNestedDeclarations() IMembersAndNestedDeclarationsContext

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

+ type CompositeKindContext struct

+ func NewCompositeKindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompositeKindContext

+ func NewEmptyCompositeKindContext() *CompositeKindContext

+ func (*CompositeKindContext) IsCompositeKindContext()

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

+ func (s *CompositeKindContext) Contract() antlr.TerminalNode

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

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

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

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

+ func (s *CompositeKindContext) Resource() antlr.TerminalNode

+ func (s *CompositeKindContext) Struct() antlr.TerminalNode

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

+ type ConcatenatingExpressionContext struct

+ func NewConcatenatingExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConcatenatingExpressionContext

+ func NewEmptyConcatenatingExpressionContext() *ConcatenatingExpressionContext

+ func (*ConcatenatingExpressionContext) IsConcatenatingExpressionContext()

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

+ func (s *ConcatenatingExpressionContext) AdditiveExpression() IAdditiveExpressionContext

+ func (s *ConcatenatingExpressionContext) Ampersand() antlr.TerminalNode

+ func (s *ConcatenatingExpressionContext) ConcatenatingExpression() IConcatenatingExpressionContext

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

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

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

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

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

+ type ConditionContext struct

+ func NewConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionContext

+ func NewEmptyConditionContext() *ConditionContext

+ func (*ConditionContext) IsConditionContext()

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

+ func (s *ConditionContext) AllExpression() []IExpressionContext

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

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

+ func (s *ConditionContext) Expression(i int) IExpressionContext

+ func (s *ConditionContext) GetMessage() IExpressionContext

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

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

+ func (s *ConditionContext) GetTest() IExpressionContext

+ func (s *ConditionContext) SetMessage(v IExpressionContext)

+ func (s *ConditionContext) SetTest(v IExpressionContext)

+ func (s *ConditionContext) 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) AllExpression() []IExpressionContext

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

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

+ func (s *ConditionalExpressionContext) Expression(i int) IExpressionContext

+ func (s *ConditionalExpressionContext) GetAlt() IExpressionContext

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

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

+ func (s *ConditionalExpressionContext) GetThen() IExpressionContext

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

+ func (s *ConditionalExpressionContext) OrExpression() IOrExpressionContext

+ func (s *ConditionalExpressionContext) SetAlt(v IExpressionContext)

+ func (s *ConditionalExpressionContext) SetThen(v IExpressionContext)

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

+ type ConditionsContext struct

+ func NewConditionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionsContext

+ func NewEmptyConditionsContext() *ConditionsContext

+ func (*ConditionsContext) IsConditionsContext()

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

+ func (s *ConditionsContext) AllCondition() []IConditionContext

+ func (s *ConditionsContext) AllEos() []IEosContext

+ func (s *ConditionsContext) Condition(i int) IConditionContext

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

+ func (s *ConditionsContext) Eos(i int) IEosContext

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

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

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

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

+ type ConformancesContext struct

+ func NewConformancesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConformancesContext

+ func NewEmptyConformancesContext() *ConformancesContext

+ func (*ConformancesContext) IsConformancesContext()

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

+ func (s *ConformancesContext) AllNominalType() []INominalTypeContext

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

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

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

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

+ func (s *ConformancesContext) NominalType(i int) INominalTypeContext

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

+ type ConstantSizedTypeContext struct

+ func NewConstantSizedTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantSizedTypeContext

+ func NewEmptyConstantSizedTypeContext() *ConstantSizedTypeContext

+ func (*ConstantSizedTypeContext) IsConstantSizedTypeContext()

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

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

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

+ func (s *ConstantSizedTypeContext) FullType() IFullTypeContext

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

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

+ func (s *ConstantSizedTypeContext) GetSize() IIntegerLiteralContext

+ func (s *ConstantSizedTypeContext) IntegerLiteral() IIntegerLiteralContext

+ func (s *ConstantSizedTypeContext) SetSize(v IIntegerLiteralContext)

+ func (s *ConstantSizedTypeContext) 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) EnterRule(listener antlr.ParseTreeListener)

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

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

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

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

+ type CreateExpressionContext struct

+ func NewCreateExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateExpressionContext

+ func NewEmptyCreateExpressionContext() *CreateExpressionContext

+ func (*CreateExpressionContext) IsCreateExpressionContext()

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

+ func (s *CreateExpressionContext) Create() antlr.TerminalNode

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

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

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

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

+ func (s *CreateExpressionContext) Invocation() IInvocationContext

+ func (s *CreateExpressionContext) NominalType() INominalTypeContext

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

+ type DecimalLiteralContext struct

+ func NewDecimalLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DecimalLiteralContext

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

+ func (s *DecimalLiteralContext) DecimalLiteral() antlr.TerminalNode

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

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

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

+ type DeclarationContext struct

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

+ func NewEmptyDeclarationContext() *DeclarationContext

+ func (*DeclarationContext) IsDeclarationContext()

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

+ func (s *DeclarationContext) CompositeDeclaration() ICompositeDeclarationContext

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

+ func (s *DeclarationContext) EventDeclaration() IEventDeclarationContext

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

+ func (s *DeclarationContext) FunctionDeclaration() IFunctionDeclarationContext

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

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

+ func (s *DeclarationContext) ImportDeclaration() IImportDeclarationContext

+ func (s *DeclarationContext) InterfaceDeclaration() IInterfaceDeclarationContext

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

+ func (s *DeclarationContext) TransactionDeclaration() ITransactionDeclarationContext

+ func (s *DeclarationContext) VariableDeclaration() IVariableDeclarationContext

+ type DestroyExpressionContext struct

+ func NewDestroyExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DestroyExpressionContext

+ func NewEmptyDestroyExpressionContext() *DestroyExpressionContext

+ func (*DestroyExpressionContext) IsDestroyExpressionContext()

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

+ func (s *DestroyExpressionContext) Destroy() antlr.TerminalNode

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

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

+ func (s *DestroyExpressionContext) Expression() IExpressionContext

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

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

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

+ type DictionaryEntryContext struct

+ func NewDictionaryEntryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DictionaryEntryContext

+ func NewEmptyDictionaryEntryContext() *DictionaryEntryContext

+ func (*DictionaryEntryContext) IsDictionaryEntryContext()

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

+ func (s *DictionaryEntryContext) AllExpression() []IExpressionContext

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

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

+ func (s *DictionaryEntryContext) Expression(i int) IExpressionContext

+ func (s *DictionaryEntryContext) GetKey() IExpressionContext

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

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

+ func (s *DictionaryEntryContext) GetValue() IExpressionContext

+ func (s *DictionaryEntryContext) SetKey(v IExpressionContext)

+ func (s *DictionaryEntryContext) SetValue(v IExpressionContext)

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

+ type DictionaryLiteralContext struct

+ func NewDictionaryLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DictionaryLiteralContext

+ func NewEmptyDictionaryLiteralContext() *DictionaryLiteralContext

+ func (*DictionaryLiteralContext) IsDictionaryLiteralContext()

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

+ func (s *DictionaryLiteralContext) AllDictionaryEntry() []IDictionaryEntryContext

+ func (s *DictionaryLiteralContext) DictionaryEntry(i int) IDictionaryEntryContext

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

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

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

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

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

+ type DictionaryTypeContext struct

+ func NewDictionaryTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DictionaryTypeContext

+ func NewEmptyDictionaryTypeContext() *DictionaryTypeContext

+ func (*DictionaryTypeContext) IsDictionaryTypeContext()

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

+ func (s *DictionaryTypeContext) AllFullType() []IFullTypeContext

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

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

+ func (s *DictionaryTypeContext) FullType(i int) IFullTypeContext

+ func (s *DictionaryTypeContext) GetKeyType() IFullTypeContext

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

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

+ func (s *DictionaryTypeContext) GetValueType() IFullTypeContext

+ func (s *DictionaryTypeContext) SetKeyType(v IFullTypeContext)

+ func (s *DictionaryTypeContext) SetValueType(v IFullTypeContext)

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

+ type EmitStatementContext struct

+ func NewEmitStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EmitStatementContext

+ func NewEmptyEmitStatementContext() *EmitStatementContext

+ func (*EmitStatementContext) IsEmitStatementContext()

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

+ func (s *EmitStatementContext) Emit() antlr.TerminalNode

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

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

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

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

+ func (s *EmitStatementContext) Identifier() IIdentifierContext

+ func (s *EmitStatementContext) Invocation() IInvocationContext

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

+ type EosContext struct

+ func NewEmptyEosContext() *EosContext

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

+ func (*EosContext) IsEosContext()

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

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

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

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

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

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

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

+ type EqualityExpressionContext struct

+ func NewEmptyEqualityExpressionContext() *EqualityExpressionContext

+ func NewEqualityExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EqualityExpressionContext

+ func (*EqualityExpressionContext) IsEqualityExpressionContext()

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

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

+ func (s *EqualityExpressionContext) EqualityExpression() IEqualityExpressionContext

+ func (s *EqualityExpressionContext) EqualityOp() IEqualityOpContext

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

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

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

+ func (s *EqualityExpressionContext) RelationalExpression() IRelationalExpressionContext

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

+ type EqualityOpContext struct

+ func NewEmptyEqualityOpContext() *EqualityOpContext

+ func NewEqualityOpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EqualityOpContext

+ func (*EqualityOpContext) IsEqualityOpContext()

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

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

+ func (s *EqualityOpContext) Equal() antlr.TerminalNode

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

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

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

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

+ func (s *EqualityOpContext) Unequal() antlr.TerminalNode

+ type Error struct

+ Errors []error

+ func (e Error) ChildErrors() []error

+ func (e Error) Error() string

+ type EventDeclarationContext struct

+ func NewEmptyEventDeclarationContext() *EventDeclarationContext

+ func NewEventDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EventDeclarationContext

+ func (*EventDeclarationContext) IsEventDeclarationContext()

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

+ func (s *EventDeclarationContext) Access() IAccessContext

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

+ func (s *EventDeclarationContext) Event() antlr.TerminalNode

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

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

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

+ func (s *EventDeclarationContext) Identifier() IIdentifierContext

+ func (s *EventDeclarationContext) ParameterList() IParameterListContext

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

+ type ExecuteContext struct

+ func NewEmptyExecuteContext() *ExecuteContext

+ func NewExecuteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExecuteContext

+ func (*ExecuteContext) IsExecuteContext()

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

+ func (s *ExecuteContext) Block() IBlockContext

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

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

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

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

+ func (s *ExecuteContext) Identifier() IIdentifierContext

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

+ type ExpressionAccessContext struct

+ func NewEmptyExpressionAccessContext() *ExpressionAccessContext

+ func NewExpressionAccessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionAccessContext

+ func (*ExpressionAccessContext) IsExpressionAccessContext()

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

+ func (s *ExpressionAccessContext) BracketExpression() IBracketExpressionContext

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

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

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

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

+ func (s *ExpressionAccessContext) MemberAccess() IMemberAccessContext

+ func (s *ExpressionAccessContext) 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) ConditionalExpression() IConditionalExpressionContext

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

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

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

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

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

+ type FieldContext struct

+ func NewEmptyFieldContext() *FieldContext

+ func NewFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldContext

+ func (*FieldContext) IsFieldContext()

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

+ func (s *FieldContext) Access() IAccessContext

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

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

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

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

+ func (s *FieldContext) Identifier() IIdentifierContext

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

+ func (s *FieldContext) TypeAnnotation() ITypeAnnotationContext

+ func (s *FieldContext) VariableKind() IVariableKindContext

+ type FieldsContext struct

+ func NewEmptyFieldsContext() *FieldsContext

+ func NewFieldsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldsContext

+ func (*FieldsContext) IsFieldsContext()

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

+ func (s *FieldsContext) AllField() []IFieldContext

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

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

+ func (s *FieldsContext) Field(i int) IFieldContext

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

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

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

+ type FixedPointLiteralContext struct

+ func NewEmptyFixedPointLiteralContext() *FixedPointLiteralContext

+ func NewFixedPointLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FixedPointLiteralContext

+ func (*FixedPointLiteralContext) IsFixedPointLiteralContext()

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

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

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

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

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

+ func (s *FixedPointLiteralContext) Minus() antlr.TerminalNode

+ func (s *FixedPointLiteralContext) PositiveFixedPointLiteral() antlr.TerminalNode

+ func (s *FixedPointLiteralContext) 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) EnterRule(listener antlr.ParseTreeListener)

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

+ func (s *ForStatementContext) Expression() IExpressionContext

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

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

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

+ func (s *ForStatementContext) Identifier() IIdentifierContext

+ func (s *ForStatementContext) In() antlr.TerminalNode

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

+ type ForceExpressionContext struct

+ func NewForceExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForceExpressionContext

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

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

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

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

+ func (s *ForceExpressionContext) Negate() antlr.TerminalNode

+ func (s *ForceExpressionContext) PostfixExpression() IPostfixExpressionContext

+ type FullTypeContext struct

+ func NewEmptyFullTypeContext() *FullTypeContext

+ func NewFullTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullTypeContext

+ func (*FullTypeContext) IsFullTypeContext()

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

+ func (s *FullTypeContext) AllOptional() []antlr.TerminalNode

+ func (s *FullTypeContext) Ampersand() antlr.TerminalNode

+ func (s *FullTypeContext) Auth() antlr.TerminalNode

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

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

+ func (s *FullTypeContext) GetOptionals() []antlr.Token

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

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

+ func (s *FullTypeContext) Get_Optional() antlr.Token

+ func (s *FullTypeContext) InnerType() IInnerTypeContext

+ func (s *FullTypeContext) Optional(i int) antlr.TerminalNode

+ func (s *FullTypeContext) SetOptionals(v []antlr.Token)

+ func (s *FullTypeContext) Set_Optional(v antlr.Token)

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

+ type FunctionBlockContext struct

+ func NewEmptyFunctionBlockContext() *FunctionBlockContext

+ func NewFunctionBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionBlockContext

+ func (*FunctionBlockContext) IsFunctionBlockContext()

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

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

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

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

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

+ func (s *FunctionBlockContext) PostConditions() IPostConditionsContext

+ func (s *FunctionBlockContext) PreConditions() IPreConditionsContext

+ func (s *FunctionBlockContext) Statements() IStatementsContext

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

+ 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) Access() IAccessContext

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

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

+ func (s *FunctionDeclarationContext) Fun() antlr.TerminalNode

+ func (s *FunctionDeclarationContext) FunctionBlock() IFunctionBlockContext

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

+ func (s *FunctionDeclarationContext) GetReturnType() ITypeAnnotationContext

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

+ func (s *FunctionDeclarationContext) Identifier() IIdentifierContext

+ func (s *FunctionDeclarationContext) ParameterList() IParameterListContext

+ func (s *FunctionDeclarationContext) SetReturnType(v ITypeAnnotationContext)

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

+ func (s *FunctionDeclarationContext) TypeAnnotation() ITypeAnnotationContext

+ type FunctionExpressionContext struct

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

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

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

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

+ func (s *FunctionExpressionContext) Fun() antlr.TerminalNode

+ func (s *FunctionExpressionContext) FunctionBlock() IFunctionBlockContext

+ func (s *FunctionExpressionContext) GetReturnType() ITypeAnnotationContext

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

+ func (s *FunctionExpressionContext) ParameterList() IParameterListContext

+ func (s *FunctionExpressionContext) SetReturnType(v ITypeAnnotationContext)

+ func (s *FunctionExpressionContext) TypeAnnotation() ITypeAnnotationContext

+ type FunctionTypeContext struct

+ func NewEmptyFunctionTypeContext() *FunctionTypeContext

+ func NewFunctionTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionTypeContext

+ func (*FunctionTypeContext) IsFunctionTypeContext()

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

+ func (s *FunctionTypeContext) AllCloseParen() []antlr.TerminalNode

+ func (s *FunctionTypeContext) AllOpenParen() []antlr.TerminalNode

+ func (s *FunctionTypeContext) AllTypeAnnotation() []ITypeAnnotationContext

+ func (s *FunctionTypeContext) CloseParen(i int) antlr.TerminalNode

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

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

+ func (s *FunctionTypeContext) GetParameterTypes() []ITypeAnnotationContext

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

+ func (s *FunctionTypeContext) GetReturnType() ITypeAnnotationContext

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

+ func (s *FunctionTypeContext) Get_typeAnnotation() ITypeAnnotationContext

+ func (s *FunctionTypeContext) OpenParen(i int) antlr.TerminalNode

+ func (s *FunctionTypeContext) SetParameterTypes(v []ITypeAnnotationContext)

+ func (s *FunctionTypeContext) SetReturnType(v ITypeAnnotationContext)

+ func (s *FunctionTypeContext) Set_typeAnnotation(v ITypeAnnotationContext)

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

+ func (s *FunctionTypeContext) TypeAnnotation(i int) ITypeAnnotationContext

+ type HexadecimalLiteralContext struct

+ func NewHexadecimalLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HexadecimalLiteralContext

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

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

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

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

+ func (s *HexadecimalLiteralContext) HexadecimalLiteral() antlr.TerminalNode

+ type IAccessContext interface

+ GetParser func() antlr.Parser

+ IsAccessContext func()

+ type IAdditiveExpressionContext interface

+ GetParser func() antlr.Parser

+ IsAdditiveExpressionContext func()

+ type IAdditiveOpContext interface

+ GetParser func() antlr.Parser

+ IsAdditiveOpContext func()

+ type IAndExpressionContext interface

+ GetParser func() antlr.Parser

+ IsAndExpressionContext func()

+ type IArgumentContext interface

+ GetParser func() antlr.Parser

+ IsArgumentContext func()

+ type IArrayLiteralContext interface

+ GetParser func() antlr.Parser

+ IsArrayLiteralContext func()

+ type IAssignmentContext interface

+ GetParser func() antlr.Parser

+ IsAssignmentContext func()

+ type IBaseTypeContext interface

+ GetParser func() antlr.Parser

+ IsBaseTypeContext func()

+ type IBlockContext interface

+ GetParser func() antlr.Parser

+ IsBlockContext func()

+ type IBooleanLiteralContext interface

+ GetParser func() antlr.Parser

+ IsBooleanLiteralContext func()

+ type IBracketExpressionContext interface

+ GetParser func() antlr.Parser

+ IsBracketExpressionContext func()

+ type IBreakStatementContext interface

+ GetParser func() antlr.Parser

+ IsBreakStatementContext func()

+ type ICastingExpressionContext interface

+ GetParser func() antlr.Parser

+ IsCastingExpressionContext func()

+ type ICastingOpContext interface

+ GetParser func() antlr.Parser

+ IsCastingOpContext func()

+ type ICompositeDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsCompositeDeclarationContext func()

+ type ICompositeKindContext interface

+ GetParser func() antlr.Parser

+ IsCompositeKindContext func()

+ type IConcatenatingExpressionContext interface

+ GetParser func() antlr.Parser

+ IsConcatenatingExpressionContext func()

+ type IConditionContext interface

+ GetMessage func() IExpressionContext

+ GetParser func() antlr.Parser

+ GetTest func() IExpressionContext

+ IsConditionContext func()

+ SetMessage func(IExpressionContext)

+ SetTest func(IExpressionContext)

+ type IConditionalExpressionContext interface

+ GetAlt func() IExpressionContext

+ GetParser func() antlr.Parser

+ GetThen func() IExpressionContext

+ IsConditionalExpressionContext func()

+ SetAlt func(IExpressionContext)

+ SetThen func(IExpressionContext)

+ type IConditionsContext interface

+ GetParser func() antlr.Parser

+ IsConditionsContext func()

+ type IConformancesContext interface

+ GetParser func() antlr.Parser

+ IsConformancesContext func()

+ type IConstantSizedTypeContext interface

+ GetParser func() antlr.Parser

+ GetSize func() IIntegerLiteralContext

+ IsConstantSizedTypeContext func()

+ SetSize func(IIntegerLiteralContext)

+ type IContinueStatementContext interface

+ GetParser func() antlr.Parser

+ IsContinueStatementContext func()

+ type ICreateExpressionContext interface

+ GetParser func() antlr.Parser

+ IsCreateExpressionContext func()

+ type IDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsDeclarationContext func()

+ type IDestroyExpressionContext interface

+ GetParser func() antlr.Parser

+ IsDestroyExpressionContext func()

+ type IDictionaryEntryContext interface

+ GetKey func() IExpressionContext

+ GetParser func() antlr.Parser

+ GetValue func() IExpressionContext

+ IsDictionaryEntryContext func()

+ SetKey func(IExpressionContext)

+ SetValue func(IExpressionContext)

+ type IDictionaryLiteralContext interface

+ GetParser func() antlr.Parser

+ IsDictionaryLiteralContext func()

+ type IDictionaryTypeContext interface

+ GetKeyType func() IFullTypeContext

+ GetParser func() antlr.Parser

+ GetValueType func() IFullTypeContext

+ IsDictionaryTypeContext func()

+ SetKeyType func(IFullTypeContext)

+ SetValueType func(IFullTypeContext)

+ type IEmitStatementContext interface

+ GetParser func() antlr.Parser

+ IsEmitStatementContext func()

+ type IEosContext interface

+ GetParser func() antlr.Parser

+ IsEosContext func()

+ type IEqualityExpressionContext interface

+ GetParser func() antlr.Parser

+ IsEqualityExpressionContext func()

+ type IEqualityOpContext interface

+ GetParser func() antlr.Parser

+ IsEqualityOpContext func()

+ type IEventDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsEventDeclarationContext func()

+ type IExecuteContext interface

+ GetParser func() antlr.Parser

+ IsExecuteContext func()

+ type IExpressionAccessContext interface

+ GetParser func() antlr.Parser

+ IsExpressionAccessContext func()

+ type IExpressionContext interface

+ GetParser func() antlr.Parser

+ IsExpressionContext func()

+ type IFieldContext interface

+ GetParser func() antlr.Parser

+ IsFieldContext func()

+ type IFieldsContext interface

+ GetParser func() antlr.Parser

+ IsFieldsContext func()

+ type IFixedPointLiteralContext interface

+ GetParser func() antlr.Parser

+ IsFixedPointLiteralContext func()

+ type IForStatementContext interface

+ GetParser func() antlr.Parser

+ IsForStatementContext func()

+ type IFullTypeContext interface

+ GetOptionals func() []antlr.Token

+ GetParser func() antlr.Parser

+ Get_Optional func() antlr.Token

+ IsFullTypeContext func()

+ SetOptionals func([]antlr.Token)

+ Set_Optional func(antlr.Token)

+ type IFunctionBlockContext interface

+ GetParser func() antlr.Parser

+ IsFunctionBlockContext func()

+ type IFunctionDeclarationContext interface

+ GetParser func() antlr.Parser

+ GetReturnType func() ITypeAnnotationContext

+ IsFunctionDeclarationContext func()

+ SetReturnType func(ITypeAnnotationContext)

+ type IFunctionTypeContext interface

+ GetParameterTypes func() []ITypeAnnotationContext

+ GetParser func() antlr.Parser

+ GetReturnType func() ITypeAnnotationContext

+ Get_typeAnnotation func() ITypeAnnotationContext

+ IsFunctionTypeContext func()

+ SetParameterTypes func([]ITypeAnnotationContext)

+ SetReturnType func(ITypeAnnotationContext)

+ Set_typeAnnotation func(ITypeAnnotationContext)

+ type IIdentifierContext interface

+ GetParser func() antlr.Parser

+ IsIdentifierContext func()

+ type IIfStatementContext interface

+ GetAlt func() IBlockContext

+ GetParser func() antlr.Parser

+ GetTestDeclaration func() IVariableDeclarationContext

+ GetTestExpression func() IExpressionContext

+ GetThen func() IBlockContext

+ IsIfStatementContext func()

+ SetAlt func(IBlockContext)

+ SetTestDeclaration func(IVariableDeclarationContext)

+ SetTestExpression func(IExpressionContext)

+ SetThen func(IBlockContext)

+ type IImportDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsImportDeclarationContext func()

+ type IInnerTypeContext interface

+ GetParser func() antlr.Parser

+ IsInnerTypeContext func()

+ type IIntegerLiteralContext interface

+ GetParser func() antlr.Parser

+ IsIntegerLiteralContext func()

+ type IInterfaceDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsInterfaceDeclarationContext func()

+ type IInvocationContext interface

+ GetParser func() antlr.Parser

+ IsInvocationContext func()

+ type ILiteralContext interface

+ GetParser func() antlr.Parser

+ IsLiteralContext func()

+ type IMemberAccessContext interface

+ GetParser func() antlr.Parser

+ IsMemberAccessContext func()

+ type IMemberOrNestedDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsMemberOrNestedDeclarationContext func()

+ type IMembersAndNestedDeclarationsContext interface

+ GetParser func() antlr.Parser

+ IsMembersAndNestedDeclarationsContext func()

+ type IMultiplicativeExpressionContext interface

+ GetParser func() antlr.Parser

+ IsMultiplicativeExpressionContext func()

+ type IMultiplicativeOpContext interface

+ GetParser func() antlr.Parser

+ IsMultiplicativeOpContext func()

+ type INilCoalescingExpressionContext interface

+ GetParser func() antlr.Parser

+ IsNilCoalescingExpressionContext func()

+ type INilLiteralContext interface

+ GetParser func() antlr.Parser

+ IsNilLiteralContext func()

+ type INominalTypeContext interface

+ GetParser func() antlr.Parser

+ IsNominalTypeContext func()

+ type IOrExpressionContext interface

+ GetParser func() antlr.Parser

+ IsOrExpressionContext func()

+ type IParameterContext interface

+ GetArgumentLabel func() IIdentifierContext

+ GetParameterName func() IIdentifierContext

+ GetParser func() antlr.Parser

+ IsParameterContext func()

+ SetArgumentLabel func(IIdentifierContext)

+ SetParameterName func(IIdentifierContext)

+ type IParameterListContext interface

+ GetParser func() antlr.Parser

+ IsParameterListContext func()

+ type IPathLiteralContext interface

+ GetDomain func() IIdentifierContext

+ GetId func() IIdentifierContext

+ GetParser func() antlr.Parser

+ IsPathLiteralContext func()

+ SetDomain func(IIdentifierContext)

+ SetId func(IIdentifierContext)

+ type IPositiveIntegerLiteralContext interface

+ GetParser func() antlr.Parser

+ IsPositiveIntegerLiteralContext func()

+ type IPostConditionsContext interface

+ GetParser func() antlr.Parser

+ IsPostConditionsContext func()

+ type IPostfixExpressionContext interface

+ GetParser func() antlr.Parser

+ IsPostfixExpressionContext func()

+ type IPreConditionsContext interface

+ GetParser func() antlr.Parser

+ IsPreConditionsContext func()

+ type IPrepareContext interface

+ GetParser func() antlr.Parser

+ IsPrepareContext func()

+ type IPrimaryExpressionContext interface

+ GetParser func() antlr.Parser

+ IsPrimaryExpressionContext func()

+ type IProgramContext interface

+ GetParser func() antlr.Parser

+ IsProgramContext func()

+ type IReferenceExpressionContext interface

+ GetParser func() antlr.Parser

+ IsReferenceExpressionContext func()

+ type IRelationalExpressionContext interface

+ GetParser func() antlr.Parser

+ IsRelationalExpressionContext func()

+ type IRelationalOpContext interface

+ GetParser func() antlr.Parser

+ IsRelationalOpContext func()

+ type IReplDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsReplDeclarationContext func()

+ type IReplElementContext interface

+ GetParser func() antlr.Parser

+ IsReplElementContext func()

+ type IReplInputContext interface

+ GetParser func() antlr.Parser

+ IsReplInputContext func()

+ type IReplStatementContext interface

+ GetParser func() antlr.Parser

+ IsReplStatementContext func()

+ type IReturnStatementContext interface

+ GetParser func() antlr.Parser

+ IsReturnStatementContext func()

+ type ISpecialFunctionDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsSpecialFunctionDeclarationContext func()

+ type IStatementContext interface

+ GetParser func() antlr.Parser

+ IsStatementContext func()

+ type IStatementsContext interface

+ GetParser func() antlr.Parser

+ IsStatementsContext func()

+ type IStringLiteralContext interface

+ GetParser func() antlr.Parser

+ IsStringLiteralContext func()

+ type ISwapContext interface

+ GetLeft func() IExpressionContext

+ GetParser func() antlr.Parser

+ GetRight func() IExpressionContext

+ IsSwapContext func()

+ SetLeft func(IExpressionContext)

+ SetRight func(IExpressionContext)

+ type ITransactionDeclarationContext interface

+ GetParser func() antlr.Parser

+ IsTransactionDeclarationContext func()

+ type ITransferContext interface

+ GetParser func() antlr.Parser

+ IsTransferContext func()

+ type ITypeAnnotationContext interface

+ GetParser func() antlr.Parser

+ IsTypeAnnotationContext func()

+ type ITypeRestrictionsContext interface

+ GetParser func() antlr.Parser

+ IsTypeRestrictionsContext func()

+ type IUnaryExpressionContext interface

+ GetParser func() antlr.Parser

+ IsUnaryExpressionContext func()

+ type IUnaryOpContext interface

+ GetParser func() antlr.Parser

+ IsUnaryOpContext func()

+ type IVariableDeclarationContext interface

+ GetLeftExpression func() IExpressionContext

+ GetLeftTransfer func() ITransferContext

+ GetParser func() antlr.Parser

+ GetRightExpression func() IExpressionContext

+ GetRightTransfer func() ITransferContext

+ IsVariableDeclarationContext func()

+ SetLeftExpression func(IExpressionContext)

+ SetLeftTransfer func(ITransferContext)

+ SetRightExpression func(IExpressionContext)

+ SetRightTransfer func(ITransferContext)

+ type IVariableKindContext interface

+ GetParser func() antlr.Parser

+ IsVariableKindContext func()

+ type IVariableSizedTypeContext interface

+ GetParser func() antlr.Parser

+ IsVariableSizedTypeContext func()

+ type IWhileStatementContext interface

+ GetParser func() antlr.Parser

+ IsWhileStatementContext func()

+ type IdentifierContext struct

+ func NewEmptyIdentifierContext() *IdentifierContext

+ func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext

+ func (*IdentifierContext) IsIdentifierContext()

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

+ func (s *IdentifierContext) Access() antlr.TerminalNode

+ func (s *IdentifierContext) Account() antlr.TerminalNode

+ func (s *IdentifierContext) All() antlr.TerminalNode

+ func (s *IdentifierContext) Auth() antlr.TerminalNode

+ func (s *IdentifierContext) Contract() antlr.TerminalNode

+ func (s *IdentifierContext) Create() antlr.TerminalNode

+ func (s *IdentifierContext) Destroy() antlr.TerminalNode

+ func (s *IdentifierContext) Emit() antlr.TerminalNode

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

+ func (s *IdentifierContext) Event() antlr.TerminalNode

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

+ func (s *IdentifierContext) From() antlr.TerminalNode

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

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

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

+ func (s *IdentifierContext) In() antlr.TerminalNode

+ func (s *IdentifierContext) Resource() antlr.TerminalNode

+ func (s *IdentifierContext) Self() antlr.TerminalNode

+ func (s *IdentifierContext) Struct() antlr.TerminalNode

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

+ type IdentifierExpressionContext struct

+ func NewIdentifierExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierExpressionContext

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

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

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

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

+ func (s *IdentifierExpressionContext) Identifier() IIdentifierContext

+ 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) Else() antlr.TerminalNode

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

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

+ func (s *IfStatementContext) Expression() IExpressionContext

+ func (s *IfStatementContext) GetAlt() IBlockContext

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

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

+ func (s *IfStatementContext) GetTestDeclaration() IVariableDeclarationContext

+ func (s *IfStatementContext) GetTestExpression() IExpressionContext

+ func (s *IfStatementContext) GetThen() IBlockContext

+ func (s *IfStatementContext) If() antlr.TerminalNode

+ func (s *IfStatementContext) IfStatement() IIfStatementContext

+ func (s *IfStatementContext) SetAlt(v IBlockContext)

+ func (s *IfStatementContext) SetTestDeclaration(v IVariableDeclarationContext)

+ func (s *IfStatementContext) SetTestExpression(v IExpressionContext)

+ func (s *IfStatementContext) SetThen(v IBlockContext)

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

+ func (s *IfStatementContext) VariableDeclaration() IVariableDeclarationContext

+ 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) AllIdentifier() []IIdentifierContext

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

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

+ func (s *ImportDeclarationContext) From() antlr.TerminalNode

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

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

+ func (s *ImportDeclarationContext) HexadecimalLiteral() antlr.TerminalNode

+ func (s *ImportDeclarationContext) Identifier(i int) IIdentifierContext

+ func (s *ImportDeclarationContext) Import() antlr.TerminalNode

+ func (s *ImportDeclarationContext) StringLiteral() IStringLiteralContext

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

+ type InnerTypeContext struct

+ func NewEmptyInnerTypeContext() *InnerTypeContext

+ func NewInnerTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InnerTypeContext

+ func (*InnerTypeContext) IsInnerTypeContext()

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

+ func (s *InnerTypeContext) BaseType() IBaseTypeContext

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

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

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

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

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

+ func (s *InnerTypeContext) TypeRestrictions() ITypeRestrictionsContext

+ type IntegerLiteralContext struct

+ func NewEmptyIntegerLiteralContext() *IntegerLiteralContext

+ func NewIntegerLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerLiteralContext

+ func (*IntegerLiteralContext) IsIntegerLiteralContext()

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

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

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

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

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

+ func (s *IntegerLiteralContext) Minus() antlr.TerminalNode

+ func (s *IntegerLiteralContext) PositiveIntegerLiteral() IPositiveIntegerLiteralContext

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

+ type IntegerLiteralKind int

+ const IntegerLiteralKindBinary

+ const IntegerLiteralKindDecimal

+ const IntegerLiteralKindHexadecimal

+ const IntegerLiteralKindOctal

+ const IntegerLiteralKindUnknown

+ func (i IntegerLiteralKind) String() string

+ func (k IntegerLiteralKind) Base() int

+ func (k IntegerLiteralKind) Name() string

+ type InterfaceDeclarationContext struct

+ func NewEmptyInterfaceDeclarationContext() *InterfaceDeclarationContext

+ func NewInterfaceDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceDeclarationContext

+ func (*InterfaceDeclarationContext) IsInterfaceDeclarationContext()

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

+ func (s *InterfaceDeclarationContext) Access() IAccessContext

+ func (s *InterfaceDeclarationContext) CompositeKind() ICompositeKindContext

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

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

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

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

+ func (s *InterfaceDeclarationContext) Identifier() IIdentifierContext

+ func (s *InterfaceDeclarationContext) Interface() antlr.TerminalNode

+ func (s *InterfaceDeclarationContext) MembersAndNestedDeclarations() IMembersAndNestedDeclarationsContext

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

+ type InvalidIntegerLiteralError struct

+ IntegerLiteralKind IntegerLiteralKind

+ InvalidIntegerLiteralKind InvalidNumberLiteralKind

+ Literal string

+ func (e *InvalidIntegerLiteralError) Error() string

+ func (e *InvalidIntegerLiteralError) SecondaryError() string

+ type InvalidNumberLiteralContext struct

+ func NewInvalidNumberLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InvalidNumberLiteralContext

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

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

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

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

+ func (s *InvalidNumberLiteralContext) InvalidNumberLiteral() antlr.TerminalNode

+ type InvalidNumberLiteralKind int

+ const InvalidNumberLiteralKindLeadingUnderscore

+ const InvalidNumberLiteralKindTrailingUnderscore

+ const InvalidNumberLiteralKindUnknown

+ const InvalidNumberLiteralKindUnknownPrefix

+ func (i InvalidNumberLiteralKind) String() string

+ func (k InvalidNumberLiteralKind) Description() string

+ type InvocationContext struct

+ func NewEmptyInvocationContext() *InvocationContext

+ func NewInvocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InvocationContext

+ func (*InvocationContext) IsInvocationContext()

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

+ func (s *InvocationContext) AllArgument() []IArgumentContext

+ func (s *InvocationContext) AllTypeAnnotation() []ITypeAnnotationContext

+ func (s *InvocationContext) Argument(i int) IArgumentContext

+ func (s *InvocationContext) CloseParen() antlr.TerminalNode

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

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

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

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

+ func (s *InvocationContext) Greater() antlr.TerminalNode

+ func (s *InvocationContext) Less() antlr.TerminalNode

+ func (s *InvocationContext) OpenParen() antlr.TerminalNode

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

+ func (s *InvocationContext) TypeAnnotation(i int) ITypeAnnotationContext

+ type InvocationExpressionContext struct

+ func NewInvocationExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InvocationExpressionContext

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

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

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

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

+ func (s *InvocationExpressionContext) Invocation() IInvocationContext

+ func (s *InvocationExpressionContext) PostfixExpression() IPostfixExpressionContext

+ type JuxtaposedUnaryOperatorsError struct

+ Pos ast.Position

+ func (e *JuxtaposedUnaryOperatorsError) EndPosition() ast.Position

+ func (e *JuxtaposedUnaryOperatorsError) Error() string

+ func (e *JuxtaposedUnaryOperatorsError) StartPosition() ast.Position

+ 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) ArrayLiteral() IArrayLiteralContext

+ func (s *LiteralContext) BooleanLiteral() IBooleanLiteralContext

+ func (s *LiteralContext) DictionaryLiteral() IDictionaryLiteralContext

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

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

+ func (s *LiteralContext) FixedPointLiteral() IFixedPointLiteralContext

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

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

+ func (s *LiteralContext) IntegerLiteral() IIntegerLiteralContext

+ func (s *LiteralContext) NilLiteral() INilLiteralContext

+ func (s *LiteralContext) PathLiteral() IPathLiteralContext

+ func (s *LiteralContext) StringLiteral() IStringLiteralContext

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

+ type LiteralExpressionContext struct

+ func NewLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralExpressionContext

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

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

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

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

+ func (s *LiteralExpressionContext) Literal() ILiteralContext

+ 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) EnterRule(listener antlr.ParseTreeListener)

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

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

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

+ func (s *MemberAccessContext) Identifier() IIdentifierContext

+ func (s *MemberAccessContext) Optional() antlr.TerminalNode

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

+ type MemberOrNestedDeclarationContext struct

+ func NewEmptyMemberOrNestedDeclarationContext() *MemberOrNestedDeclarationContext

+ func NewMemberOrNestedDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberOrNestedDeclarationContext

+ func (*MemberOrNestedDeclarationContext) IsMemberOrNestedDeclarationContext()

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

+ func (s *MemberOrNestedDeclarationContext) CompositeDeclaration() ICompositeDeclarationContext

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

+ func (s *MemberOrNestedDeclarationContext) EventDeclaration() IEventDeclarationContext

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

+ func (s *MemberOrNestedDeclarationContext) Field() IFieldContext

+ func (s *MemberOrNestedDeclarationContext) FunctionDeclaration() IFunctionDeclarationContext

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

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

+ func (s *MemberOrNestedDeclarationContext) InterfaceDeclaration() IInterfaceDeclarationContext

+ func (s *MemberOrNestedDeclarationContext) SpecialFunctionDeclaration() ISpecialFunctionDeclarationContext

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

+ type MembersAndNestedDeclarationsContext struct

+ func NewEmptyMembersAndNestedDeclarationsContext() *MembersAndNestedDeclarationsContext

+ func NewMembersAndNestedDeclarationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MembersAndNestedDeclarationsContext

+ func (*MembersAndNestedDeclarationsContext) IsMembersAndNestedDeclarationsContext()

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

+ func (s *MembersAndNestedDeclarationsContext) AllMemberOrNestedDeclaration() []IMemberOrNestedDeclarationContext

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

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

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

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

+ func (s *MembersAndNestedDeclarationsContext) MemberOrNestedDeclaration(i int) IMemberOrNestedDeclarationContext

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

+ type MultiplicativeExpressionContext struct

+ func NewEmptyMultiplicativeExpressionContext() *MultiplicativeExpressionContext

+ func NewMultiplicativeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiplicativeExpressionContext

+ func (*MultiplicativeExpressionContext) IsMultiplicativeExpressionContext()

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

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

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

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

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

+ func (s *MultiplicativeExpressionContext) MultiplicativeExpression() IMultiplicativeExpressionContext

+ func (s *MultiplicativeExpressionContext) MultiplicativeOp() IMultiplicativeOpContext

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

+ func (s *MultiplicativeExpressionContext) UnaryExpression() IUnaryExpressionContext

+ type MultiplicativeOpContext struct

+ func NewEmptyMultiplicativeOpContext() *MultiplicativeOpContext

+ func NewMultiplicativeOpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiplicativeOpContext

+ func (*MultiplicativeOpContext) IsMultiplicativeOpContext()

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

+ func (s *MultiplicativeOpContext) Div() antlr.TerminalNode

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

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

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

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

+ func (s *MultiplicativeOpContext) Mod() antlr.TerminalNode

+ func (s *MultiplicativeOpContext) Mul() antlr.TerminalNode

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

+ type NestedExpressionContext struct

+ func NewNestedExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NestedExpressionContext

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

+ func (s *NestedExpressionContext) CloseParen() antlr.TerminalNode

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

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

+ func (s *NestedExpressionContext) Expression() IExpressionContext

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

+ func (s *NestedExpressionContext) OpenParen() antlr.TerminalNode

+ type NilCoalescingExpressionContext struct

+ func NewEmptyNilCoalescingExpressionContext() *NilCoalescingExpressionContext

+ func NewNilCoalescingExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NilCoalescingExpressionContext

+ func (*NilCoalescingExpressionContext) IsNilCoalescingExpressionContext()

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

+ func (s *NilCoalescingExpressionContext) CastingExpression() ICastingExpressionContext

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

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

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

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

+ func (s *NilCoalescingExpressionContext) NilCoalescing() antlr.TerminalNode

+ func (s *NilCoalescingExpressionContext) NilCoalescingExpression() INilCoalescingExpressionContext

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

+ type NilLiteralContext struct

+ func NewEmptyNilLiteralContext() *NilLiteralContext

+ func NewNilLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NilLiteralContext

+ func (*NilLiteralContext) IsNilLiteralContext()

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

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

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

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

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

+ func (s *NilLiteralContext) Nil() antlr.TerminalNode

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

+ type NominalTypeContext struct

+ func NewEmptyNominalTypeContext() *NominalTypeContext

+ func NewNominalTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NominalTypeContext

+ func (*NominalTypeContext) IsNominalTypeContext()

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

+ func (s *NominalTypeContext) AllIdentifier() []IIdentifierContext

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

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

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

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

+ func (s *NominalTypeContext) Identifier(i int) IIdentifierContext

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

+ type OctalLiteralContext struct

+ func NewOctalLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OctalLiteralContext

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

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

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

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

+ func (s *OctalLiteralContext) OctalLiteral() antlr.TerminalNode

+ type OrExpressionContext struct

+ func NewEmptyOrExpressionContext() *OrExpressionContext

+ func NewOrExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrExpressionContext

+ func (*OrExpressionContext) IsOrExpressionContext()

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

+ func (s *OrExpressionContext) AndExpression() IAndExpressionContext

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

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

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

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

+ func (s *OrExpressionContext) OrExpression() IOrExpressionContext

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

+ type ParameterContext struct

+ func NewEmptyParameterContext() *ParameterContext

+ func NewParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterContext

+ func (*ParameterContext) IsParameterContext()

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

+ func (s *ParameterContext) AllIdentifier() []IIdentifierContext

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

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

+ func (s *ParameterContext) GetArgumentLabel() IIdentifierContext

+ func (s *ParameterContext) GetParameterName() IIdentifierContext

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

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

+ func (s *ParameterContext) Identifier(i int) IIdentifierContext

+ func (s *ParameterContext) SetArgumentLabel(v IIdentifierContext)

+ func (s *ParameterContext) SetParameterName(v IIdentifierContext)

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

+ func (s *ParameterContext) TypeAnnotation() ITypeAnnotationContext

+ type ParameterListContext struct

+ func NewEmptyParameterListContext() *ParameterListContext

+ func NewParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterListContext

+ func (*ParameterListContext) IsParameterListContext()

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

+ func (s *ParameterListContext) AllParameter() []IParameterContext

+ func (s *ParameterListContext) CloseParen() antlr.TerminalNode

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

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

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

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

+ func (s *ParameterListContext) OpenParen() antlr.TerminalNode

+ func (s *ParameterListContext) Parameter(i int) IParameterContext

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

+ type ParseError interface

+ type PathLiteralContext struct

+ func NewEmptyPathLiteralContext() *PathLiteralContext

+ func NewPathLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PathLiteralContext

+ func (*PathLiteralContext) IsPathLiteralContext()

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

+ func (s *PathLiteralContext) AllDiv() []antlr.TerminalNode

+ func (s *PathLiteralContext) AllIdentifier() []IIdentifierContext

+ func (s *PathLiteralContext) Div(i int) antlr.TerminalNode

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

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

+ func (s *PathLiteralContext) GetDomain() IIdentifierContext

+ func (s *PathLiteralContext) GetId() IIdentifierContext

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

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

+ func (s *PathLiteralContext) Identifier(i int) IIdentifierContext

+ func (s *PathLiteralContext) SetDomain(v IIdentifierContext)

+ func (s *PathLiteralContext) SetId(v IIdentifierContext)

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

+ type PositiveIntegerLiteralContext struct

+ func NewEmptyPositiveIntegerLiteralContext() *PositiveIntegerLiteralContext

+ func NewPositiveIntegerLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PositiveIntegerLiteralContext

+ func (*PositiveIntegerLiteralContext) IsPositiveIntegerLiteralContext()

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

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

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

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

+ type PostConditionsContext struct

+ func NewEmptyPostConditionsContext() *PostConditionsContext

+ func NewPostConditionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostConditionsContext

+ func (*PostConditionsContext) IsPostConditionsContext()

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

+ func (s *PostConditionsContext) Conditions() IConditionsContext

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

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

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

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

+ func (s *PostConditionsContext) Post() antlr.TerminalNode

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

+ type PostfixExpressionContext struct

+ func NewEmptyPostfixExpressionContext() *PostfixExpressionContext

+ func NewPostfixExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostfixExpressionContext

+ func (*PostfixExpressionContext) IsPostfixExpressionContext()

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

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

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

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

+ type PreConditionsContext struct

+ func NewEmptyPreConditionsContext() *PreConditionsContext

+ func NewPreConditionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreConditionsContext

+ func (*PreConditionsContext) IsPreConditionsContext()

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

+ func (s *PreConditionsContext) Conditions() IConditionsContext

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

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

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

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

+ func (s *PreConditionsContext) Pre() antlr.TerminalNode

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

+ type PrepareContext struct

+ func NewEmptyPrepareContext() *PrepareContext

+ func NewPrepareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrepareContext

+ func (*PrepareContext) IsPrepareContext()

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

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

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

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

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

+ func (s *PrepareContext) SpecialFunctionDeclaration() ISpecialFunctionDeclarationContext

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

+ type PrimaryExpressionContext struct

+ func NewEmptyPrimaryExpressionContext() *PrimaryExpressionContext

+ func NewPrimaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryExpressionContext

+ func (*PrimaryExpressionContext) IsPrimaryExpressionContext()

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

+ func (s *PrimaryExpressionContext) CreateExpression() ICreateExpressionContext

+ func (s *PrimaryExpressionContext) DestroyExpression() IDestroyExpressionContext

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

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

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

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

+ func (s *PrimaryExpressionContext) PostfixExpression() IPostfixExpressionContext

+ func (s *PrimaryExpressionContext) ReferenceExpression() IReferenceExpressionContext

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

+ type ProgramContext struct

+ func NewEmptyProgramContext() *ProgramContext

+ func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext

+ func (*ProgramContext) IsProgramContext()

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

+ func (s *ProgramContext) AllDeclaration() []IDeclarationContext

+ func (s *ProgramContext) Declaration(i int) IDeclarationContext

+ func (s *ProgramContext) EOF() antlr.TerminalNode

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

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

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

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

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

+ type ProgramVisitor struct

+ func (v *ProgramVisitor) VisitAccess(ctx *AccessContext) interface{}

+ func (v *ProgramVisitor) VisitAccessExpression(ctx *AccessExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitAdditiveExpression(ctx *AdditiveExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitAdditiveOp(ctx *AdditiveOpContext) interface{}

+ func (v *ProgramVisitor) VisitAndExpression(ctx *AndExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitArgument(ctx *ArgumentContext) interface{}

+ func (v *ProgramVisitor) VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitAssignment(ctx *AssignmentContext) interface{}

+ func (v *ProgramVisitor) VisitBaseType(ctx *BaseTypeContext) interface{}

+ func (v *ProgramVisitor) VisitBinaryLiteral(ctx *BinaryLiteralContext) interface{}

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

+ func (v *ProgramVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitBracketExpression(ctx *BracketExpressionContext) interface{}

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

+ func (v *ProgramVisitor) VisitCastingExpression(ctx *CastingExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitCastingOp(ctx *CastingOpContext) interface{}

+ func (v *ProgramVisitor) VisitChildren(node antlr.RuleNode) interface{}

+ func (v *ProgramVisitor) VisitCompositeDeclaration(ctx *CompositeDeclarationContext) interface{}

+ func (v *ProgramVisitor) VisitCompositeKind(ctx *CompositeKindContext) interface{}

+ func (v *ProgramVisitor) VisitConcatenatingExpression(ctx *ConcatenatingExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitCondition(ctx *ConditionContext) interface{}

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

+ func (v *ProgramVisitor) VisitConditions(ctx *ConditionsContext) interface{}

+ func (v *ProgramVisitor) VisitConformances(ctx *ConformancesContext) interface{}

+ func (v *ProgramVisitor) VisitConstantSizedType(ctx *ConstantSizedTypeContext) interface{}

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

+ func (v *ProgramVisitor) VisitCreateExpression(ctx *CreateExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitDeclaration(ctx *DeclarationContext) interface{}

+ func (v *ProgramVisitor) VisitDestroyExpression(ctx *DestroyExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitDictionaryEntry(ctx *DictionaryEntryContext) interface{}

+ func (v *ProgramVisitor) VisitDictionaryLiteral(ctx *DictionaryLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitDictionaryType(ctx *DictionaryTypeContext) interface{}

+ func (v *ProgramVisitor) VisitEmitStatement(ctx *EmitStatementContext) interface{}

+ func (v *ProgramVisitor) VisitEqualityExpression(ctx *EqualityExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitEqualityOp(ctx *EqualityOpContext) interface{}

+ func (v *ProgramVisitor) VisitEventDeclaration(ctx *EventDeclarationContext) interface{}

+ func (v *ProgramVisitor) VisitExecute(ctx *ExecuteContext) interface{}

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

+ func (v *ProgramVisitor) VisitExpressionAccess(ctx *ExpressionAccessContext) interface{}

+ func (v *ProgramVisitor) VisitField(ctx *FieldContext) interface{}

+ func (v *ProgramVisitor) VisitFields(ctx *FieldsContext) interface{}

+ func (v *ProgramVisitor) VisitFixedPointLiteral(ctx *FixedPointLiteralContext) interface{}

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

+ func (v *ProgramVisitor) VisitForceExpression(ctx *ForceExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitFullType(ctx *FullTypeContext) interface{}

+ func (v *ProgramVisitor) VisitFunctionBlock(ctx *FunctionBlockContext) interface{}

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

+ func (v *ProgramVisitor) VisitFunctionExpression(ctx *FunctionExpressionContext) interface{}

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

+ func (v *ProgramVisitor) VisitHexadecimalLiteral(ctx *HexadecimalLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitIdentifier(ctx *IdentifierContext) interface{}

+ func (v *ProgramVisitor) VisitIdentifierExpression(ctx *IdentifierExpressionContext) interface{}

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

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

+ func (v *ProgramVisitor) VisitInnerType(ctx *InnerTypeContext) interface{}

+ func (v *ProgramVisitor) VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitInterfaceDeclaration(ctx *InterfaceDeclarationContext) interface{}

+ func (v *ProgramVisitor) VisitInvalidNumberLiteral(ctx *InvalidNumberLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitInvocation(ctx *InvocationContext) interface{}

+ func (v *ProgramVisitor) VisitInvocationExpression(ctx *InvocationExpressionContext) interface{}

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

+ func (v *ProgramVisitor) VisitLiteralExpression(ctx *LiteralExpressionContext) interface{}

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

+ func (v *ProgramVisitor) VisitMemberOrNestedDeclaration(ctx *MemberOrNestedDeclarationContext) interface{}

+ func (v *ProgramVisitor) VisitMembersAndNestedDeclarations(ctx *MembersAndNestedDeclarationsContext) interface{}

+ func (v *ProgramVisitor) VisitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitMultiplicativeOp(ctx *MultiplicativeOpContext) interface{}

+ func (v *ProgramVisitor) VisitNestedExpression(ctx *NestedExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitNilCoalescingExpression(ctx *NilCoalescingExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitNilLiteral(ctx *NilLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitNominalType(ctx *NominalTypeContext) interface{}

+ func (v *ProgramVisitor) VisitOctalLiteral(ctx *OctalLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitOrExpression(ctx *OrExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitParameter(ctx *ParameterContext) interface{}

+ func (v *ProgramVisitor) VisitParameterList(ctx *ParameterListContext) interface{}

+ func (v *ProgramVisitor) VisitPathLiteral(ctx *PathLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitPostConditions(ctx *PostConditionsContext) interface{}

+ func (v *ProgramVisitor) VisitPreConditions(ctx *PreConditionsContext) interface{}

+ func (v *ProgramVisitor) VisitPrepare(ctx *PrepareContext) interface{}

+ func (v *ProgramVisitor) VisitPrimaryExpression(ctx *PrimaryExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitProgram(ctx *ProgramContext) interface{}

+ func (v *ProgramVisitor) VisitReferenceExpression(ctx *ReferenceExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitRelationalExpression(ctx *RelationalExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitRelationalOp(ctx *RelationalOpContext) interface{}

+ func (v *ProgramVisitor) VisitReplDeclaration(ctx *ReplDeclarationContext) interface{}

+ func (v *ProgramVisitor) VisitReplElement(ctx *ReplElementContext) interface{}

+ func (v *ProgramVisitor) VisitReplInput(ctx *ReplInputContext) interface{}

+ func (v *ProgramVisitor) VisitReplStatement(ctx *ReplStatementContext) interface{}

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

+ func (v *ProgramVisitor) VisitSpecialFunctionDeclaration(ctx *SpecialFunctionDeclarationContext) interface{}

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

+ func (v *ProgramVisitor) VisitStatements(ctx *StatementsContext) interface{}

+ func (v *ProgramVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}

+ func (v *ProgramVisitor) VisitSwap(ctx *SwapContext) interface{}

+ func (v *ProgramVisitor) VisitTransactionDeclaration(ctx *TransactionDeclarationContext) interface{}

+ func (v *ProgramVisitor) VisitTransfer(ctx *TransferContext) interface{}

+ func (v *ProgramVisitor) VisitTypeAnnotation(ctx *TypeAnnotationContext) interface{}

+ func (v *ProgramVisitor) VisitTypeRestrictions(ctx *TypeRestrictionsContext) interface{}

+ func (v *ProgramVisitor) VisitUnaryExpression(ctx *UnaryExpressionContext) interface{}

+ func (v *ProgramVisitor) VisitUnaryOp(ctx *UnaryOpContext) interface{}

+ func (v *ProgramVisitor) VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

+ func (v *ProgramVisitor) VisitVariableKind(ctx *VariableKindContext) interface{}

+ func (v *ProgramVisitor) VisitVariableSizedType(ctx *VariableSizedTypeContext) interface{}

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

+ type ReferenceExpressionContext struct

+ func NewEmptyReferenceExpressionContext() *ReferenceExpressionContext

+ func NewReferenceExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceExpressionContext

+ func (*ReferenceExpressionContext) IsReferenceExpressionContext()

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

+ func (s *ReferenceExpressionContext) Ampersand() antlr.TerminalNode

+ func (s *ReferenceExpressionContext) Casting() antlr.TerminalNode

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

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

+ func (s *ReferenceExpressionContext) Expression() IExpressionContext

+ func (s *ReferenceExpressionContext) FullType() IFullTypeContext

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

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

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

+ type RelationalExpressionContext struct

+ func NewEmptyRelationalExpressionContext() *RelationalExpressionContext

+ func NewRelationalExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationalExpressionContext

+ func (*RelationalExpressionContext) IsRelationalExpressionContext()

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

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

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

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

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

+ func (s *RelationalExpressionContext) NilCoalescingExpression() INilCoalescingExpressionContext

+ func (s *RelationalExpressionContext) RelationalExpression() IRelationalExpressionContext

+ func (s *RelationalExpressionContext) RelationalOp() IRelationalOpContext

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

+ type RelationalOpContext struct

+ func NewEmptyRelationalOpContext() *RelationalOpContext

+ func NewRelationalOpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationalOpContext

+ func (*RelationalOpContext) IsRelationalOpContext()

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

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

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

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

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

+ func (s *RelationalOpContext) Greater() antlr.TerminalNode

+ func (s *RelationalOpContext) GreaterEqual() antlr.TerminalNode

+ func (s *RelationalOpContext) Less() antlr.TerminalNode

+ func (s *RelationalOpContext) LessEqual() antlr.TerminalNode

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

+ type ReplDeclarationContext struct

+ func NewEmptyReplDeclarationContext() *ReplDeclarationContext

+ func NewReplDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplDeclarationContext

+ func (*ReplDeclarationContext) IsReplDeclarationContext()

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

+ func (s *ReplDeclarationContext) Declaration() IDeclarationContext

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

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

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

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

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

+ type ReplElementContext struct

+ func NewEmptyReplElementContext() *ReplElementContext

+ func NewReplElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplElementContext

+ func (*ReplElementContext) IsReplElementContext()

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

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

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

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

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

+ func (s *ReplElementContext) ReplDeclaration() IReplDeclarationContext

+ func (s *ReplElementContext) ReplStatement() IReplStatementContext

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

+ type ReplInputContext struct

+ func NewEmptyReplInputContext() *ReplInputContext

+ func NewReplInputContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplInputContext

+ func (*ReplInputContext) IsReplInputContext()

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

+ func (s *ReplInputContext) AllReplElement() []IReplElementContext

+ func (s *ReplInputContext) EOF() antlr.TerminalNode

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

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

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

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

+ func (s *ReplInputContext) ReplElement(i int) IReplElementContext

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

+ type ReplStatementContext struct

+ func NewEmptyReplStatementContext() *ReplStatementContext

+ func NewReplStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplStatementContext

+ func (*ReplStatementContext) IsReplStatementContext()

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

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

+ func (s *ReplStatementContext) Eos() IEosContext

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

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

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

+ func (s *ReplStatementContext) Statement() IStatementContext

+ func (s *ReplStatementContext) 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) EnterRule(listener antlr.ParseTreeListener)

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

+ func (s *ReturnStatementContext) Expression() IExpressionContext

+ 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 SpecialFunctionDeclarationContext struct

+ func NewEmptySpecialFunctionDeclarationContext() *SpecialFunctionDeclarationContext

+ func NewSpecialFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SpecialFunctionDeclarationContext

+ func (*SpecialFunctionDeclarationContext) IsSpecialFunctionDeclarationContext()

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

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

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

+ func (s *SpecialFunctionDeclarationContext) FunctionBlock() IFunctionBlockContext

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

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

+ func (s *SpecialFunctionDeclarationContext) Identifier() IIdentifierContext

+ func (s *SpecialFunctionDeclarationContext) ParameterList() IParameterListContext

+ func (s *SpecialFunctionDeclarationContext) 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) Assignment() IAssignmentContext

+ func (s *StatementContext) BreakStatement() IBreakStatementContext

+ func (s *StatementContext) ContinueStatement() IContinueStatementContext

+ func (s *StatementContext) Declaration() IDeclarationContext

+ func (s *StatementContext) EmitStatement() IEmitStatementContext

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

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

+ func (s *StatementContext) Expression() IExpressionContext

+ func (s *StatementContext) ForStatement() IForStatementContext

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

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

+ func (s *StatementContext) IfStatement() IIfStatementContext

+ func (s *StatementContext) ReturnStatement() IReturnStatementContext

+ func (s *StatementContext) Swap() ISwapContext

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

+ func (s *StatementContext) WhileStatement() IWhileStatementContext

+ type StatementsContext struct

+ func NewEmptyStatementsContext() *StatementsContext

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

+ func (*StatementsContext) IsStatementsContext()

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

+ func (s *StatementsContext) AllEos() []IEosContext

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

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

+ func (s *StatementsContext) Eos(i int) IEosContext

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

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

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

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

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

+ type StringLiteralContext struct

+ func NewEmptyStringLiteralContext() *StringLiteralContext

+ func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext

+ func (*StringLiteralContext) IsStringLiteralContext()

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

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

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

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

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

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

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

+ type SwapContext struct

+ func NewEmptySwapContext() *SwapContext

+ func NewSwapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwapContext

+ func (*SwapContext) IsSwapContext()

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

+ func (s *SwapContext) AllExpression() []IExpressionContext

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

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

+ func (s *SwapContext) Expression(i int) IExpressionContext

+ func (s *SwapContext) GetLeft() IExpressionContext

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

+ func (s *SwapContext) GetRight() IExpressionContext

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

+ func (s *SwapContext) SetLeft(v IExpressionContext)

+ func (s *SwapContext) SetRight(v IExpressionContext)

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

+ type SyntaxError struct

+ Message string

+ Pos ast.Position

+ func (e *SyntaxError) EndPosition() ast.Position

+ func (e *SyntaxError) Error() string

+ func (e *SyntaxError) StartPosition() ast.Position

+ type TransactionDeclarationContext struct

+ func NewEmptyTransactionDeclarationContext() *TransactionDeclarationContext

+ func NewTransactionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionDeclarationContext

+ func (*TransactionDeclarationContext) IsTransactionDeclarationContext()

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

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

+ func (s *TransactionDeclarationContext) Execute() IExecuteContext

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

+ func (s *TransactionDeclarationContext) Fields() IFieldsContext

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

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

+ func (s *TransactionDeclarationContext) ParameterList() IParameterListContext

+ func (s *TransactionDeclarationContext) PostConditions() IPostConditionsContext

+ func (s *TransactionDeclarationContext) PreConditions() IPreConditionsContext

+ func (s *TransactionDeclarationContext) Prepare() IPrepareContext

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

+ func (s *TransactionDeclarationContext) Transaction() antlr.TerminalNode

+ type TransferContext struct

+ func NewEmptyTransferContext() *TransferContext

+ func NewTransferContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransferContext

+ func (*TransferContext) IsTransferContext()

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

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

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

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

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

+ func (s *TransferContext) Move() antlr.TerminalNode

+ func (s *TransferContext) MoveForced() antlr.TerminalNode

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

+ type TypeAnnotationContext struct

+ func NewEmptyTypeAnnotationContext() *TypeAnnotationContext

+ func NewTypeAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeAnnotationContext

+ func (*TypeAnnotationContext) IsTypeAnnotationContext()

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

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

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

+ func (s *TypeAnnotationContext) FullType() IFullTypeContext

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

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

+ func (s *TypeAnnotationContext) ResourceAnnotation() antlr.TerminalNode

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

+ type TypeRestrictionsContext struct

+ func NewEmptyTypeRestrictionsContext() *TypeRestrictionsContext

+ func NewTypeRestrictionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeRestrictionsContext

+ func (*TypeRestrictionsContext) IsTypeRestrictionsContext()

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

+ func (s *TypeRestrictionsContext) AllNominalType() []INominalTypeContext

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

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

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

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

+ func (s *TypeRestrictionsContext) NominalType(i int) INominalTypeContext

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

+ type UnaryExpressionContext struct

+ func NewEmptyUnaryExpressionContext() *UnaryExpressionContext

+ func NewUnaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryExpressionContext

+ func (*UnaryExpressionContext) IsUnaryExpressionContext()

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

+ func (s *UnaryExpressionContext) AllUnaryOp() []IUnaryOpContext

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

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

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

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

+ func (s *UnaryExpressionContext) PrimaryExpression() IPrimaryExpressionContext

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

+ func (s *UnaryExpressionContext) UnaryExpression() IUnaryExpressionContext

+ func (s *UnaryExpressionContext) UnaryOp(i int) IUnaryOpContext

+ type UnaryOpContext struct

+ func NewEmptyUnaryOpContext() *UnaryOpContext

+ func NewUnaryOpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryOpContext

+ func (*UnaryOpContext) IsUnaryOpContext()

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

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

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

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

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

+ func (s *UnaryOpContext) Minus() antlr.TerminalNode

+ func (s *UnaryOpContext) Move() antlr.TerminalNode

+ func (s *UnaryOpContext) Negate() antlr.TerminalNode

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

+ type VariableDeclarationContext struct

+ func NewEmptyVariableDeclarationContext() *VariableDeclarationContext

+ func NewVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationContext

+ func (*VariableDeclarationContext) IsVariableDeclarationContext()

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

+ func (s *VariableDeclarationContext) Access() IAccessContext

+ func (s *VariableDeclarationContext) AllExpression() []IExpressionContext

+ func (s *VariableDeclarationContext) AllTransfer() []ITransferContext

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

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

+ func (s *VariableDeclarationContext) Expression(i int) IExpressionContext

+ func (s *VariableDeclarationContext) GetLeftExpression() IExpressionContext

+ func (s *VariableDeclarationContext) GetLeftTransfer() ITransferContext

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

+ func (s *VariableDeclarationContext) GetRightExpression() IExpressionContext

+ func (s *VariableDeclarationContext) GetRightTransfer() ITransferContext

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

+ func (s *VariableDeclarationContext) Identifier() IIdentifierContext

+ func (s *VariableDeclarationContext) SetLeftExpression(v IExpressionContext)

+ func (s *VariableDeclarationContext) SetLeftTransfer(v ITransferContext)

+ func (s *VariableDeclarationContext) SetRightExpression(v IExpressionContext)

+ func (s *VariableDeclarationContext) SetRightTransfer(v ITransferContext)

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

+ func (s *VariableDeclarationContext) Transfer(i int) ITransferContext

+ func (s *VariableDeclarationContext) TypeAnnotation() ITypeAnnotationContext

+ func (s *VariableDeclarationContext) VariableKind() IVariableKindContext

+ type VariableKindContext struct

+ func NewEmptyVariableKindContext() *VariableKindContext

+ func NewVariableKindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableKindContext

+ func (*VariableKindContext) IsVariableKindContext()

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

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

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

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

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

+ func (s *VariableKindContext) Let() antlr.TerminalNode

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

+ func (s *VariableKindContext) Var() antlr.TerminalNode

+ type VariableSizedTypeContext struct

+ func NewEmptyVariableSizedTypeContext() *VariableSizedTypeContext

+ func NewVariableSizedTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableSizedTypeContext

+ func (*VariableSizedTypeContext) IsVariableSizedTypeContext()

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

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

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

+ func (s *VariableSizedTypeContext) FullType() IFullTypeContext

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

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

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

+ 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) EnterRule(listener antlr.ParseTreeListener)

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

+ func (s *WhileStatementContext) Expression() IExpressionContext

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

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

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

+ func (s *WhileStatementContext) While() antlr.TerminalNode

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL