parser

package
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 14, 2024 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var SyntaxErrorLevels = []SyntaxErrorLevel{SyntaxErrorFatal, SyntaxErrorArgument}
View Source 
var SyntaxErrorTypes = []SyntaxErrorType{}/* 231 elements not displayed */
View Source 
var SyntaxWarningLevels = []SyntaxWarningLevel{SyntaxWarningDefault, SyntaxWarningVerbose}
View Source 
var SyntaxWarningTypes = []SyntaxWarningType{
	AMBIGUOUS_FIRST_ARGUMENT_MINUS,
	AMBIGUOUS_FIRST_ARGUMENT_PLUS,
	AMBIGUOUS_PREFIX_STAR,
	AMBIGUOUS_SLASH,
	DOT_DOT_DOT_EOL,
	EQUAL_IN_CONDITIONAL,
	END_IN_METHOD,
	DUPLICATED_HASH_KEY,
	DUPLICATED_WHEN_CLAUSE,
	FLOAT_OUT_OF_RANGE,
	INTEGER_IN_FLIP_FLOP,
	KEYWORD_EOL,
}

Functions

func ErrToJSON 

func ErrToJSON(err error) map[string]interface{}

func ErrToStr 

func ErrToStr(err error) string

Types

type AliasGlobalVariableNode 

type AliasGlobalVariableNode struct {
	Newname    Node
	Oldname    Node
	Keywordloc *Location
	Loc        *Location
}

func NewAliasGlobalVariableNode 

func NewAliasGlobalVariableNode(newName Node, oldName Node, keywordLoc *Location, loc *Location) *AliasGlobalVariableNode

func (*AliasGlobalVariableNode) Accept 

func (node *AliasGlobalVariableNode) Accept(visitor NodeVisitor)

func (*AliasGlobalVariableNode) Children 

func (node *AliasGlobalVariableNode) Children() []Node

func (*AliasGlobalVariableNode) MarshalJSON 

func (node *AliasGlobalVariableNode) MarshalJSON() ([]byte, error)

type AliasMethodNode 

type AliasMethodNode struct {
	Newname    Node
	Oldname    Node
	Keywordloc *Location
	Loc        *Location
}

func NewAliasMethodNode 

func NewAliasMethodNode(newName Node, oldName Node, keywordLoc *Location, loc *Location) *AliasMethodNode

func (*AliasMethodNode) Accept 

func (node *AliasMethodNode) Accept(visitor NodeVisitor)

func (*AliasMethodNode) Children 

func (node *AliasMethodNode) Children() []Node

func (*AliasMethodNode) MarshalJSON 

func (node *AliasMethodNode) MarshalJSON() ([]byte, error)

type AlternationPatternNode 

type AlternationPatternNode struct {
	Left        Node
	Right       Node
	Operatorloc *Location
	Loc         *Location
}

func NewAlternationPatternNode 

func NewAlternationPatternNode(left Node, right Node, operatorLoc *Location, loc *Location) *AlternationPatternNode

func (*AlternationPatternNode) Accept 

func (node *AlternationPatternNode) Accept(visitor NodeVisitor)

func (*AlternationPatternNode) Children 

func (node *AlternationPatternNode) Children() []Node

func (*AlternationPatternNode) MarshalJSON 

func (node *AlternationPatternNode) MarshalJSON() ([]byte, error)

type AndNode 

type AndNode struct {
	Left        Node
	Right       Node
	Operatorloc *Location
	Loc         *Location
}

func NewAndNode 

func NewAndNode(left Node, right Node, operatorLoc *Location, loc *Location) *AndNode

func (*AndNode) Accept 

func (node *AndNode) Accept(visitor NodeVisitor)

func (*AndNode) Children 

func (node *AndNode) Children() []Node

func (*AndNode) MarshalJSON 

func (node *AndNode) MarshalJSON() ([]byte, error)

type ArgumentsNode 

type ArgumentsNode struct {
	Flags     ArgumentsNodeFlags
	Arguments []Node
	Loc       *Location
}

func NewArgumentsNode 

func NewArgumentsNode(flags ArgumentsNodeFlags, arguments []Node, loc *Location) *ArgumentsNode

func (*ArgumentsNode) Accept 

func (node *ArgumentsNode) Accept(visitor NodeVisitor)

func (*ArgumentsNode) Children 

func (node *ArgumentsNode) Children() []Node

func (*ArgumentsNode) IsContainsKeywordSplat 

func (node *ArgumentsNode) IsContainsKeywordSplat() bool

func (*ArgumentsNode) MarshalJSON 

func (node *ArgumentsNode) MarshalJSON() ([]byte, error)

type ArgumentsNodeFlags 

type ArgumentsNodeFlags int16
const (
	ARGUMENTS_NODE_CONTAINS_KEYWORD_SPLAT ArgumentsNodeFlags = 1 << 0
)

type ArrayNode 

type ArrayNode struct {
	Flags      ArrayNodeFlags
	Elements   []Node
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewArrayNode 

func NewArrayNode(flags ArrayNodeFlags, elements []Node, openingLoc *Location, closingLoc *Location, loc *Location) *ArrayNode

func (*ArrayNode) Accept 

func (node *ArrayNode) Accept(visitor NodeVisitor)

func (*ArrayNode) Children 

func (node *ArrayNode) Children() []Node

func (*ArrayNode) IsContainsSplat 

func (node *ArrayNode) IsContainsSplat() bool

func (*ArrayNode) MarshalJSON 

func (node *ArrayNode) MarshalJSON() ([]byte, error)

type ArrayNodeFlags 

type ArrayNodeFlags int16
const (
	ARRAY_NODE_CONTAINS_SPLAT ArrayNodeFlags = 1 << 0
)

type ArrayPatternNode 

type ArrayPatternNode struct {
	Constant   Node
	Requireds  []Node
	Rest       Node
	Posts      []Node
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewArrayPatternNode 

func NewArrayPatternNode(constant Node, requireds []Node, rest Node, posts []Node, openingLoc *Location, closingLoc *Location, loc *Location) *ArrayPatternNode

func (*ArrayPatternNode) Accept 

func (node *ArrayPatternNode) Accept(visitor NodeVisitor)

func (*ArrayPatternNode) Children 

func (node *ArrayPatternNode) Children() []Node

func (*ArrayPatternNode) MarshalJSON 

func (node *ArrayPatternNode) MarshalJSON() ([]byte, error)

type AssocNode 

type AssocNode struct {
	Key         Node
	Value       Node
	Operatorloc *Location
	Loc         *Location
}

func NewAssocNode 

func NewAssocNode(key Node, value Node, operatorLoc *Location, loc *Location) *AssocNode

func (*AssocNode) Accept 

func (node *AssocNode) Accept(visitor NodeVisitor)

func (*AssocNode) Children 

func (node *AssocNode) Children() []Node

func (*AssocNode) MarshalJSON 

func (node *AssocNode) MarshalJSON() ([]byte, error)

type AssocSplatNode 

type AssocSplatNode struct {
	Value       Node
	Operatorloc *Location
	Loc         *Location
}

func NewAssocSplatNode 

func NewAssocSplatNode(value Node, operatorLoc *Location, loc *Location) *AssocSplatNode

func (*AssocSplatNode) Accept 

func (node *AssocSplatNode) Accept(visitor NodeVisitor)

func (*AssocSplatNode) Children 

func (node *AssocSplatNode) Children() []Node

func (*AssocSplatNode) MarshalJSON 

func (node *AssocSplatNode) MarshalJSON() ([]byte, error)

type BackReferenceReadNode 

type BackReferenceReadNode struct {
	Name string
	Loc  *Location
}

func NewBackReferenceReadNode 

func NewBackReferenceReadNode(name string, loc *Location) *BackReferenceReadNode

func (*BackReferenceReadNode) Accept 

func (node *BackReferenceReadNode) Accept(visitor NodeVisitor)

func (*BackReferenceReadNode) Children 

func (node *BackReferenceReadNode) Children() []Node

func (*BackReferenceReadNode) MarshalJSON 

func (node *BackReferenceReadNode) MarshalJSON() ([]byte, error)

type BeginNode 

type BeginNode struct {
	Beginkeywordloc *Location
	Statements      *StatementsNode
	Rescueclause    *RescueNode
	Elseclause      *ElseNode
	Ensureclause    *EnsureNode
	Endkeywordloc   *Location
	Loc             *Location
}

func NewBeginNode 

func NewBeginNode(beginKeywordLoc *Location, statements *StatementsNode, rescueClause *RescueNode, elseClause *ElseNode, ensureClause *EnsureNode, endKeywordLoc *Location, loc *Location) *BeginNode

func (*BeginNode) Accept 

func (node *BeginNode) Accept(visitor NodeVisitor)

func (*BeginNode) Children 

func (node *BeginNode) Children() []Node

func (*BeginNode) MarshalJSON 

func (node *BeginNode) MarshalJSON() ([]byte, error)

type BlockArgumentNode 

type BlockArgumentNode struct {
	Expression  Node
	Operatorloc *Location
	Loc         *Location
}

func NewBlockArgumentNode 

func NewBlockArgumentNode(expression Node, operatorLoc *Location, loc *Location) *BlockArgumentNode

func (*BlockArgumentNode) Accept 

func (node *BlockArgumentNode) Accept(visitor NodeVisitor)

func (*BlockArgumentNode) Children 

func (node *BlockArgumentNode) Children() []Node

func (*BlockArgumentNode) MarshalJSON 

func (node *BlockArgumentNode) MarshalJSON() ([]byte, error)

type BlockLocalVariableNode 

type BlockLocalVariableNode struct {
	Flags ParameterFlags
	Name  string
	Loc   *Location
}

func NewBlockLocalVariableNode 

func NewBlockLocalVariableNode(flags ParameterFlags, name string, loc *Location) *BlockLocalVariableNode

func (*BlockLocalVariableNode) Accept 

func (node *BlockLocalVariableNode) Accept(visitor NodeVisitor)

func (*BlockLocalVariableNode) Children 

func (node *BlockLocalVariableNode) Children() []Node

func (*BlockLocalVariableNode) IsRepeatedParameter 

func (node *BlockLocalVariableNode) IsRepeatedParameter() bool

func (*BlockLocalVariableNode) MarshalJSON 

func (node *BlockLocalVariableNode) MarshalJSON() ([]byte, error)

type BlockNode 

type BlockNode struct {
	Locals     []string
	Parameters Node
	Body       Node
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewBlockNode 

func NewBlockNode(locals []string, parameters Node, body Node, openingLoc *Location, closingLoc *Location, loc *Location) *BlockNode

func (*BlockNode) Accept 

func (node *BlockNode) Accept(visitor NodeVisitor)

func (*BlockNode) Children 

func (node *BlockNode) Children() []Node

func (*BlockNode) MarshalJSON 

func (node *BlockNode) MarshalJSON() ([]byte, error)

type BlockParameterNode 

type BlockParameterNode struct {
	Flags       ParameterFlags
	Name        *string
	Nameloc     *Location
	Operatorloc *Location
	Loc         *Location
}

func NewBlockParameterNode 

func NewBlockParameterNode(flags ParameterFlags, name *string, nameLoc *Location, operatorLoc *Location, loc *Location) *BlockParameterNode

func (*BlockParameterNode) Accept 

func (node *BlockParameterNode) Accept(visitor NodeVisitor)

func (*BlockParameterNode) Children 

func (node *BlockParameterNode) Children() []Node

func (*BlockParameterNode) IsRepeatedParameter 

func (node *BlockParameterNode) IsRepeatedParameter() bool

func (*BlockParameterNode) MarshalJSON 

func (node *BlockParameterNode) MarshalJSON() ([]byte, error)

type BlockParametersNode 

type BlockParametersNode struct {
	Parameters *ParametersNode
	Locals     []Node
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewBlockParametersNode 

func NewBlockParametersNode(parameters *ParametersNode, locals []Node, openingLoc *Location, closingLoc *Location, loc *Location) *BlockParametersNode

func (*BlockParametersNode) Accept 

func (node *BlockParametersNode) Accept(visitor NodeVisitor)

func (*BlockParametersNode) Children 

func (node *BlockParametersNode) Children() []Node

func (*BlockParametersNode) MarshalJSON 

func (node *BlockParametersNode) MarshalJSON() ([]byte, error)

type BreakNode 

type BreakNode struct {
	Arguments  *ArgumentsNode
	Keywordloc *Location
	Loc        *Location
}

func NewBreakNode 

func NewBreakNode(arguments *ArgumentsNode, keywordLoc *Location, loc *Location) *BreakNode

func (*BreakNode) Accept 

func (node *BreakNode) Accept(visitor NodeVisitor)

func (*BreakNode) Children 

func (node *BreakNode) Children() []Node

func (*BreakNode) MarshalJSON 

func (node *BreakNode) MarshalJSON() ([]byte, error)

type CallAndWriteNode 

type CallAndWriteNode struct {
	Flags           CallNodeFlags
	Receiver        Node
	Calloperatorloc *Location
	Messageloc      *Location
	Readname        string
	Writename       string
	Operatorloc     *Location
	Value           Node
	Loc             *Location
}

func NewCallAndWriteNode 

func NewCallAndWriteNode(flags CallNodeFlags, receiver Node, callOperatorLoc *Location, messageLoc *Location, readName string, writeName string, operatorLoc *Location, value Node, loc *Location) *CallAndWriteNode

func (*CallAndWriteNode) Accept 

func (node *CallAndWriteNode) Accept(visitor NodeVisitor)

func (*CallAndWriteNode) Children 

func (node *CallAndWriteNode) Children() []Node

func (*CallAndWriteNode) IsAttributeWrite 

func (node *CallAndWriteNode) IsAttributeWrite() bool

func (*CallAndWriteNode) IsIgnoreVisibility 

func (node *CallAndWriteNode) IsIgnoreVisibility() bool

func (*CallAndWriteNode) IsSafeNavigation 

func (node *CallAndWriteNode) IsSafeNavigation() bool

func (*CallAndWriteNode) IsVariableCall 

func (node *CallAndWriteNode) IsVariableCall() bool

func (*CallAndWriteNode) MarshalJSON 

func (node *CallAndWriteNode) MarshalJSON() ([]byte, error)

type CallNode 

type CallNode struct {
	Flags           CallNodeFlags
	Receiver        Node
	Calloperatorloc *Location
	Name            string
	Messageloc      *Location
	Openingloc      *Location
	Arguments       *ArgumentsNode
	Closingloc      *Location
	Block           Node
	Loc             *Location
}

func NewCallNode 

func NewCallNode(flags CallNodeFlags, receiver Node, callOperatorLoc *Location, name string, messageLoc *Location, openingLoc *Location, arguments *ArgumentsNode, closingLoc *Location, block Node, loc *Location) *CallNode

func (*CallNode) Accept 

func (node *CallNode) Accept(visitor NodeVisitor)

func (*CallNode) Children 

func (node *CallNode) Children() []Node

func (*CallNode) IsAttributeWrite 

func (node *CallNode) IsAttributeWrite() bool

func (*CallNode) IsIgnoreVisibility 

func (node *CallNode) IsIgnoreVisibility() bool

func (*CallNode) IsSafeNavigation 

func (node *CallNode) IsSafeNavigation() bool

func (*CallNode) IsVariableCall 

func (node *CallNode) IsVariableCall() bool

func (*CallNode) MarshalJSON 

func (node *CallNode) MarshalJSON() ([]byte, error)

type CallNodeFlags 

type CallNodeFlags int16
const (
	CALL_NODE_SAFE_NAVIGATION   CallNodeFlags = 1 << 0
	CALL_NODE_VARIABLE_CALL     CallNodeFlags = 1 << 1
	CALL_NODE_ATTRIBUTE_WRITE   CallNodeFlags = 1 << 2
	CALL_NODE_IGNORE_VISIBILITY CallNodeFlags = 1 << 3
)

type CallOperatorWriteNode 

type CallOperatorWriteNode struct {
	Flags           CallNodeFlags
	Receiver        Node
	Calloperatorloc *Location
	Messageloc      *Location
	Readname        string
	Writename       string
	Operator        string
	Operatorloc     *Location
	Value           Node
	Loc             *Location
}

func NewCallOperatorWriteNode 

func NewCallOperatorWriteNode(flags CallNodeFlags, receiver Node, callOperatorLoc *Location, messageLoc *Location, readName string, writeName string, operator string, operatorLoc *Location, value Node, loc *Location) *CallOperatorWriteNode

func (*CallOperatorWriteNode) Accept 

func (node *CallOperatorWriteNode) Accept(visitor NodeVisitor)

func (*CallOperatorWriteNode) Children 

func (node *CallOperatorWriteNode) Children() []Node

func (*CallOperatorWriteNode) IsAttributeWrite 

func (node *CallOperatorWriteNode) IsAttributeWrite() bool

func (*CallOperatorWriteNode) IsIgnoreVisibility 

func (node *CallOperatorWriteNode) IsIgnoreVisibility() bool

func (*CallOperatorWriteNode) IsSafeNavigation 

func (node *CallOperatorWriteNode) IsSafeNavigation() bool

func (*CallOperatorWriteNode) IsVariableCall 

func (node *CallOperatorWriteNode) IsVariableCall() bool

func (*CallOperatorWriteNode) MarshalJSON 

func (node *CallOperatorWriteNode) MarshalJSON() ([]byte, error)

type CallOrWriteNode 

type CallOrWriteNode struct {
	Flags           CallNodeFlags
	Receiver        Node
	Calloperatorloc *Location
	Messageloc      *Location
	Readname        string
	Writename       string
	Operatorloc     *Location
	Value           Node
	Loc             *Location
}

func NewCallOrWriteNode 

func NewCallOrWriteNode(flags CallNodeFlags, receiver Node, callOperatorLoc *Location, messageLoc *Location, readName string, writeName string, operatorLoc *Location, value Node, loc *Location) *CallOrWriteNode

func (*CallOrWriteNode) Accept 

func (node *CallOrWriteNode) Accept(visitor NodeVisitor)

func (*CallOrWriteNode) Children 

func (node *CallOrWriteNode) Children() []Node

func (*CallOrWriteNode) IsAttributeWrite 

func (node *CallOrWriteNode) IsAttributeWrite() bool

func (*CallOrWriteNode) IsIgnoreVisibility 

func (node *CallOrWriteNode) IsIgnoreVisibility() bool

func (*CallOrWriteNode) IsSafeNavigation 

func (node *CallOrWriteNode) IsSafeNavigation() bool

func (*CallOrWriteNode) IsVariableCall 

func (node *CallOrWriteNode) IsVariableCall() bool

func (*CallOrWriteNode) MarshalJSON 

func (node *CallOrWriteNode) MarshalJSON() ([]byte, error)

type CallTargetNode 

type CallTargetNode struct {
	Flags           CallNodeFlags
	Receiver        Node
	Calloperatorloc *Location
	Name            string
	Messageloc      *Location
	Loc             *Location
}

func NewCallTargetNode 

func NewCallTargetNode(flags CallNodeFlags, receiver Node, callOperatorLoc *Location, name string, messageLoc *Location, loc *Location) *CallTargetNode

func (*CallTargetNode) Accept 

func (node *CallTargetNode) Accept(visitor NodeVisitor)

func (*CallTargetNode) Children 

func (node *CallTargetNode) Children() []Node

func (*CallTargetNode) IsAttributeWrite 

func (node *CallTargetNode) IsAttributeWrite() bool

func (*CallTargetNode) IsIgnoreVisibility 

func (node *CallTargetNode) IsIgnoreVisibility() bool

func (*CallTargetNode) IsSafeNavigation 

func (node *CallTargetNode) IsSafeNavigation() bool

func (*CallTargetNode) IsVariableCall 

func (node *CallTargetNode) IsVariableCall() bool

func (*CallTargetNode) MarshalJSON 

func (node *CallTargetNode) MarshalJSON() ([]byte, error)

type CapturePatternNode 

type CapturePatternNode struct {
	Value       Node
	Target      Node
	Operatorloc *Location
	Loc         *Location
}

func NewCapturePatternNode 

func NewCapturePatternNode(value Node, target Node, operatorLoc *Location, loc *Location) *CapturePatternNode

func (*CapturePatternNode) Accept 

func (node *CapturePatternNode) Accept(visitor NodeVisitor)

func (*CapturePatternNode) Children 

func (node *CapturePatternNode) Children() []Node

func (*CapturePatternNode) MarshalJSON 

func (node *CapturePatternNode) MarshalJSON() ([]byte, error)

type CaseMatchNode 

type CaseMatchNode struct {
	Predicate      Node
	Conditions     []Node
	Consequent     *ElseNode
	Casekeywordloc *Location
	Endkeywordloc  *Location
	Loc            *Location
}

func NewCaseMatchNode 

func NewCaseMatchNode(predicate Node, conditions []Node, consequent *ElseNode, caseKeywordLoc *Location, endKeywordLoc *Location, loc *Location) *CaseMatchNode

func (*CaseMatchNode) Accept 

func (node *CaseMatchNode) Accept(visitor NodeVisitor)

func (*CaseMatchNode) Children 

func (node *CaseMatchNode) Children() []Node

func (*CaseMatchNode) MarshalJSON 

func (node *CaseMatchNode) MarshalJSON() ([]byte, error)

type CaseNode 

type CaseNode struct {
	Predicate      Node
	Conditions     []Node
	Consequent     *ElseNode
	Casekeywordloc *Location
	Endkeywordloc  *Location
	Loc            *Location
}

func NewCaseNode 

func NewCaseNode(predicate Node, conditions []Node, consequent *ElseNode, caseKeywordLoc *Location, endKeywordLoc *Location, loc *Location) *CaseNode

func (*CaseNode) Accept 

func (node *CaseNode) Accept(visitor NodeVisitor)

func (*CaseNode) Children 

func (node *CaseNode) Children() []Node

func (*CaseNode) MarshalJSON 

func (node *CaseNode) MarshalJSON() ([]byte, error)

type ClassNode 

type ClassNode struct {
	Locals                 []string
	Classkeywordloc        *Location
	Constantpath           Node
	Inheritanceoperatorloc *Location
	Superclass             Node
	Body                   Node
	Endkeywordloc          *Location
	Name                   string
	Loc                    *Location
}

func NewClassNode 

func NewClassNode(locals []string, classKeywordLoc *Location, constantPath Node, inheritanceOperatorLoc *Location, superclass Node, body Node, endKeywordLoc *Location, name string, loc *Location) *ClassNode

func (*ClassNode) Accept 

func (node *ClassNode) Accept(visitor NodeVisitor)

func (*ClassNode) Children 

func (node *ClassNode) Children() []Node

func (*ClassNode) MarshalJSON 

func (node *ClassNode) MarshalJSON() ([]byte, error)

type ClassVariableAndWriteNode 

type ClassVariableAndWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewClassVariableAndWriteNode 

func NewClassVariableAndWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *ClassVariableAndWriteNode

func (*ClassVariableAndWriteNode) Accept 

func (node *ClassVariableAndWriteNode) Accept(visitor NodeVisitor)

func (*ClassVariableAndWriteNode) Children 

func (node *ClassVariableAndWriteNode) Children() []Node

func (*ClassVariableAndWriteNode) MarshalJSON 

func (node *ClassVariableAndWriteNode) MarshalJSON() ([]byte, error)

type ClassVariableOperatorWriteNode 

type ClassVariableOperatorWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Operator    string
	Loc         *Location
}

func NewClassVariableOperatorWriteNode 

func NewClassVariableOperatorWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, operator string, loc *Location) *ClassVariableOperatorWriteNode

func (*ClassVariableOperatorWriteNode) Accept 

func (node *ClassVariableOperatorWriteNode) Accept(visitor NodeVisitor)

func (*ClassVariableOperatorWriteNode) Children 

func (node *ClassVariableOperatorWriteNode) Children() []Node

func (*ClassVariableOperatorWriteNode) MarshalJSON 

func (node *ClassVariableOperatorWriteNode) MarshalJSON() ([]byte, error)

type ClassVariableOrWriteNode 

type ClassVariableOrWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewClassVariableOrWriteNode 

func NewClassVariableOrWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *ClassVariableOrWriteNode

func (*ClassVariableOrWriteNode) Accept 

func (node *ClassVariableOrWriteNode) Accept(visitor NodeVisitor)

func (*ClassVariableOrWriteNode) Children 

func (node *ClassVariableOrWriteNode) Children() []Node

func (*ClassVariableOrWriteNode) MarshalJSON 

func (node *ClassVariableOrWriteNode) MarshalJSON() ([]byte, error)

type ClassVariableReadNode 

type ClassVariableReadNode struct {
	Name string
	Loc  *Location
}

func NewClassVariableReadNode 

func NewClassVariableReadNode(name string, loc *Location) *ClassVariableReadNode

func (*ClassVariableReadNode) Accept 

func (node *ClassVariableReadNode) Accept(visitor NodeVisitor)

func (*ClassVariableReadNode) Children 

func (node *ClassVariableReadNode) Children() []Node

func (*ClassVariableReadNode) MarshalJSON 

func (node *ClassVariableReadNode) MarshalJSON() ([]byte, error)

type ClassVariableTargetNode 

type ClassVariableTargetNode struct {
	Name string
	Loc  *Location
}

func NewClassVariableTargetNode 

func NewClassVariableTargetNode(name string, loc *Location) *ClassVariableTargetNode

func (*ClassVariableTargetNode) Accept 

func (node *ClassVariableTargetNode) Accept(visitor NodeVisitor)

func (*ClassVariableTargetNode) Children 

func (node *ClassVariableTargetNode) Children() []Node

func (*ClassVariableTargetNode) MarshalJSON 

func (node *ClassVariableTargetNode) MarshalJSON() ([]byte, error)

type ClassVariableWriteNode 

type ClassVariableWriteNode struct {
	Name        string
	Nameloc     *Location
	Value       Node
	Operatorloc *Location
	Loc         *Location
}

func NewClassVariableWriteNode 

func NewClassVariableWriteNode(name string, nameLoc *Location, value Node, operatorLoc *Location, loc *Location) *ClassVariableWriteNode

func (*ClassVariableWriteNode) Accept 

func (node *ClassVariableWriteNode) Accept(visitor NodeVisitor)

func (*ClassVariableWriteNode) Children 

func (node *ClassVariableWriteNode) Children() []Node

func (*ClassVariableWriteNode) MarshalJSON 

func (node *ClassVariableWriteNode) MarshalJSON() ([]byte, error)

type Comment 

type Comment struct {
	Typpe uint32
	Loc   *Location
}

func NewComment 

func NewComment(typpe uint32, loc *Location) *Comment

func (*Comment) MarshalJSON 

func (c *Comment) MarshalJSON() ([]byte, error)

type ConstantAndWriteNode 

type ConstantAndWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewConstantAndWriteNode 

func NewConstantAndWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *ConstantAndWriteNode

func (*ConstantAndWriteNode) Accept 

func (node *ConstantAndWriteNode) Accept(visitor NodeVisitor)

func (*ConstantAndWriteNode) Children 

func (node *ConstantAndWriteNode) Children() []Node

func (*ConstantAndWriteNode) MarshalJSON 

func (node *ConstantAndWriteNode) MarshalJSON() ([]byte, error)

type ConstantOperatorWriteNode 

type ConstantOperatorWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Operator    string
	Loc         *Location
}

func NewConstantOperatorWriteNode 

func NewConstantOperatorWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, operator string, loc *Location) *ConstantOperatorWriteNode

func (*ConstantOperatorWriteNode) Accept 

func (node *ConstantOperatorWriteNode) Accept(visitor NodeVisitor)

func (*ConstantOperatorWriteNode) Children 

func (node *ConstantOperatorWriteNode) Children() []Node

func (*ConstantOperatorWriteNode) MarshalJSON 

func (node *ConstantOperatorWriteNode) MarshalJSON() ([]byte, error)

type ConstantOrWriteNode 

type ConstantOrWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewConstantOrWriteNode 

func NewConstantOrWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *ConstantOrWriteNode

func (*ConstantOrWriteNode) Accept 

func (node *ConstantOrWriteNode) Accept(visitor NodeVisitor)

func (*ConstantOrWriteNode) Children 

func (node *ConstantOrWriteNode) Children() []Node

func (*ConstantOrWriteNode) MarshalJSON 

func (node *ConstantOrWriteNode) MarshalJSON() ([]byte, error)

type ConstantPathAndWriteNode 

type ConstantPathAndWriteNode struct {
	Target      *ConstantPathNode
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewConstantPathAndWriteNode 

func NewConstantPathAndWriteNode(target *ConstantPathNode, operatorLoc *Location, value Node, loc *Location) *ConstantPathAndWriteNode

func (*ConstantPathAndWriteNode) Accept 

func (node *ConstantPathAndWriteNode) Accept(visitor NodeVisitor)

func (*ConstantPathAndWriteNode) Children 

func (node *ConstantPathAndWriteNode) Children() []Node

func (*ConstantPathAndWriteNode) MarshalJSON 

func (node *ConstantPathAndWriteNode) MarshalJSON() ([]byte, error)

type ConstantPathNode 

type ConstantPathNode struct {
	Parent       Node
	Child        Node
	Delimiterloc *Location
	Loc          *Location
}

func NewConstantPathNode 

func NewConstantPathNode(parent Node, child Node, delimiterLoc *Location, loc *Location) *ConstantPathNode

func (*ConstantPathNode) Accept 

func (node *ConstantPathNode) Accept(visitor NodeVisitor)

func (*ConstantPathNode) Children 

func (node *ConstantPathNode) Children() []Node

func (*ConstantPathNode) MarshalJSON 

func (node *ConstantPathNode) MarshalJSON() ([]byte, error)

type ConstantPathOperatorWriteNode 

type ConstantPathOperatorWriteNode struct {
	Target      *ConstantPathNode
	Operatorloc *Location
	Value       Node
	Operator    string
	Loc         *Location
}

func NewConstantPathOperatorWriteNode 

func NewConstantPathOperatorWriteNode(target *ConstantPathNode, operatorLoc *Location, value Node, operator string, loc *Location) *ConstantPathOperatorWriteNode

func (*ConstantPathOperatorWriteNode) Accept 

func (node *ConstantPathOperatorWriteNode) Accept(visitor NodeVisitor)

func (*ConstantPathOperatorWriteNode) Children 

func (node *ConstantPathOperatorWriteNode) Children() []Node

func (*ConstantPathOperatorWriteNode) MarshalJSON 

func (node *ConstantPathOperatorWriteNode) MarshalJSON() ([]byte, error)

type ConstantPathOrWriteNode 

type ConstantPathOrWriteNode struct {
	Target      *ConstantPathNode
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewConstantPathOrWriteNode 

func NewConstantPathOrWriteNode(target *ConstantPathNode, operatorLoc *Location, value Node, loc *Location) *ConstantPathOrWriteNode

func (*ConstantPathOrWriteNode) Accept 

func (node *ConstantPathOrWriteNode) Accept(visitor NodeVisitor)

func (*ConstantPathOrWriteNode) Children 

func (node *ConstantPathOrWriteNode) Children() []Node

func (*ConstantPathOrWriteNode) MarshalJSON 

func (node *ConstantPathOrWriteNode) MarshalJSON() ([]byte, error)

type ConstantPathTargetNode 

type ConstantPathTargetNode struct {
	Parent       Node
	Child        Node
	Delimiterloc *Location
	Loc          *Location
}

func NewConstantPathTargetNode 

func NewConstantPathTargetNode(parent Node, child Node, delimiterLoc *Location, loc *Location) *ConstantPathTargetNode

func (*ConstantPathTargetNode) Accept 

func (node *ConstantPathTargetNode) Accept(visitor NodeVisitor)

func (*ConstantPathTargetNode) Children 

func (node *ConstantPathTargetNode) Children() []Node

func (*ConstantPathTargetNode) MarshalJSON 

func (node *ConstantPathTargetNode) MarshalJSON() ([]byte, error)

type ConstantPathWriteNode 

type ConstantPathWriteNode struct {
	Target      *ConstantPathNode
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewConstantPathWriteNode 

func NewConstantPathWriteNode(target *ConstantPathNode, operatorLoc *Location, value Node, loc *Location) *ConstantPathWriteNode

func (*ConstantPathWriteNode) Accept 

func (node *ConstantPathWriteNode) Accept(visitor NodeVisitor)

func (*ConstantPathWriteNode) Children 

func (node *ConstantPathWriteNode) Children() []Node

func (*ConstantPathWriteNode) MarshalJSON 

func (node *ConstantPathWriteNode) MarshalJSON() ([]byte, error)

type ConstantReadNode 

type ConstantReadNode struct {
	Name string
	Loc  *Location
}

func NewConstantReadNode 

func NewConstantReadNode(name string, loc *Location) *ConstantReadNode

func (*ConstantReadNode) Accept 

func (node *ConstantReadNode) Accept(visitor NodeVisitor)

func (*ConstantReadNode) Children 

func (node *ConstantReadNode) Children() []Node

func (*ConstantReadNode) MarshalJSON 

func (node *ConstantReadNode) MarshalJSON() ([]byte, error)

type ConstantTargetNode 

type ConstantTargetNode struct {
	Name string
	Loc  *Location
}

func NewConstantTargetNode 

func NewConstantTargetNode(name string, loc *Location) *ConstantTargetNode

func (*ConstantTargetNode) Accept 

func (node *ConstantTargetNode) Accept(visitor NodeVisitor)

func (*ConstantTargetNode) Children 

func (node *ConstantTargetNode) Children() []Node

func (*ConstantTargetNode) MarshalJSON 

func (node *ConstantTargetNode) MarshalJSON() ([]byte, error)

type ConstantWriteNode 

type ConstantWriteNode struct {
	Name        string
	Nameloc     *Location
	Value       Node
	Operatorloc *Location
	Loc         *Location
}

func NewConstantWriteNode 

func NewConstantWriteNode(name string, nameLoc *Location, value Node, operatorLoc *Location, loc *Location) *ConstantWriteNode

func (*ConstantWriteNode) Accept 

func (node *ConstantWriteNode) Accept(visitor NodeVisitor)

func (*ConstantWriteNode) Children 

func (node *ConstantWriteNode) Children() []Node

func (*ConstantWriteNode) MarshalJSON 

func (node *ConstantWriteNode) MarshalJSON() ([]byte, error)

type DefNode 

type DefNode struct {
	Name          string
	Nameloc       *Location
	Receiver      Node
	Parameters    *ParametersNode
	Body          Node
	Locals        []string
	Defkeywordloc *Location
	Operatorloc   *Location
	Lparenloc     *Location
	Rparenloc     *Location
	Equalloc      *Location
	Endkeywordloc *Location
	Loc           *Location
}

func NewDefNode 

func NewDefNode(name string, nameLoc *Location, receiver Node, parameters *ParametersNode, body Node, locals []string, defKeywordLoc *Location, operatorLoc *Location, lparenLoc *Location, rparenLoc *Location, equalLoc *Location, endKeywordLoc *Location, loc *Location) *DefNode

func (*DefNode) Accept 

func (node *DefNode) Accept(visitor NodeVisitor)

func (*DefNode) Children 

func (node *DefNode) Children() []Node

func (*DefNode) MarshalJSON 

func (node *DefNode) MarshalJSON() ([]byte, error)

type DefinedNode 

type DefinedNode struct {
	Lparenloc  *Location
	Value      Node
	Rparenloc  *Location
	Keywordloc *Location
	Loc        *Location
}

func NewDefinedNode 

func NewDefinedNode(lparenLoc *Location, value Node, rparenLoc *Location, keywordLoc *Location, loc *Location) *DefinedNode

func (*DefinedNode) Accept 

func (node *DefinedNode) Accept(visitor NodeVisitor)

func (*DefinedNode) Children 

func (node *DefinedNode) Children() []Node

func (*DefinedNode) MarshalJSON 

func (node *DefinedNode) MarshalJSON() ([]byte, error)

type ElseNode 

type ElseNode struct {
	Elsekeywordloc *Location
	Statements     *StatementsNode
	Endkeywordloc  *Location
	Loc            *Location
}

func NewElseNode 

func NewElseNode(elseKeywordLoc *Location, statements *StatementsNode, endKeywordLoc *Location, loc *Location) *ElseNode

func (*ElseNode) Accept 

func (node *ElseNode) Accept(visitor NodeVisitor)

func (*ElseNode) Children 

func (node *ElseNode) Children() []Node

func (*ElseNode) MarshalJSON 

func (node *ElseNode) MarshalJSON() ([]byte, error)

type EmbeddedStatementsNode 

type EmbeddedStatementsNode struct {
	Openingloc *Location
	Statements *StatementsNode
	Closingloc *Location
	Loc        *Location
}

func NewEmbeddedStatementsNode 

func NewEmbeddedStatementsNode(openingLoc *Location, statements *StatementsNode, closingLoc *Location, loc *Location) *EmbeddedStatementsNode

func (*EmbeddedStatementsNode) Accept 

func (node *EmbeddedStatementsNode) Accept(visitor NodeVisitor)

func (*EmbeddedStatementsNode) Children 

func (node *EmbeddedStatementsNode) Children() []Node

func (*EmbeddedStatementsNode) MarshalJSON 

func (node *EmbeddedStatementsNode) MarshalJSON() ([]byte, error)

type EmbeddedVariableNode 

type EmbeddedVariableNode struct {
	Operatorloc *Location
	Variable    Node
	Loc         *Location
}

func NewEmbeddedVariableNode 

func NewEmbeddedVariableNode(operatorLoc *Location, variable Node, loc *Location) *EmbeddedVariableNode

func (*EmbeddedVariableNode) Accept 

func (node *EmbeddedVariableNode) Accept(visitor NodeVisitor)

func (*EmbeddedVariableNode) Children 

func (node *EmbeddedVariableNode) Children() []Node

func (*EmbeddedVariableNode) MarshalJSON 

func (node *EmbeddedVariableNode) MarshalJSON() ([]byte, error)

type EncodingFlags 

type EncodingFlags int16
const (
	ENCODING_FORCED_UTF8_ENCODING   EncodingFlags = 1 << 0
	ENCODING_FORCED_BINARY_ENCODING EncodingFlags = 1 << 1
)

type EnsureNode 

type EnsureNode struct {
	Ensurekeywordloc *Location
	Statements       *StatementsNode
	Endkeywordloc    *Location
	Loc              *Location
}

func NewEnsureNode 

func NewEnsureNode(ensureKeywordLoc *Location, statements *StatementsNode, endKeywordLoc *Location, loc *Location) *EnsureNode

func (*EnsureNode) Accept 

func (node *EnsureNode) Accept(visitor NodeVisitor)

func (*EnsureNode) Children 

func (node *EnsureNode) Children() []Node

func (*EnsureNode) MarshalJSON 

func (node *EnsureNode) MarshalJSON() ([]byte, error)

type FalseNode 

type FalseNode struct {
	Loc *Location
}

func NewFalseNode 

func NewFalseNode(loc *Location) *FalseNode

func (*FalseNode) Accept 

func (node *FalseNode) Accept(visitor NodeVisitor)

func (*FalseNode) Children 

func (node *FalseNode) Children() []Node

func (*FalseNode) MarshalJSON 

func (node *FalseNode) MarshalJSON() ([]byte, error)

type FindPatternNode 

type FindPatternNode struct {
	Constant   Node
	Left       Node
	Requireds  []Node
	Right      Node
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewFindPatternNode 

func NewFindPatternNode(constant Node, left Node, requireds []Node, right Node, openingLoc *Location, closingLoc *Location, loc *Location) *FindPatternNode

func (*FindPatternNode) Accept 

func (node *FindPatternNode) Accept(visitor NodeVisitor)

func (*FindPatternNode) Children 

func (node *FindPatternNode) Children() []Node

func (*FindPatternNode) MarshalJSON 

func (node *FindPatternNode) MarshalJSON() ([]byte, error)

type FlipFlopNode 

type FlipFlopNode struct {
	Flags       RangeFlags
	Left        Node
	Right       Node
	Operatorloc *Location
	Loc         *Location
}

func NewFlipFlopNode 

func NewFlipFlopNode(flags RangeFlags, left Node, right Node, operatorLoc *Location, loc *Location) *FlipFlopNode

func (*FlipFlopNode) Accept 

func (node *FlipFlopNode) Accept(visitor NodeVisitor)

func (*FlipFlopNode) Children 

func (node *FlipFlopNode) Children() []Node

func (*FlipFlopNode) IsExcludeEnd 

func (node *FlipFlopNode) IsExcludeEnd() bool

func (*FlipFlopNode) MarshalJSON 

func (node *FlipFlopNode) MarshalJSON() ([]byte, error)

type FloatNode 

type FloatNode struct {
	Value float64
	Loc   *Location
}

func NewFloatNode 

func NewFloatNode(value float64, loc *Location) *FloatNode

func (*FloatNode) Accept 

func (node *FloatNode) Accept(visitor NodeVisitor)

func (*FloatNode) Children 

func (node *FloatNode) Children() []Node

func (*FloatNode) MarshalJSON 

func (node *FloatNode) MarshalJSON() ([]byte, error)

type ForNode 

type ForNode struct {
	Index         Node
	Collection    Node
	Statements    *StatementsNode
	Forkeywordloc *Location
	Inkeywordloc  *Location
	Dokeywordloc  *Location
	Endkeywordloc *Location
	Loc           *Location
}

func NewForNode 

func NewForNode(index Node, collection Node, statements *StatementsNode, forKeywordLoc *Location, inKeywordLoc *Location, doKeywordLoc *Location, endKeywordLoc *Location, loc *Location) *ForNode

func (*ForNode) Accept 

func (node *ForNode) Accept(visitor NodeVisitor)

func (*ForNode) Children 

func (node *ForNode) Children() []Node

func (*ForNode) MarshalJSON 

func (node *ForNode) MarshalJSON() ([]byte, error)

type ForwardingArgumentsNode 

type ForwardingArgumentsNode struct {
	Loc *Location
}

func NewForwardingArgumentsNode 

func NewForwardingArgumentsNode(loc *Location) *ForwardingArgumentsNode

func (*ForwardingArgumentsNode) Accept 

func (node *ForwardingArgumentsNode) Accept(visitor NodeVisitor)

func (*ForwardingArgumentsNode) Children 

func (node *ForwardingArgumentsNode) Children() []Node

func (*ForwardingArgumentsNode) MarshalJSON 

func (node *ForwardingArgumentsNode) MarshalJSON() ([]byte, error)

type ForwardingParameterNode 

type ForwardingParameterNode struct {
	Loc *Location
}

func NewForwardingParameterNode 

func NewForwardingParameterNode(loc *Location) *ForwardingParameterNode

func (*ForwardingParameterNode) Accept 

func (node *ForwardingParameterNode) Accept(visitor NodeVisitor)

func (*ForwardingParameterNode) Children 

func (node *ForwardingParameterNode) Children() []Node

func (*ForwardingParameterNode) MarshalJSON 

func (node *ForwardingParameterNode) MarshalJSON() ([]byte, error)

type ForwardingSuperNode 

type ForwardingSuperNode struct {
	Block *BlockNode
	Loc   *Location
}

func NewForwardingSuperNode 

func NewForwardingSuperNode(block *BlockNode, loc *Location) *ForwardingSuperNode

func (*ForwardingSuperNode) Accept 

func (node *ForwardingSuperNode) Accept(visitor NodeVisitor)

func (*ForwardingSuperNode) Children 

func (node *ForwardingSuperNode) Children() []Node

func (*ForwardingSuperNode) MarshalJSON 

func (node *ForwardingSuperNode) MarshalJSON() ([]byte, error)

type GlobalVariableAndWriteNode 

type GlobalVariableAndWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewGlobalVariableAndWriteNode 

func NewGlobalVariableAndWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *GlobalVariableAndWriteNode

func (*GlobalVariableAndWriteNode) Accept 

func (node *GlobalVariableAndWriteNode) Accept(visitor NodeVisitor)

func (*GlobalVariableAndWriteNode) Children 

func (node *GlobalVariableAndWriteNode) Children() []Node

func (*GlobalVariableAndWriteNode) MarshalJSON 

func (node *GlobalVariableAndWriteNode) MarshalJSON() ([]byte, error)

type GlobalVariableOperatorWriteNode 

type GlobalVariableOperatorWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Operator    string
	Loc         *Location
}

func NewGlobalVariableOperatorWriteNode 

func NewGlobalVariableOperatorWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, operator string, loc *Location) *GlobalVariableOperatorWriteNode

func (*GlobalVariableOperatorWriteNode) Accept 

func (node *GlobalVariableOperatorWriteNode) Accept(visitor NodeVisitor)

func (*GlobalVariableOperatorWriteNode) Children 

func (node *GlobalVariableOperatorWriteNode) Children() []Node

func (*GlobalVariableOperatorWriteNode) MarshalJSON 

func (node *GlobalVariableOperatorWriteNode) MarshalJSON() ([]byte, error)

type GlobalVariableOrWriteNode 

type GlobalVariableOrWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewGlobalVariableOrWriteNode 

func NewGlobalVariableOrWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *GlobalVariableOrWriteNode

func (*GlobalVariableOrWriteNode) Accept 

func (node *GlobalVariableOrWriteNode) Accept(visitor NodeVisitor)

func (*GlobalVariableOrWriteNode) Children 

func (node *GlobalVariableOrWriteNode) Children() []Node

func (*GlobalVariableOrWriteNode) MarshalJSON 

func (node *GlobalVariableOrWriteNode) MarshalJSON() ([]byte, error)

type GlobalVariableReadNode 

type GlobalVariableReadNode struct {
	Name string
	Loc  *Location
}

func NewGlobalVariableReadNode 

func NewGlobalVariableReadNode(name string, loc *Location) *GlobalVariableReadNode

func (*GlobalVariableReadNode) Accept 

func (node *GlobalVariableReadNode) Accept(visitor NodeVisitor)

func (*GlobalVariableReadNode) Children 

func (node *GlobalVariableReadNode) Children() []Node

func (*GlobalVariableReadNode) MarshalJSON 

func (node *GlobalVariableReadNode) MarshalJSON() ([]byte, error)

type GlobalVariableTargetNode 

type GlobalVariableTargetNode struct {
	Name string
	Loc  *Location
}

func NewGlobalVariableTargetNode 

func NewGlobalVariableTargetNode(name string, loc *Location) *GlobalVariableTargetNode

func (*GlobalVariableTargetNode) Accept 

func (node *GlobalVariableTargetNode) Accept(visitor NodeVisitor)

func (*GlobalVariableTargetNode) Children 

func (node *GlobalVariableTargetNode) Children() []Node

func (*GlobalVariableTargetNode) MarshalJSON 

func (node *GlobalVariableTargetNode) MarshalJSON() ([]byte, error)

type GlobalVariableWriteNode 

type GlobalVariableWriteNode struct {
	Name        string
	Nameloc     *Location
	Value       Node
	Operatorloc *Location
	Loc         *Location
}

func NewGlobalVariableWriteNode 

func NewGlobalVariableWriteNode(name string, nameLoc *Location, value Node, operatorLoc *Location, loc *Location) *GlobalVariableWriteNode

func (*GlobalVariableWriteNode) Accept 

func (node *GlobalVariableWriteNode) Accept(visitor NodeVisitor)

func (*GlobalVariableWriteNode) Children 

func (node *GlobalVariableWriteNode) Children() []Node

func (*GlobalVariableWriteNode) MarshalJSON 

func (node *GlobalVariableWriteNode) MarshalJSON() ([]byte, error)

type HashNode 

type HashNode struct {
	Openingloc *Location
	Elements   []Node
	Closingloc *Location
	Loc        *Location
}

func NewHashNode 

func NewHashNode(openingLoc *Location, elements []Node, closingLoc *Location, loc *Location) *HashNode

func (*HashNode) Accept 

func (node *HashNode) Accept(visitor NodeVisitor)

func (*HashNode) Children 

func (node *HashNode) Children() []Node

func (*HashNode) MarshalJSON 

func (node *HashNode) MarshalJSON() ([]byte, error)

type HashPatternNode 

type HashPatternNode struct {
	Constant   Node
	Elements   []Node
	Rest       Node
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewHashPatternNode 

func NewHashPatternNode(constant Node, elements []Node, rest Node, openingLoc *Location, closingLoc *Location, loc *Location) *HashPatternNode

func (*HashPatternNode) Accept 

func (node *HashPatternNode) Accept(visitor NodeVisitor)

func (*HashPatternNode) Children 

func (node *HashPatternNode) Children() []Node

func (*HashPatternNode) MarshalJSON 

func (node *HashPatternNode) MarshalJSON() ([]byte, error)

type IfNode 

type IfNode struct {
	Ifkeywordloc   *Location
	Predicate      Node
	Thenkeywordloc *Location
	Statements     *StatementsNode
	Consequent     Node
	Endkeywordloc  *Location
	Loc            *Location
}

func NewIfNode 

func NewIfNode(ifKeywordLoc *Location, predicate Node, thenKeywordLoc *Location, statements *StatementsNode, consequent Node, endKeywordLoc *Location, loc *Location) *IfNode

func (*IfNode) Accept 

func (node *IfNode) Accept(visitor NodeVisitor)

func (*IfNode) Children 

func (node *IfNode) Children() []Node

func (*IfNode) MarshalJSON 

func (node *IfNode) MarshalJSON() ([]byte, error)

type ImaginaryNode 

type ImaginaryNode struct {
	Numeric Node
	Loc     *Location
}

func NewImaginaryNode 

func NewImaginaryNode(numeric Node, loc *Location) *ImaginaryNode

func (*ImaginaryNode) Accept 

func (node *ImaginaryNode) Accept(visitor NodeVisitor)

func (*ImaginaryNode) Children 

func (node *ImaginaryNode) Children() []Node

func (*ImaginaryNode) MarshalJSON 

func (node *ImaginaryNode) MarshalJSON() ([]byte, error)

type ImplicitNode 

type ImplicitNode struct {
	Value Node
	Loc   *Location
}

func NewImplicitNode 

func NewImplicitNode(value Node, loc *Location) *ImplicitNode

func (*ImplicitNode) Accept 

func (node *ImplicitNode) Accept(visitor NodeVisitor)

func (*ImplicitNode) Children 

func (node *ImplicitNode) Children() []Node

func (*ImplicitNode) MarshalJSON 

func (node *ImplicitNode) MarshalJSON() ([]byte, error)

type ImplicitRestNode 

type ImplicitRestNode struct {
	Loc *Location
}

func NewImplicitRestNode 

func NewImplicitRestNode(loc *Location) *ImplicitRestNode

func (*ImplicitRestNode) Accept 

func (node *ImplicitRestNode) Accept(visitor NodeVisitor)

func (*ImplicitRestNode) Children 

func (node *ImplicitRestNode) Children() []Node

func (*ImplicitRestNode) MarshalJSON 

func (node *ImplicitRestNode) MarshalJSON() ([]byte, error)

type InNode 

type InNode struct {
	Pattern    Node
	Statements *StatementsNode
	Inloc      *Location
	Thenloc    *Location
	Loc        *Location
}

func NewInNode 

func NewInNode(pattern Node, statements *StatementsNode, inLoc *Location, thenLoc *Location, loc *Location) *InNode

func (*InNode) Accept 

func (node *InNode) Accept(visitor NodeVisitor)

func (*InNode) Children 

func (node *InNode) Children() []Node

func (*InNode) MarshalJSON 

func (node *InNode) MarshalJSON() ([]byte, error)

type IndexAndWriteNode 

type IndexAndWriteNode struct {
	Flags           CallNodeFlags
	Receiver        Node
	Calloperatorloc *Location
	Openingloc      *Location
	Arguments       *ArgumentsNode
	Closingloc      *Location
	Block           Node
	Operatorloc     *Location
	Value           Node
	Loc             *Location
}

func NewIndexAndWriteNode 

func NewIndexAndWriteNode(flags CallNodeFlags, receiver Node, callOperatorLoc *Location, openingLoc *Location, arguments *ArgumentsNode, closingLoc *Location, block Node, operatorLoc *Location, value Node, loc *Location) *IndexAndWriteNode

func (*IndexAndWriteNode) Accept 

func (node *IndexAndWriteNode) Accept(visitor NodeVisitor)

func (*IndexAndWriteNode) Children 

func (node *IndexAndWriteNode) Children() []Node

func (*IndexAndWriteNode) IsAttributeWrite 

func (node *IndexAndWriteNode) IsAttributeWrite() bool

func (*IndexAndWriteNode) IsIgnoreVisibility 

func (node *IndexAndWriteNode) IsIgnoreVisibility() bool

func (*IndexAndWriteNode) IsSafeNavigation 

func (node *IndexAndWriteNode) IsSafeNavigation() bool

func (*IndexAndWriteNode) IsVariableCall 

func (node *IndexAndWriteNode) IsVariableCall() bool

func (*IndexAndWriteNode) MarshalJSON 

func (node *IndexAndWriteNode) MarshalJSON() ([]byte, error)

type IndexOperatorWriteNode 

type IndexOperatorWriteNode struct {
	Flags           CallNodeFlags
	Receiver        Node
	Calloperatorloc *Location
	Openingloc      *Location
	Arguments       *ArgumentsNode
	Closingloc      *Location
	Block           Node
	Operator        string
	Operatorloc     *Location
	Value           Node
	Loc             *Location
}

func NewIndexOperatorWriteNode 

func NewIndexOperatorWriteNode(flags CallNodeFlags, receiver Node, callOperatorLoc *Location, openingLoc *Location, arguments *ArgumentsNode, closingLoc *Location, block Node, operator string, operatorLoc *Location, value Node, loc *Location) *IndexOperatorWriteNode

func (*IndexOperatorWriteNode) Accept 

func (node *IndexOperatorWriteNode) Accept(visitor NodeVisitor)

func (*IndexOperatorWriteNode) Children 

func (node *IndexOperatorWriteNode) Children() []Node

func (*IndexOperatorWriteNode) IsAttributeWrite 

func (node *IndexOperatorWriteNode) IsAttributeWrite() bool

func (*IndexOperatorWriteNode) IsIgnoreVisibility 

func (node *IndexOperatorWriteNode) IsIgnoreVisibility() bool

func (*IndexOperatorWriteNode) IsSafeNavigation 

func (node *IndexOperatorWriteNode) IsSafeNavigation() bool

func (*IndexOperatorWriteNode) IsVariableCall 

func (node *IndexOperatorWriteNode) IsVariableCall() bool

func (*IndexOperatorWriteNode) MarshalJSON 

func (node *IndexOperatorWriteNode) MarshalJSON() ([]byte, error)

type IndexOrWriteNode 

type IndexOrWriteNode struct {
	Flags           CallNodeFlags
	Receiver        Node
	Calloperatorloc *Location
	Openingloc      *Location
	Arguments       *ArgumentsNode
	Closingloc      *Location
	Block           Node
	Operatorloc     *Location
	Value           Node
	Loc             *Location
}

func NewIndexOrWriteNode 

func NewIndexOrWriteNode(flags CallNodeFlags, receiver Node, callOperatorLoc *Location, openingLoc *Location, arguments *ArgumentsNode, closingLoc *Location, block Node, operatorLoc *Location, value Node, loc *Location) *IndexOrWriteNode

func (*IndexOrWriteNode) Accept 

func (node *IndexOrWriteNode) Accept(visitor NodeVisitor)

func (*IndexOrWriteNode) Children 

func (node *IndexOrWriteNode) Children() []Node

func (*IndexOrWriteNode) IsAttributeWrite 

func (node *IndexOrWriteNode) IsAttributeWrite() bool

func (*IndexOrWriteNode) IsIgnoreVisibility 

func (node *IndexOrWriteNode) IsIgnoreVisibility() bool

func (*IndexOrWriteNode) IsSafeNavigation 

func (node *IndexOrWriteNode) IsSafeNavigation() bool

func (*IndexOrWriteNode) IsVariableCall 

func (node *IndexOrWriteNode) IsVariableCall() bool

func (*IndexOrWriteNode) MarshalJSON 

func (node *IndexOrWriteNode) MarshalJSON() ([]byte, error)

type IndexTargetNode 

type IndexTargetNode struct {
	Flags      CallNodeFlags
	Receiver   Node
	Openingloc *Location
	Arguments  *ArgumentsNode
	Closingloc *Location
	Block      Node
	Loc        *Location
}

func NewIndexTargetNode 

func NewIndexTargetNode(flags CallNodeFlags, receiver Node, openingLoc *Location, arguments *ArgumentsNode, closingLoc *Location, block Node, loc *Location) *IndexTargetNode

func (*IndexTargetNode) Accept 

func (node *IndexTargetNode) Accept(visitor NodeVisitor)

func (*IndexTargetNode) Children 

func (node *IndexTargetNode) Children() []Node

func (*IndexTargetNode) IsAttributeWrite 

func (node *IndexTargetNode) IsAttributeWrite() bool

func (*IndexTargetNode) IsIgnoreVisibility 

func (node *IndexTargetNode) IsIgnoreVisibility() bool

func (*IndexTargetNode) IsSafeNavigation 

func (node *IndexTargetNode) IsSafeNavigation() bool

func (*IndexTargetNode) IsVariableCall 

func (node *IndexTargetNode) IsVariableCall() bool

func (*IndexTargetNode) MarshalJSON 

func (node *IndexTargetNode) MarshalJSON() ([]byte, error)

type InstanceVariableAndWriteNode 

type InstanceVariableAndWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewInstanceVariableAndWriteNode 

func NewInstanceVariableAndWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *InstanceVariableAndWriteNode

func (*InstanceVariableAndWriteNode) Accept 

func (node *InstanceVariableAndWriteNode) Accept(visitor NodeVisitor)

func (*InstanceVariableAndWriteNode) Children 

func (node *InstanceVariableAndWriteNode) Children() []Node

func (*InstanceVariableAndWriteNode) MarshalJSON 

func (node *InstanceVariableAndWriteNode) MarshalJSON() ([]byte, error)

type InstanceVariableOperatorWriteNode 

type InstanceVariableOperatorWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Operator    string
	Loc         *Location
}

func NewInstanceVariableOperatorWriteNode 

func NewInstanceVariableOperatorWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, operator string, loc *Location) *InstanceVariableOperatorWriteNode

func (*InstanceVariableOperatorWriteNode) Accept 

func (node *InstanceVariableOperatorWriteNode) Accept(visitor NodeVisitor)

func (*InstanceVariableOperatorWriteNode) Children 

func (node *InstanceVariableOperatorWriteNode) Children() []Node

func (*InstanceVariableOperatorWriteNode) MarshalJSON 

func (node *InstanceVariableOperatorWriteNode) MarshalJSON() ([]byte, error)

type InstanceVariableOrWriteNode 

type InstanceVariableOrWriteNode struct {
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewInstanceVariableOrWriteNode 

func NewInstanceVariableOrWriteNode(name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *InstanceVariableOrWriteNode

func (*InstanceVariableOrWriteNode) Accept 

func (node *InstanceVariableOrWriteNode) Accept(visitor NodeVisitor)

func (*InstanceVariableOrWriteNode) Children 

func (node *InstanceVariableOrWriteNode) Children() []Node

func (*InstanceVariableOrWriteNode) MarshalJSON 

func (node *InstanceVariableOrWriteNode) MarshalJSON() ([]byte, error)

type InstanceVariableReadNode 

type InstanceVariableReadNode struct {
	Name string
	Loc  *Location
}

func NewInstanceVariableReadNode 

func NewInstanceVariableReadNode(name string, loc *Location) *InstanceVariableReadNode

func (*InstanceVariableReadNode) Accept 

func (node *InstanceVariableReadNode) Accept(visitor NodeVisitor)

func (*InstanceVariableReadNode) Children 

func (node *InstanceVariableReadNode) Children() []Node

func (*InstanceVariableReadNode) MarshalJSON 

func (node *InstanceVariableReadNode) MarshalJSON() ([]byte, error)

type InstanceVariableTargetNode 

type InstanceVariableTargetNode struct {
	Name string
	Loc  *Location
}

func NewInstanceVariableTargetNode 

func NewInstanceVariableTargetNode(name string, loc *Location) *InstanceVariableTargetNode

func (*InstanceVariableTargetNode) Accept 

func (node *InstanceVariableTargetNode) Accept(visitor NodeVisitor)

func (*InstanceVariableTargetNode) Children 

func (node *InstanceVariableTargetNode) Children() []Node

func (*InstanceVariableTargetNode) MarshalJSON 

func (node *InstanceVariableTargetNode) MarshalJSON() ([]byte, error)

type InstanceVariableWriteNode 

type InstanceVariableWriteNode struct {
	Name        string
	Nameloc     *Location
	Value       Node
	Operatorloc *Location
	Loc         *Location
}

func NewInstanceVariableWriteNode 

func NewInstanceVariableWriteNode(name string, nameLoc *Location, value Node, operatorLoc *Location, loc *Location) *InstanceVariableWriteNode

func (*InstanceVariableWriteNode) Accept 

func (node *InstanceVariableWriteNode) Accept(visitor NodeVisitor)

func (*InstanceVariableWriteNode) Children 

func (node *InstanceVariableWriteNode) Children() []Node

func (*InstanceVariableWriteNode) MarshalJSON 

func (node *InstanceVariableWriteNode) MarshalJSON() ([]byte, error)

type IntegerBaseFlags 

type IntegerBaseFlags int16
const (
	INTEGER_BASE_BINARY      IntegerBaseFlags = 1 << 0
	INTEGER_BASE_DECIMAL     IntegerBaseFlags = 1 << 1
	INTEGER_BASE_OCTAL       IntegerBaseFlags = 1 << 2
	INTEGER_BASE_HEXADECIMAL IntegerBaseFlags = 1 << 3
)

type IntegerNode 

type IntegerNode struct {
	Flags IntegerBaseFlags
	Value *big.Int
	Loc   *Location
}

func NewIntegerNode 

func NewIntegerNode(flags IntegerBaseFlags, value *big.Int, loc *Location) *IntegerNode

func (*IntegerNode) Accept 

func (node *IntegerNode) Accept(visitor NodeVisitor)

func (*IntegerNode) Children 

func (node *IntegerNode) Children() []Node

func (*IntegerNode) IsBinary 

func (node *IntegerNode) IsBinary() bool

func (*IntegerNode) IsDecimal 

func (node *IntegerNode) IsDecimal() bool

func (*IntegerNode) IsHexadecimal 

func (node *IntegerNode) IsHexadecimal() bool

func (*IntegerNode) IsOctal 

func (node *IntegerNode) IsOctal() bool

func (*IntegerNode) MarshalJSON 

func (node *IntegerNode) MarshalJSON() ([]byte, error)

type InterpolatedMatchLastLineNode 

type InterpolatedMatchLastLineNode struct {
	Flags      RegularExpressionFlags
	Openingloc *Location
	Parts      []Node
	Closingloc *Location
	Loc        *Location
}

func NewInterpolatedMatchLastLineNode 

func NewInterpolatedMatchLastLineNode(flags RegularExpressionFlags, openingLoc *Location, parts []Node, closingLoc *Location, loc *Location) *InterpolatedMatchLastLineNode

func (*InterpolatedMatchLastLineNode) Accept 

func (node *InterpolatedMatchLastLineNode) Accept(visitor NodeVisitor)

func (*InterpolatedMatchLastLineNode) Children 

func (node *InterpolatedMatchLastLineNode) Children() []Node

func (*InterpolatedMatchLastLineNode) IsAscii8bit 

func (node *InterpolatedMatchLastLineNode) IsAscii8bit() bool

func (*InterpolatedMatchLastLineNode) IsEucJp 

func (node *InterpolatedMatchLastLineNode) IsEucJp() bool

func (*InterpolatedMatchLastLineNode) IsExtended 

func (node *InterpolatedMatchLastLineNode) IsExtended() bool

func (*InterpolatedMatchLastLineNode) IsForcedBinaryEncoding 

func (node *InterpolatedMatchLastLineNode) IsForcedBinaryEncoding() bool

func (*InterpolatedMatchLastLineNode) IsForcedUsAsciiEncoding 

func (node *InterpolatedMatchLastLineNode) IsForcedUsAsciiEncoding() bool

func (*InterpolatedMatchLastLineNode) IsForcedUtf8Encoding 

func (node *InterpolatedMatchLastLineNode) IsForcedUtf8Encoding() bool

func (*InterpolatedMatchLastLineNode) IsIgnoreCase 

func (node *InterpolatedMatchLastLineNode) IsIgnoreCase() bool

func (*InterpolatedMatchLastLineNode) IsMultiLine 

func (node *InterpolatedMatchLastLineNode) IsMultiLine() bool

func (*InterpolatedMatchLastLineNode) IsOnce 

func (node *InterpolatedMatchLastLineNode) IsOnce() bool

func (*InterpolatedMatchLastLineNode) IsUtf8 

func (node *InterpolatedMatchLastLineNode) IsUtf8() bool

func (*InterpolatedMatchLastLineNode) IsWindows31j 

func (node *InterpolatedMatchLastLineNode) IsWindows31j() bool

func (*InterpolatedMatchLastLineNode) MarshalJSON 

func (node *InterpolatedMatchLastLineNode) MarshalJSON() ([]byte, error)

type InterpolatedRegularExpressionNode 

type InterpolatedRegularExpressionNode struct {
	Flags      RegularExpressionFlags
	Openingloc *Location
	Parts      []Node
	Closingloc *Location
	Loc        *Location
}

func NewInterpolatedRegularExpressionNode 

func NewInterpolatedRegularExpressionNode(flags RegularExpressionFlags, openingLoc *Location, parts []Node, closingLoc *Location, loc *Location) *InterpolatedRegularExpressionNode

func (*InterpolatedRegularExpressionNode) Accept 

func (node *InterpolatedRegularExpressionNode) Accept(visitor NodeVisitor)

func (*InterpolatedRegularExpressionNode) Children 

func (node *InterpolatedRegularExpressionNode) Children() []Node

func (*InterpolatedRegularExpressionNode) IsAscii8bit 

func (node *InterpolatedRegularExpressionNode) IsAscii8bit() bool

func (*InterpolatedRegularExpressionNode) IsEucJp 

func (node *InterpolatedRegularExpressionNode) IsEucJp() bool

func (*InterpolatedRegularExpressionNode) IsExtended 

func (node *InterpolatedRegularExpressionNode) IsExtended() bool

func (*InterpolatedRegularExpressionNode) IsForcedBinaryEncoding 

func (node *InterpolatedRegularExpressionNode) IsForcedBinaryEncoding() bool

func (*InterpolatedRegularExpressionNode) IsForcedUsAsciiEncoding 

func (node *InterpolatedRegularExpressionNode) IsForcedUsAsciiEncoding() bool

func (*InterpolatedRegularExpressionNode) IsForcedUtf8Encoding 

func (node *InterpolatedRegularExpressionNode) IsForcedUtf8Encoding() bool

func (*InterpolatedRegularExpressionNode) IsIgnoreCase 

func (node *InterpolatedRegularExpressionNode) IsIgnoreCase() bool

func (*InterpolatedRegularExpressionNode) IsMultiLine 

func (node *InterpolatedRegularExpressionNode) IsMultiLine() bool

func (*InterpolatedRegularExpressionNode) IsOnce 

func (node *InterpolatedRegularExpressionNode) IsOnce() bool

func (*InterpolatedRegularExpressionNode) IsUtf8 

func (node *InterpolatedRegularExpressionNode) IsUtf8() bool

func (*InterpolatedRegularExpressionNode) IsWindows31j 

func (node *InterpolatedRegularExpressionNode) IsWindows31j() bool

func (*InterpolatedRegularExpressionNode) MarshalJSON 

func (node *InterpolatedRegularExpressionNode) MarshalJSON() ([]byte, error)

type InterpolatedStringNode 

type InterpolatedStringNode struct {
	Openingloc *Location
	Parts      []Node
	Closingloc *Location
	Loc        *Location
}

func NewInterpolatedStringNode 

func NewInterpolatedStringNode(openingLoc *Location, parts []Node, closingLoc *Location, loc *Location) *InterpolatedStringNode

func (*InterpolatedStringNode) Accept 

func (node *InterpolatedStringNode) Accept(visitor NodeVisitor)

func (*InterpolatedStringNode) Children 

func (node *InterpolatedStringNode) Children() []Node

func (*InterpolatedStringNode) MarshalJSON 

func (node *InterpolatedStringNode) MarshalJSON() ([]byte, error)

type InterpolatedSymbolNode 

type InterpolatedSymbolNode struct {
	Openingloc *Location
	Parts      []Node
	Closingloc *Location
	Loc        *Location
}

func NewInterpolatedSymbolNode 

func NewInterpolatedSymbolNode(openingLoc *Location, parts []Node, closingLoc *Location, loc *Location) *InterpolatedSymbolNode

func (*InterpolatedSymbolNode) Accept 

func (node *InterpolatedSymbolNode) Accept(visitor NodeVisitor)

func (*InterpolatedSymbolNode) Children 

func (node *InterpolatedSymbolNode) Children() []Node

func (*InterpolatedSymbolNode) MarshalJSON 

func (node *InterpolatedSymbolNode) MarshalJSON() ([]byte, error)

type InterpolatedXStringNode 

type InterpolatedXStringNode struct {
	Openingloc *Location
	Parts      []Node
	Closingloc *Location
	Loc        *Location
}

func NewInterpolatedXStringNode 

func NewInterpolatedXStringNode(openingLoc *Location, parts []Node, closingLoc *Location, loc *Location) *InterpolatedXStringNode

func (*InterpolatedXStringNode) Accept 

func (node *InterpolatedXStringNode) Accept(visitor NodeVisitor)

func (*InterpolatedXStringNode) Children 

func (node *InterpolatedXStringNode) Children() []Node

func (*InterpolatedXStringNode) MarshalJSON 

func (node *InterpolatedXStringNode) MarshalJSON() ([]byte, error)

type ItParametersNode 

type ItParametersNode struct {
	Loc *Location
}

func NewItParametersNode 

func NewItParametersNode(loc *Location) *ItParametersNode

func (*ItParametersNode) Accept 

func (node *ItParametersNode) Accept(visitor NodeVisitor)

func (*ItParametersNode) Children 

func (node *ItParametersNode) Children() []Node

func (*ItParametersNode) MarshalJSON 

func (node *ItParametersNode) MarshalJSON() ([]byte, error)

type KeywordHashNode 

type KeywordHashNode struct {
	Flags    KeywordHashNodeFlags
	Elements []Node
	Loc      *Location
}

func NewKeywordHashNode 

func NewKeywordHashNode(flags KeywordHashNodeFlags, elements []Node, loc *Location) *KeywordHashNode

func (*KeywordHashNode) Accept 

func (node *KeywordHashNode) Accept(visitor NodeVisitor)

func (*KeywordHashNode) Children 

func (node *KeywordHashNode) Children() []Node

func (*KeywordHashNode) IsSymbolKeys 

func (node *KeywordHashNode) IsSymbolKeys() bool

func (*KeywordHashNode) MarshalJSON 

func (node *KeywordHashNode) MarshalJSON() ([]byte, error)

type KeywordHashNodeFlags 

type KeywordHashNodeFlags int16
const (
	KEYWORD_HASH_NODE_SYMBOL_KEYS KeywordHashNodeFlags = 1 << 0
)

type KeywordRestParameterNode 

type KeywordRestParameterNode struct {
	Flags       ParameterFlags
	Name        *string
	Nameloc     *Location
	Operatorloc *Location
	Loc         *Location
}

func NewKeywordRestParameterNode 

func NewKeywordRestParameterNode(flags ParameterFlags, name *string, nameLoc *Location, operatorLoc *Location, loc *Location) *KeywordRestParameterNode

func (*KeywordRestParameterNode) Accept 

func (node *KeywordRestParameterNode) Accept(visitor NodeVisitor)

func (*KeywordRestParameterNode) Children 

func (node *KeywordRestParameterNode) Children() []Node

func (*KeywordRestParameterNode) IsRepeatedParameter 

func (node *KeywordRestParameterNode) IsRepeatedParameter() bool

func (*KeywordRestParameterNode) MarshalJSON 

func (node *KeywordRestParameterNode) MarshalJSON() ([]byte, error)

type LambdaNode 

type LambdaNode struct {
	Locals      []string
	Operatorloc *Location
	Openingloc  *Location
	Closingloc  *Location
	Parameters  Node
	Body        Node
	Loc         *Location
}

func NewLambdaNode 

func NewLambdaNode(locals []string, operatorLoc *Location, openingLoc *Location, closingLoc *Location, parameters Node, body Node, loc *Location) *LambdaNode

func (*LambdaNode) Accept 

func (node *LambdaNode) Accept(visitor NodeVisitor)

func (*LambdaNode) Children 

func (node *LambdaNode) Children() []Node

func (*LambdaNode) MarshalJSON 

func (node *LambdaNode) MarshalJSON() ([]byte, error)

type LocalVariableAndWriteNode 

type LocalVariableAndWriteNode struct {
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Name        string
	Depth       uint32
	Loc         *Location
}

func NewLocalVariableAndWriteNode 

func NewLocalVariableAndWriteNode(nameLoc *Location, operatorLoc *Location, value Node, name string, depth uint32, loc *Location) *LocalVariableAndWriteNode

func (*LocalVariableAndWriteNode) Accept 

func (node *LocalVariableAndWriteNode) Accept(visitor NodeVisitor)

func (*LocalVariableAndWriteNode) Children 

func (node *LocalVariableAndWriteNode) Children() []Node

func (*LocalVariableAndWriteNode) MarshalJSON 

func (node *LocalVariableAndWriteNode) MarshalJSON() ([]byte, error)

type LocalVariableOperatorWriteNode 

type LocalVariableOperatorWriteNode struct {
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Name        string
	Operator    string
	Depth       uint32
	Loc         *Location
}

func NewLocalVariableOperatorWriteNode 

func NewLocalVariableOperatorWriteNode(nameLoc *Location, operatorLoc *Location, value Node, name string, operator string, depth uint32, loc *Location) *LocalVariableOperatorWriteNode

func (*LocalVariableOperatorWriteNode) Accept 

func (node *LocalVariableOperatorWriteNode) Accept(visitor NodeVisitor)

func (*LocalVariableOperatorWriteNode) Children 

func (node *LocalVariableOperatorWriteNode) Children() []Node

func (*LocalVariableOperatorWriteNode) MarshalJSON 

func (node *LocalVariableOperatorWriteNode) MarshalJSON() ([]byte, error)

type LocalVariableOrWriteNode 

type LocalVariableOrWriteNode struct {
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Name        string
	Depth       uint32
	Loc         *Location
}

func NewLocalVariableOrWriteNode 

func NewLocalVariableOrWriteNode(nameLoc *Location, operatorLoc *Location, value Node, name string, depth uint32, loc *Location) *LocalVariableOrWriteNode

func (*LocalVariableOrWriteNode) Accept 

func (node *LocalVariableOrWriteNode) Accept(visitor NodeVisitor)

func (*LocalVariableOrWriteNode) Children 

func (node *LocalVariableOrWriteNode) Children() []Node

func (*LocalVariableOrWriteNode) MarshalJSON 

func (node *LocalVariableOrWriteNode) MarshalJSON() ([]byte, error)

type LocalVariableReadNode 

type LocalVariableReadNode struct {
	Name  string
	Depth uint32
	Loc   *Location
}

func NewLocalVariableReadNode 

func NewLocalVariableReadNode(name string, depth uint32, loc *Location) *LocalVariableReadNode

func (*LocalVariableReadNode) Accept 

func (node *LocalVariableReadNode) Accept(visitor NodeVisitor)

func (*LocalVariableReadNode) Children 

func (node *LocalVariableReadNode) Children() []Node

func (*LocalVariableReadNode) MarshalJSON 

func (node *LocalVariableReadNode) MarshalJSON() ([]byte, error)

type LocalVariableTargetNode 

type LocalVariableTargetNode struct {
	Name  string
	Depth uint32
	Loc   *Location
}

func NewLocalVariableTargetNode 

func NewLocalVariableTargetNode(name string, depth uint32, loc *Location) *LocalVariableTargetNode

func (*LocalVariableTargetNode) Accept 

func (node *LocalVariableTargetNode) Accept(visitor NodeVisitor)

func (*LocalVariableTargetNode) Children 

func (node *LocalVariableTargetNode) Children() []Node

func (*LocalVariableTargetNode) MarshalJSON 

func (node *LocalVariableTargetNode) MarshalJSON() ([]byte, error)

type LocalVariableWriteNode 

type LocalVariableWriteNode struct {
	Name        string
	Depth       uint32
	Nameloc     *Location
	Value       Node
	Operatorloc *Location
	Loc         *Location
}

func NewLocalVariableWriteNode 

func NewLocalVariableWriteNode(name string, depth uint32, nameLoc *Location, value Node, operatorLoc *Location, loc *Location) *LocalVariableWriteNode

func (*LocalVariableWriteNode) Accept 

func (node *LocalVariableWriteNode) Accept(visitor NodeVisitor)

func (*LocalVariableWriteNode) Children 

func (node *LocalVariableWriteNode) Children() []Node

func (*LocalVariableWriteNode) MarshalJSON 

func (node *LocalVariableWriteNode) MarshalJSON() ([]byte, error)

type Location 

type Location struct {
	StartOffset uint32
	Length      uint32
}

func NewLocation 

func NewLocation(startOffset uint32, length uint32) *Location

func (*Location) EndOffset 

func (l *Location) EndOffset() uint32

func (*Location) MarshalJSON 

func (l *Location) MarshalJSON() ([]byte, error)

type LoopFlags 

type LoopFlags int16
const (
	LOOP_BEGIN_MODIFIER LoopFlags = 1 << 0
)

type MagicComment 

type MagicComment struct {
	KeyLocation   *Location
	ValueLocation *Location
}

func NewMagicComment 

func NewMagicComment(keyLocation *Location, valueLocation *Location) *MagicComment

func (*MagicComment) MarshalJSON 

func (c *MagicComment) MarshalJSON() ([]byte, error)

type MatchLastLineNode 

type MatchLastLineNode struct {
	Flags      RegularExpressionFlags
	Openingloc *Location
	Contentloc *Location
	Closingloc *Location
	Unescaped  string
	Loc        *Location
}

func NewMatchLastLineNode 

func NewMatchLastLineNode(flags RegularExpressionFlags, openingLoc *Location, contentLoc *Location, closingLoc *Location, unescaped string, loc *Location) *MatchLastLineNode

func (*MatchLastLineNode) Accept 

func (node *MatchLastLineNode) Accept(visitor NodeVisitor)

func (*MatchLastLineNode) Children 

func (node *MatchLastLineNode) Children() []Node

func (*MatchLastLineNode) IsAscii8bit 

func (node *MatchLastLineNode) IsAscii8bit() bool

func (*MatchLastLineNode) IsEucJp 

func (node *MatchLastLineNode) IsEucJp() bool

func (*MatchLastLineNode) IsExtended 

func (node *MatchLastLineNode) IsExtended() bool

func (*MatchLastLineNode) IsForcedBinaryEncoding 

func (node *MatchLastLineNode) IsForcedBinaryEncoding() bool

func (*MatchLastLineNode) IsForcedUsAsciiEncoding 

func (node *MatchLastLineNode) IsForcedUsAsciiEncoding() bool

func (*MatchLastLineNode) IsForcedUtf8Encoding 

func (node *MatchLastLineNode) IsForcedUtf8Encoding() bool

func (*MatchLastLineNode) IsIgnoreCase 

func (node *MatchLastLineNode) IsIgnoreCase() bool

func (*MatchLastLineNode) IsMultiLine 

func (node *MatchLastLineNode) IsMultiLine() bool

func (*MatchLastLineNode) IsOnce 

func (node *MatchLastLineNode) IsOnce() bool

func (*MatchLastLineNode) IsUtf8 

func (node *MatchLastLineNode) IsUtf8() bool

func (*MatchLastLineNode) IsWindows31j 

func (node *MatchLastLineNode) IsWindows31j() bool

func (*MatchLastLineNode) MarshalJSON 

func (node *MatchLastLineNode) MarshalJSON() ([]byte, error)

type MatchPredicateNode 

type MatchPredicateNode struct {
	Value       Node
	Pattern     Node
	Operatorloc *Location
	Loc         *Location
}

func NewMatchPredicateNode 

func NewMatchPredicateNode(value Node, pattern Node, operatorLoc *Location, loc *Location) *MatchPredicateNode

func (*MatchPredicateNode) Accept 

func (node *MatchPredicateNode) Accept(visitor NodeVisitor)

func (*MatchPredicateNode) Children 

func (node *MatchPredicateNode) Children() []Node

func (*MatchPredicateNode) MarshalJSON 

func (node *MatchPredicateNode) MarshalJSON() ([]byte, error)

type MatchRequiredNode 

type MatchRequiredNode struct {
	Value       Node
	Pattern     Node
	Operatorloc *Location
	Loc         *Location
}

func NewMatchRequiredNode 

func NewMatchRequiredNode(value Node, pattern Node, operatorLoc *Location, loc *Location) *MatchRequiredNode

func (*MatchRequiredNode) Accept 

func (node *MatchRequiredNode) Accept(visitor NodeVisitor)

func (*MatchRequiredNode) Children 

func (node *MatchRequiredNode) Children() []Node

func (*MatchRequiredNode) MarshalJSON 

func (node *MatchRequiredNode) MarshalJSON() ([]byte, error)

type MatchWriteNode 

type MatchWriteNode struct {
	Call    *CallNode
	Targets []Node
	Loc     *Location
}

func NewMatchWriteNode 

func NewMatchWriteNode(call *CallNode, targets []Node, loc *Location) *MatchWriteNode

func (*MatchWriteNode) Accept 

func (node *MatchWriteNode) Accept(visitor NodeVisitor)

func (*MatchWriteNode) Children 

func (node *MatchWriteNode) Children() []Node

func (*MatchWriteNode) MarshalJSON 

func (node *MatchWriteNode) MarshalJSON() ([]byte, error)

type MissingNode 

type MissingNode struct {
	Loc *Location
}

func NewMissingNode 

func NewMissingNode(loc *Location) *MissingNode

func (*MissingNode) Accept 

func (node *MissingNode) Accept(visitor NodeVisitor)

func (*MissingNode) Children 

func (node *MissingNode) Children() []Node

func (*MissingNode) MarshalJSON 

func (node *MissingNode) MarshalJSON() ([]byte, error)

type ModuleNode 

type ModuleNode struct {
	Locals           []string
	Modulekeywordloc *Location
	Constantpath     Node
	Body             Node
	Endkeywordloc    *Location
	Name             string
	Loc              *Location
}

func NewModuleNode 

func NewModuleNode(locals []string, moduleKeywordLoc *Location, constantPath Node, body Node, endKeywordLoc *Location, name string, loc *Location) *ModuleNode

func (*ModuleNode) Accept 

func (node *ModuleNode) Accept(visitor NodeVisitor)

func (*ModuleNode) Children 

func (node *ModuleNode) Children() []Node

func (*ModuleNode) MarshalJSON 

func (node *ModuleNode) MarshalJSON() ([]byte, error)

type MultiTargetNode 

type MultiTargetNode struct {
	Lefts     []Node
	Rest      Node
	Rights    []Node
	Lparenloc *Location
	Rparenloc *Location
	Loc       *Location
}

func NewMultiTargetNode 

func NewMultiTargetNode(lefts []Node, rest Node, rights []Node, lparenLoc *Location, rparenLoc *Location, loc *Location) *MultiTargetNode

func (*MultiTargetNode) Accept 

func (node *MultiTargetNode) Accept(visitor NodeVisitor)

func (*MultiTargetNode) Children 

func (node *MultiTargetNode) Children() []Node

func (*MultiTargetNode) MarshalJSON 

func (node *MultiTargetNode) MarshalJSON() ([]byte, error)

type MultiWriteNode 

type MultiWriteNode struct {
	Lefts       []Node
	Rest        Node
	Rights      []Node
	Lparenloc   *Location
	Rparenloc   *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewMultiWriteNode 

func NewMultiWriteNode(lefts []Node, rest Node, rights []Node, lparenLoc *Location, rparenLoc *Location, operatorLoc *Location, value Node, loc *Location) *MultiWriteNode

func (*MultiWriteNode) Accept 

func (node *MultiWriteNode) Accept(visitor NodeVisitor)

func (*MultiWriteNode) Children 

func (node *MultiWriteNode) Children() []Node

func (*MultiWriteNode) MarshalJSON 

func (node *MultiWriteNode) MarshalJSON() ([]byte, error)

type NextNode 

type NextNode struct {
	Arguments  *ArgumentsNode
	Keywordloc *Location
	Loc        *Location
}

func NewNextNode 

func NewNextNode(arguments *ArgumentsNode, keywordLoc *Location, loc *Location) *NextNode

func (*NextNode) Accept 

func (node *NextNode) Accept(visitor NodeVisitor)

func (*NextNode) Children 

func (node *NextNode) Children() []Node

func (*NextNode) MarshalJSON 

func (node *NextNode) MarshalJSON() ([]byte, error)

type NilNode 

type NilNode struct {
	Loc *Location
}

func NewNilNode 

func NewNilNode(loc *Location) *NilNode

func (*NilNode) Accept 

func (node *NilNode) Accept(visitor NodeVisitor)

func (*NilNode) Children 

func (node *NilNode) Children() []Node

func (*NilNode) MarshalJSON 

func (node *NilNode) MarshalJSON() ([]byte, error)

type NoKeywordsParameterNode 

type NoKeywordsParameterNode struct {
	Operatorloc *Location
	Keywordloc  *Location
	Loc         *Location
}

func NewNoKeywordsParameterNode 

func NewNoKeywordsParameterNode(operatorLoc *Location, keywordLoc *Location, loc *Location) *NoKeywordsParameterNode

func (*NoKeywordsParameterNode) Accept 

func (node *NoKeywordsParameterNode) Accept(visitor NodeVisitor)

func (*NoKeywordsParameterNode) Children 

func (node *NoKeywordsParameterNode) Children() []Node

func (*NoKeywordsParameterNode) MarshalJSON 

func (node *NoKeywordsParameterNode) MarshalJSON() ([]byte, error)

type Node 

type Node interface {
	Accept(NodeVisitor)
	Children() []Node
}

type NodeVisitor 

type NodeVisitor interface {
	Visit(Node)
}

type NumberedParametersNode 

type NumberedParametersNode struct {
	Maximum uint8
	Loc     *Location
}

func NewNumberedParametersNode 

func NewNumberedParametersNode(maximum uint8, loc *Location) *NumberedParametersNode

func (*NumberedParametersNode) Accept 

func (node *NumberedParametersNode) Accept(visitor NodeVisitor)

func (*NumberedParametersNode) Children 

func (node *NumberedParametersNode) Children() []Node

func (*NumberedParametersNode) MarshalJSON 

func (node *NumberedParametersNode) MarshalJSON() ([]byte, error)

type NumberedReferenceReadNode 

type NumberedReferenceReadNode struct {
	Number uint32
	Loc    *Location
}

func NewNumberedReferenceReadNode 

func NewNumberedReferenceReadNode(number uint32, loc *Location) *NumberedReferenceReadNode

func (*NumberedReferenceReadNode) Accept 

func (node *NumberedReferenceReadNode) Accept(visitor NodeVisitor)

func (*NumberedReferenceReadNode) Children 

func (node *NumberedReferenceReadNode) Children() []Node

func (*NumberedReferenceReadNode) MarshalJSON 

func (node *NumberedReferenceReadNode) MarshalJSON() ([]byte, error)

type OptionalKeywordParameterNode 

type OptionalKeywordParameterNode struct {
	Flags   ParameterFlags
	Name    string
	Nameloc *Location
	Value   Node
	Loc     *Location
}

func NewOptionalKeywordParameterNode 

func NewOptionalKeywordParameterNode(flags ParameterFlags, name string, nameLoc *Location, value Node, loc *Location) *OptionalKeywordParameterNode

func (*OptionalKeywordParameterNode) Accept 

func (node *OptionalKeywordParameterNode) Accept(visitor NodeVisitor)

func (*OptionalKeywordParameterNode) Children 

func (node *OptionalKeywordParameterNode) Children() []Node

func (*OptionalKeywordParameterNode) IsRepeatedParameter 

func (node *OptionalKeywordParameterNode) IsRepeatedParameter() bool

func (*OptionalKeywordParameterNode) MarshalJSON 

func (node *OptionalKeywordParameterNode) MarshalJSON() ([]byte, error)

type OptionalParameterNode 

type OptionalParameterNode struct {
	Flags       ParameterFlags
	Name        string
	Nameloc     *Location
	Operatorloc *Location
	Value       Node
	Loc         *Location
}

func NewOptionalParameterNode 

func NewOptionalParameterNode(flags ParameterFlags, name string, nameLoc *Location, operatorLoc *Location, value Node, loc *Location) *OptionalParameterNode

func (*OptionalParameterNode) Accept 

func (node *OptionalParameterNode) Accept(visitor NodeVisitor)

func (*OptionalParameterNode) Children 

func (node *OptionalParameterNode) Children() []Node

func (*OptionalParameterNode) IsRepeatedParameter 

func (node *OptionalParameterNode) IsRepeatedParameter() bool

func (*OptionalParameterNode) MarshalJSON 

func (node *OptionalParameterNode) MarshalJSON() ([]byte, error)

type OrNode 

type OrNode struct {
	Left        Node
	Right       Node
	Operatorloc *Location
	Loc         *Location
}

func NewOrNode 

func NewOrNode(left Node, right Node, operatorLoc *Location, loc *Location) *OrNode

func (*OrNode) Accept 

func (node *OrNode) Accept(visitor NodeVisitor)

func (*OrNode) Children 

func (node *OrNode) Children() []Node

func (*OrNode) MarshalJSON 

func (node *OrNode) MarshalJSON() ([]byte, error)

type ParameterFlags 

type ParameterFlags int16
const (
	PARAMETER_REPEATED_PARAMETER ParameterFlags = 1 << 0
)

type ParametersNode 

type ParametersNode struct {
	Requireds   []Node
	Optionals   []Node
	Rest        Node
	Posts       []Node
	Keywords    []Node
	Keywordrest Node
	Block       *BlockParameterNode
	Loc         *Location
}

func NewParametersNode 

func NewParametersNode(requireds []Node, optionals []Node, rest Node, posts []Node, keywords []Node, keywordRest Node, block *BlockParameterNode, loc *Location) *ParametersNode

func (*ParametersNode) Accept 

func (node *ParametersNode) Accept(visitor NodeVisitor)

func (*ParametersNode) Children 

func (node *ParametersNode) Children() []Node

func (*ParametersNode) MarshalJSON 

func (node *ParametersNode) MarshalJSON() ([]byte, error)

type ParenthesesNode 

type ParenthesesNode struct {
	Body       Node
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewParenthesesNode 

func NewParenthesesNode(body Node, openingLoc *Location, closingLoc *Location, loc *Location) *ParenthesesNode

func (*ParenthesesNode) Accept 

func (node *ParenthesesNode) Accept(visitor NodeVisitor)

func (*ParenthesesNode) Children 

func (node *ParenthesesNode) Children() []Node

func (*ParenthesesNode) MarshalJSON 

func (node *ParenthesesNode) MarshalJSON() ([]byte, error)

type ParseResult 

type ParseResult struct {
	Value         Node
	Comments      []*Comment
	MagicComments []*MagicComment
	DataLocation  *Location
	SynError      []*SyntaxError
	SynWarnings   []*SyntaxWarning
}

func NewParseResult 

func NewParseResult(
	value Node,
	comments []*Comment,
	magicComments []*MagicComment,
	dataLocation *Location,
	synError []*SyntaxError,
	synWarnings []*SyntaxWarning,
) *ParseResult

func (*ParseResult) MarshalJSON 

func (p *ParseResult) MarshalJSON() ([]byte, error)

type Parser 

type Parser struct {
	// contains filtered or unexported fields
}

func NewParser 

func NewParser(ctx context.Context) (*Parser, error)

func (*Parser) Close 

func (p *Parser) Close(ctx context.Context) error

func (*Parser) Parse 

func (p *Parser) Parse(ctx context.Context, source string) (result *ParseResult, err error)

type PinnedExpressionNode 

type PinnedExpressionNode struct {
	Expression  Node
	Operatorloc *Location
	Lparenloc   *Location
	Rparenloc   *Location
	Loc         *Location
}

func NewPinnedExpressionNode 

func NewPinnedExpressionNode(expression Node, operatorLoc *Location, lparenLoc *Location, rparenLoc *Location, loc *Location) *PinnedExpressionNode

func (*PinnedExpressionNode) Accept 

func (node *PinnedExpressionNode) Accept(visitor NodeVisitor)

func (*PinnedExpressionNode) Children 

func (node *PinnedExpressionNode) Children() []Node

func (*PinnedExpressionNode) MarshalJSON 

func (node *PinnedExpressionNode) MarshalJSON() ([]byte, error)

type PinnedVariableNode 

type PinnedVariableNode struct {
	Variable    Node
	Operatorloc *Location
	Loc         *Location
}

func NewPinnedVariableNode 

func NewPinnedVariableNode(variable Node, operatorLoc *Location, loc *Location) *PinnedVariableNode

func (*PinnedVariableNode) Accept 

func (node *PinnedVariableNode) Accept(visitor NodeVisitor)

func (*PinnedVariableNode) Children 

func (node *PinnedVariableNode) Children() []Node

func (*PinnedVariableNode) MarshalJSON 

func (node *PinnedVariableNode) MarshalJSON() ([]byte, error)

type PostExecutionNode 

type PostExecutionNode struct {
	Statements *StatementsNode
	Keywordloc *Location
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewPostExecutionNode 

func NewPostExecutionNode(statements *StatementsNode, keywordLoc *Location, openingLoc *Location, closingLoc *Location, loc *Location) *PostExecutionNode

func (*PostExecutionNode) Accept 

func (node *PostExecutionNode) Accept(visitor NodeVisitor)

func (*PostExecutionNode) Children 

func (node *PostExecutionNode) Children() []Node

func (*PostExecutionNode) MarshalJSON 

func (node *PostExecutionNode) MarshalJSON() ([]byte, error)

type PreExecutionNode 

type PreExecutionNode struct {
	Statements *StatementsNode
	Keywordloc *Location
	Openingloc *Location
	Closingloc *Location
	Loc        *Location
}

func NewPreExecutionNode 

func NewPreExecutionNode(statements *StatementsNode, keywordLoc *Location, openingLoc *Location, closingLoc *Location, loc *Location) *PreExecutionNode

func (*PreExecutionNode) Accept 

func (node *PreExecutionNode) Accept(visitor NodeVisitor)

func (*PreExecutionNode) Children 

func (node *PreExecutionNode) Children() []Node

func (*PreExecutionNode) MarshalJSON 

func (node *PreExecutionNode) MarshalJSON() ([]byte, error)

type ProgramNode 

type ProgramNode struct {
	Locals     []string
	Statements *StatementsNode
	Loc        *Location
}

func NewProgramNode 

func NewProgramNode(locals []string, statements *StatementsNode, loc *Location) *ProgramNode

func (*ProgramNode) Accept 

func (node *ProgramNode) Accept(visitor NodeVisitor)

func (*ProgramNode) Children 

func (node *ProgramNode) Children() []Node

func (*ProgramNode) MarshalJSON 

func (node *ProgramNode) MarshalJSON() ([]byte, error)

type RangeFlags 

type RangeFlags int16
const (
	RANGE_EXCLUDE_END RangeFlags = 1 << 0
)

type RangeNode 

type RangeNode struct {
	Flags       RangeFlags
	Left        Node
	Right       Node
	Operatorloc *Location
	Loc         *Location
}

func NewRangeNode 

func NewRangeNode(flags RangeFlags, left Node, right Node, operatorLoc *Location, loc *Location) *RangeNode

func (*RangeNode) Accept 

func (node *RangeNode) Accept(visitor NodeVisitor)

func (*RangeNode) Children 

func (node *RangeNode) Children() []Node

func (*RangeNode) IsExcludeEnd 

func (node *RangeNode) IsExcludeEnd() bool

func (*RangeNode) MarshalJSON 

func (node *RangeNode) MarshalJSON() ([]byte, error)

type RationalNode 

type RationalNode struct {
	Numeric Node
	Loc     *Location
}

func NewRationalNode 

func NewRationalNode(numeric Node, loc *Location) *RationalNode

func (*RationalNode) Accept 

func (node *RationalNode) Accept(visitor NodeVisitor)

func (*RationalNode) Children 

func (node *RationalNode) Children() []Node

func (*RationalNode) MarshalJSON 

func (node *RationalNode) MarshalJSON() ([]byte, error)

type RedoNode 

type RedoNode struct {
	Loc *Location
}

func NewRedoNode 

func NewRedoNode(loc *Location) *RedoNode

func (*RedoNode) Accept 

func (node *RedoNode) Accept(visitor NodeVisitor)

func (*RedoNode) Children 

func (node *RedoNode) Children() []Node

func (*RedoNode) MarshalJSON 

func (node *RedoNode) MarshalJSON() ([]byte, error)

type RegularExpressionFlags 

type RegularExpressionFlags int16
const (
	REGULAR_EXPRESSION_IGNORE_CASE              RegularExpressionFlags = 1 << 0
	REGULAR_EXPRESSION_EXTENDED                 RegularExpressionFlags = 1 << 1
	REGULAR_EXPRESSION_MULTI_LINE               RegularExpressionFlags = 1 << 2
	REGULAR_EXPRESSION_ONCE                     RegularExpressionFlags = 1 << 3
	REGULAR_EXPRESSION_EUC_JP                   RegularExpressionFlags = 1 << 4
	REGULAR_EXPRESSION_ASCII_8BIT               RegularExpressionFlags = 1 << 5
	REGULAR_EXPRESSION_WINDOWS_31J              RegularExpressionFlags = 1 << 6
	REGULAR_EXPRESSION_UTF_8                    RegularExpressionFlags = 1 << 7
	REGULAR_EXPRESSION_FORCED_UTF8_ENCODING     RegularExpressionFlags = 1 << 8
	REGULAR_EXPRESSION_FORCED_BINARY_ENCODING   RegularExpressionFlags = 1 << 9
	REGULAR_EXPRESSION_FORCED_US_ASCII_ENCODING RegularExpressionFlags = 1 << 10
)

type RegularExpressionNode 

type RegularExpressionNode struct {
	Flags      RegularExpressionFlags
	Openingloc *Location
	Contentloc *Location
	Closingloc *Location
	Unescaped  string
	Loc        *Location
}

func NewRegularExpressionNode 

func NewRegularExpressionNode(flags RegularExpressionFlags, openingLoc *Location, contentLoc *Location, closingLoc *Location, unescaped string, loc *Location) *RegularExpressionNode

func (*RegularExpressionNode) Accept 

func (node *RegularExpressionNode) Accept(visitor NodeVisitor)

func (*RegularExpressionNode) Children 

func (node *RegularExpressionNode) Children() []Node

func (*RegularExpressionNode) IsAscii8bit 

func (node *RegularExpressionNode) IsAscii8bit() bool

func (*RegularExpressionNode) IsEucJp 

func (node *RegularExpressionNode) IsEucJp() bool

func (*RegularExpressionNode) IsExtended 

func (node *RegularExpressionNode) IsExtended() bool

func (*RegularExpressionNode) IsForcedBinaryEncoding 

func (node *RegularExpressionNode) IsForcedBinaryEncoding() bool

func (*RegularExpressionNode) IsForcedUsAsciiEncoding 

func (node *RegularExpressionNode) IsForcedUsAsciiEncoding() bool

func (*RegularExpressionNode) IsForcedUtf8Encoding 

func (node *RegularExpressionNode) IsForcedUtf8Encoding() bool

func (*RegularExpressionNode) IsIgnoreCase 

func (node *RegularExpressionNode) IsIgnoreCase() bool

func (*RegularExpressionNode) IsMultiLine 

func (node *RegularExpressionNode) IsMultiLine() bool

func (*RegularExpressionNode) IsOnce 

func (node *RegularExpressionNode) IsOnce() bool

func (*RegularExpressionNode) IsUtf8 

func (node *RegularExpressionNode) IsUtf8() bool

func (*RegularExpressionNode) IsWindows31j 

func (node *RegularExpressionNode) IsWindows31j() bool

func (*RegularExpressionNode) MarshalJSON 

func (node *RegularExpressionNode) MarshalJSON() ([]byte, error)

type RequiredKeywordParameterNode 

type RequiredKeywordParameterNode struct {
	Flags   ParameterFlags
	Name    string
	Nameloc *Location
	Loc     *Location
}

func NewRequiredKeywordParameterNode 

func NewRequiredKeywordParameterNode(flags ParameterFlags, name string, nameLoc *Location, loc *Location) *RequiredKeywordParameterNode

func (*RequiredKeywordParameterNode) Accept 

func (node *RequiredKeywordParameterNode) Accept(visitor NodeVisitor)

func (*RequiredKeywordParameterNode) Children 

func (node *RequiredKeywordParameterNode) Children() []Node

func (*RequiredKeywordParameterNode) IsRepeatedParameter 

func (node *RequiredKeywordParameterNode) IsRepeatedParameter() bool

func (*RequiredKeywordParameterNode) MarshalJSON 

func (node *RequiredKeywordParameterNode) MarshalJSON() ([]byte, error)

type RequiredParameterNode 

type RequiredParameterNode struct {
	Flags ParameterFlags
	Name  string
	Loc   *Location
}

func NewRequiredParameterNode 

func NewRequiredParameterNode(flags ParameterFlags, name string, loc *Location) *RequiredParameterNode

func (*RequiredParameterNode) Accept 

func (node *RequiredParameterNode) Accept(visitor NodeVisitor)

func (*RequiredParameterNode) Children 

func (node *RequiredParameterNode) Children() []Node

func (*RequiredParameterNode) IsRepeatedParameter 

func (node *RequiredParameterNode) IsRepeatedParameter() bool

func (*RequiredParameterNode) MarshalJSON 

func (node *RequiredParameterNode) MarshalJSON() ([]byte, error)

type RescueModifierNode 

type RescueModifierNode struct {
	Expression       Node
	Keywordloc       *Location
	Rescueexpression Node
	Loc              *Location
}

func NewRescueModifierNode 

func NewRescueModifierNode(expression Node, keywordLoc *Location, rescueExpression Node, loc *Location) *RescueModifierNode

func (*RescueModifierNode) Accept 

func (node *RescueModifierNode) Accept(visitor NodeVisitor)

func (*RescueModifierNode) Children 

func (node *RescueModifierNode) Children() []Node

func (*RescueModifierNode) MarshalJSON 

func (node *RescueModifierNode) MarshalJSON() ([]byte, error)

type RescueNode 

type RescueNode struct {
	Keywordloc  *Location
	Exceptions  []Node
	Operatorloc *Location
	Reference   Node
	Statements  *StatementsNode
	Consequent  *RescueNode
	Loc         *Location
}

func NewRescueNode 

func NewRescueNode(keywordLoc *Location, exceptions []Node, operatorLoc *Location, reference Node, statements *StatementsNode, consequent *RescueNode, loc *Location) *RescueNode

func (*RescueNode) Accept 

func (node *RescueNode) Accept(visitor NodeVisitor)

func (*RescueNode) Children 

func (node *RescueNode) Children() []Node

func (*RescueNode) MarshalJSON 

func (node *RescueNode) MarshalJSON() ([]byte, error)

type RestParameterNode 

type RestParameterNode struct {
	Flags       ParameterFlags
	Name        *string
	Nameloc     *Location
	Operatorloc *Location
	Loc         *Location
}

func NewRestParameterNode 

func NewRestParameterNode(flags ParameterFlags, name *string, nameLoc *Location, operatorLoc *Location, loc *Location) *RestParameterNode

func (*RestParameterNode) Accept 

func (node *RestParameterNode) Accept(visitor NodeVisitor)

func (*RestParameterNode) Children 

func (node *RestParameterNode) Children() []Node

func (*RestParameterNode) IsRepeatedParameter 

func (node *RestParameterNode) IsRepeatedParameter() bool

func (*RestParameterNode) MarshalJSON 

func (node *RestParameterNode) MarshalJSON() ([]byte, error)

type RetryNode 

type RetryNode struct {
	Loc *Location
}

func NewRetryNode 

func NewRetryNode(loc *Location) *RetryNode

func (*RetryNode) Accept 

func (node *RetryNode) Accept(visitor NodeVisitor)

func (*RetryNode) Children 

func (node *RetryNode) Children() []Node

func (*RetryNode) MarshalJSON 

func (node *RetryNode) MarshalJSON() ([]byte, error)

type ReturnNode 

type ReturnNode struct {
	Keywordloc *Location
	Arguments  *ArgumentsNode
	Loc        *Location
}

func NewReturnNode 

func NewReturnNode(keywordLoc *Location, arguments *ArgumentsNode, loc *Location) *ReturnNode

func (*ReturnNode) Accept 

func (node *ReturnNode) Accept(visitor NodeVisitor)

func (*ReturnNode) Children 

func (node *ReturnNode) Children() []Node

func (*ReturnNode) MarshalJSON 

func (node *ReturnNode) MarshalJSON() ([]byte, error)

type SelfNode 

type SelfNode struct {
	Loc *Location
}

func NewSelfNode 

func NewSelfNode(loc *Location) *SelfNode

func (*SelfNode) Accept 

func (node *SelfNode) Accept(visitor NodeVisitor)

func (*SelfNode) Children 

func (node *SelfNode) Children() []Node

func (*SelfNode) MarshalJSON 

func (node *SelfNode) MarshalJSON() ([]byte, error)

type SingletonClassNode 

type SingletonClassNode struct {
	Locals          []string
	Classkeywordloc *Location
	Operatorloc     *Location
	Expression      Node
	Body            Node
	Endkeywordloc   *Location
	Loc             *Location
}

func NewSingletonClassNode 

func NewSingletonClassNode(locals []string, classKeywordLoc *Location, operatorLoc *Location, expression Node, body Node, endKeywordLoc *Location, loc *Location) *SingletonClassNode

func (*SingletonClassNode) Accept 

func (node *SingletonClassNode) Accept(visitor NodeVisitor)

func (*SingletonClassNode) Children 

func (node *SingletonClassNode) Children() []Node

func (*SingletonClassNode) MarshalJSON 

func (node *SingletonClassNode) MarshalJSON() ([]byte, error)

type SourceEncodingNode 

type SourceEncodingNode struct {
	Loc *Location
}

func NewSourceEncodingNode 

func NewSourceEncodingNode(loc *Location) *SourceEncodingNode

func (*SourceEncodingNode) Accept 

func (node *SourceEncodingNode) Accept(visitor NodeVisitor)

func (*SourceEncodingNode) Children 

func (node *SourceEncodingNode) Children() []Node

func (*SourceEncodingNode) MarshalJSON 

func (node *SourceEncodingNode) MarshalJSON() ([]byte, error)

type SourceFileNode 

type SourceFileNode struct {
	Filepath string
	Loc      *Location
}

func NewSourceFileNode 

func NewSourceFileNode(filepath string, loc *Location) *SourceFileNode

func (*SourceFileNode) Accept 

func (node *SourceFileNode) Accept(visitor NodeVisitor)

func (*SourceFileNode) Children 

func (node *SourceFileNode) Children() []Node

func (*SourceFileNode) MarshalJSON 

func (node *SourceFileNode) MarshalJSON() ([]byte, error)

type SourceLineNode 

type SourceLineNode struct {
	Loc *Location
}

func NewSourceLineNode 

func NewSourceLineNode(loc *Location) *SourceLineNode

func (*SourceLineNode) Accept 

func (node *SourceLineNode) Accept(visitor NodeVisitor)

func (*SourceLineNode) Children 

func (node *SourceLineNode) Children() []Node

func (*SourceLineNode) MarshalJSON 

func (node *SourceLineNode) MarshalJSON() ([]byte, error)

type SplatNode 

type SplatNode struct {
	Operatorloc *Location
	Expression  Node
	Loc         *Location
}

func NewSplatNode 

func NewSplatNode(operatorLoc *Location, expression Node, loc *Location) *SplatNode

func (*SplatNode) Accept 

func (node *SplatNode) Accept(visitor NodeVisitor)

func (*SplatNode) Children 

func (node *SplatNode) Children() []Node

func (*SplatNode) MarshalJSON 

func (node *SplatNode) MarshalJSON() ([]byte, error)

type StatementsNode 

type StatementsNode struct {
	Body []Node
	Loc  *Location
}

func NewStatementsNode 

func NewStatementsNode(body []Node, loc *Location) *StatementsNode

func (*StatementsNode) Accept 

func (node *StatementsNode) Accept(visitor NodeVisitor)

func (*StatementsNode) Children 

func (node *StatementsNode) Children() []Node

func (*StatementsNode) MarshalJSON 

func (node *StatementsNode) MarshalJSON() ([]byte, error)

type StringFlags 

type StringFlags int16
const (
	STRING_FORCED_UTF8_ENCODING   StringFlags = 1 << 0
	STRING_FORCED_BINARY_ENCODING StringFlags = 1 << 1
	STRING_FROZEN                 StringFlags = 1 << 2
)

type StringNode 

type StringNode struct {
	Flags      StringFlags
	Openingloc *Location
	Contentloc *Location
	Closingloc *Location
	Unescaped  string
	Loc        *Location
}

func NewStringNode 

func NewStringNode(flags StringFlags, openingLoc *Location, contentLoc *Location, closingLoc *Location, unescaped string, loc *Location) *StringNode

func (*StringNode) Accept 

func (node *StringNode) Accept(visitor NodeVisitor)

func (*StringNode) Children 

func (node *StringNode) Children() []Node

func (*StringNode) IsForcedBinaryEncoding 

func (node *StringNode) IsForcedBinaryEncoding() bool

func (*StringNode) IsForcedUtf8Encoding 

func (node *StringNode) IsForcedUtf8Encoding() bool

func (*StringNode) IsFrozen 

func (node *StringNode) IsFrozen() bool

func (*StringNode) MarshalJSON 

func (node *StringNode) MarshalJSON() ([]byte, error)

type SuperNode 

type SuperNode struct {
	Keywordloc *Location
	Lparenloc  *Location
	Arguments  *ArgumentsNode
	Rparenloc  *Location
	Block      Node
	Loc        *Location
}

func NewSuperNode 

func NewSuperNode(keywordLoc *Location, lparenLoc *Location, arguments *ArgumentsNode, rparenLoc *Location, block Node, loc *Location) *SuperNode

func (*SuperNode) Accept 

func (node *SuperNode) Accept(visitor NodeVisitor)

func (*SuperNode) Children 

func (node *SuperNode) Children() []Node

func (*SuperNode) MarshalJSON 

func (node *SuperNode) MarshalJSON() ([]byte, error)

type SymbolFlags 

type SymbolFlags int16
const (
	SYMBOL_FORCED_UTF8_ENCODING     SymbolFlags = 1 << 0
	SYMBOL_FORCED_BINARY_ENCODING   SymbolFlags = 1 << 1
	SYMBOL_FORCED_US_ASCII_ENCODING SymbolFlags = 1 << 2
)

type SymbolNode 

type SymbolNode struct {
	Flags      SymbolFlags
	Openingloc *Location
	Valueloc   *Location
	Closingloc *Location
	Unescaped  string
	Loc        *Location
}

func NewSymbolNode 

func NewSymbolNode(flags SymbolFlags, openingLoc *Location, valueLoc *Location, closingLoc *Location, unescaped string, loc *Location) *SymbolNode

func (*SymbolNode) Accept 

func (node *SymbolNode) Accept(visitor NodeVisitor)

func (*SymbolNode) Children 

func (node *SymbolNode) Children() []Node

func (*SymbolNode) IsForcedBinaryEncoding 

func (node *SymbolNode) IsForcedBinaryEncoding() bool

func (*SymbolNode) IsForcedUsAsciiEncoding 

func (node *SymbolNode) IsForcedUsAsciiEncoding() bool

func (*SymbolNode) IsForcedUtf8Encoding 

func (node *SymbolNode) IsForcedUtf8Encoding() bool

func (*SymbolNode) MarshalJSON 

func (node *SymbolNode) MarshalJSON() ([]byte, error)

type SyntaxError 

type SyntaxError struct {
	Message  string
	Location *Location
	Level    SyntaxErrorLevel
	Type     SyntaxErrorType
}

func NewSyntaxError 

func NewSyntaxError(
	message string,
	location *Location,
	level SyntaxErrorLevel,
	errType SyntaxErrorType,
) *SyntaxError

type SyntaxErrorLevel 

type SyntaxErrorLevel int
const (
	SyntaxErrorFatal SyntaxErrorLevel = iota
	SyntaxErrorArgument
)

type SyntaxErrorType 

type SyntaxErrorType int
const (
	ALIAS_ARGUMENT                     SyntaxErrorType = 0
	AMPAMPEQ_MULTI_ASSIGN              SyntaxErrorType = 1
	ARGUMENT_AFTER_BLOCK               SyntaxErrorType = 2
	ARGUMENT_AFTER_FORWARDING_ELLIPSES SyntaxErrorType = 3
	ARGUMENT_BARE_HASH                 SyntaxErrorType = 4
	ARGUMENT_BLOCK_FORWARDING          SyntaxErrorType = 5
	ARGUMENT_BLOCK_MULTI               SyntaxErrorType = 6
	ARGUMENT_FORMAL_CLASS              SyntaxErrorType = 7
	ARGUMENT_FORMAL_CONSTANT           SyntaxErrorType = 8
	ARGUMENT_FORMAL_GLOBAL             SyntaxErrorType = 9
	ARGUMENT_FORMAL_IVAR               SyntaxErrorType = 10
	ARGUMENT_FORWARDING_UNBOUND        SyntaxErrorType = 11
	ARGUMENT_IN                        SyntaxErrorType = 12
	ARGUMENT_NO_FORWARDING_AMP         SyntaxErrorType = 13
	ARGUMENT_NO_FORWARDING_ELLIPSES    SyntaxErrorType = 14
	ARGUMENT_NO_FORWARDING_STAR        SyntaxErrorType = 15
	ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT   SyntaxErrorType = 16
	ARGUMENT_SPLAT_AFTER_SPLAT         SyntaxErrorType = 17
	ARGUMENT_TERM_PAREN                SyntaxErrorType = 18
	ARGUMENT_UNEXPECTED_BLOCK          SyntaxErrorType = 19
	ARRAY_ELEMENT                      SyntaxErrorType = 20
	ARRAY_EXPRESSION                   SyntaxErrorType = 21
	ARRAY_EXPRESSION_AFTER_STAR        SyntaxErrorType = 22
	ARRAY_SEPARATOR                    SyntaxErrorType = 23
	ARRAY_TERM                         SyntaxErrorType = 24
	BEGIN_LONELY_ELSE                  SyntaxErrorType = 25
	BEGIN_TERM                         SyntaxErrorType = 26
	BEGIN_UPCASE_BRACE                 SyntaxErrorType = 27
	BEGIN_UPCASE_TERM                  SyntaxErrorType = 28
	BEGIN_UPCASE_TOPLEVEL              SyntaxErrorType = 29
	BLOCK_PARAM_LOCAL_VARIABLE         SyntaxErrorType = 30
	BLOCK_PARAM_PIPE_TERM              SyntaxErrorType = 31
	BLOCK_TERM_BRACE                   SyntaxErrorType = 32
	BLOCK_TERM_END                     SyntaxErrorType = 33
	CANNOT_PARSE_EXPRESSION            SyntaxErrorType = 34
	CANNOT_PARSE_STRING_PART           SyntaxErrorType = 35
	CASE_EXPRESSION_AFTER_CASE         SyntaxErrorType = 36
	CASE_EXPRESSION_AFTER_WHEN         SyntaxErrorType = 37
	CASE_MATCH_MISSING_PREDICATE       SyntaxErrorType = 38
	CASE_MISSING_CONDITIONS            SyntaxErrorType = 39
	CASE_TERM                          SyntaxErrorType = 40
	CLASS_IN_METHOD                    SyntaxErrorType = 41
	CLASS_NAME                         SyntaxErrorType = 42
	CLASS_SUPERCLASS                   SyntaxErrorType = 43
	CLASS_TERM                         SyntaxErrorType = 44
	CLASS_UNEXPECTED_END               SyntaxErrorType = 45
	CONDITIONAL_ELSIF_PREDICATE        SyntaxErrorType = 46
	CONDITIONAL_IF_PREDICATE           SyntaxErrorType = 47
	CONDITIONAL_PREDICATE_TERM         SyntaxErrorType = 48
	CONDITIONAL_TERM                   SyntaxErrorType = 49
	CONDITIONAL_TERM_ELSE              SyntaxErrorType = 50
	CONDITIONAL_UNLESS_PREDICATE       SyntaxErrorType = 51
	CONDITIONAL_UNTIL_PREDICATE        SyntaxErrorType = 52
	CONDITIONAL_WHILE_PREDICATE        SyntaxErrorType = 53
	CONSTANT_PATH_COLON_COLON_CONSTANT SyntaxErrorType = 54
	DEF_ENDLESS                        SyntaxErrorType = 55
	DEF_ENDLESS_SETTER                 SyntaxErrorType = 56
	DEF_NAME                           SyntaxErrorType = 57
	DEF_NAME_AFTER_RECEIVER            SyntaxErrorType = 58
	DEF_PARAMS_TERM                    SyntaxErrorType = 59
	DEF_PARAMS_TERM_PAREN              SyntaxErrorType = 60
	DEF_RECEIVER                       SyntaxErrorType = 61
	DEF_RECEIVER_TERM                  SyntaxErrorType = 62
	DEF_TERM                           SyntaxErrorType = 63
	DEFINED_EXPRESSION                 SyntaxErrorType = 64
	EMBDOC_TERM                        SyntaxErrorType = 65
	EMBEXPR_END                        SyntaxErrorType = 66
	EMBVAR_INVALID                     SyntaxErrorType = 67
	END_UPCASE_BRACE                   SyntaxErrorType = 68
	END_UPCASE_TERM                    SyntaxErrorType = 69
	ESCAPE_INVALID_CONTROL             SyntaxErrorType = 70
	ESCAPE_INVALID_CONTROL_REPEAT      SyntaxErrorType = 71
	ESCAPE_INVALID_HEXADECIMAL         SyntaxErrorType = 72
	ESCAPE_INVALID_META                SyntaxErrorType = 73
	ESCAPE_INVALID_META_REPEAT         SyntaxErrorType = 74
	ESCAPE_INVALID_UNICODE             SyntaxErrorType = 75
	ESCAPE_INVALID_UNICODE_CM_FLAGS    SyntaxErrorType = 76
	ESCAPE_INVALID_UNICODE_LITERAL     SyntaxErrorType = 77
	ESCAPE_INVALID_UNICODE_LONG        SyntaxErrorType = 78
	ESCAPE_INVALID_UNICODE_TERM        SyntaxErrorType = 79
	EXPECT_ARGUMENT                    SyntaxErrorType = 80
	EXPECT_EOL_AFTER_STATEMENT         SyntaxErrorType = 81
	EXPECT_EXPRESSION_AFTER_AMPAMPEQ   SyntaxErrorType = 82
	EXPECT_EXPRESSION_AFTER_COMMA      SyntaxErrorType = 83
	EXPECT_EXPRESSION_AFTER_EQUAL      SyntaxErrorType = 84
	EXPECT_EXPRESSION_AFTER_LESS_LESS  SyntaxErrorType = 85
	EXPECT_EXPRESSION_AFTER_LPAREN     SyntaxErrorType = 86
	EXPECT_EXPRESSION_AFTER_OPERATOR   SyntaxErrorType = 87
	EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ SyntaxErrorType = 88
	EXPECT_EXPRESSION_AFTER_QUESTION   SyntaxErrorType = 89
	EXPECT_EXPRESSION_AFTER_SPLAT      SyntaxErrorType = 90
	EXPECT_EXPRESSION_AFTER_SPLAT_HASH SyntaxErrorType = 91
	EXPECT_EXPRESSION_AFTER_STAR       SyntaxErrorType = 92
	EXPECT_IDENT_REQ_PARAMETER         SyntaxErrorType = 93
	EXPECT_LPAREN_REQ_PARAMETER        SyntaxErrorType = 94
	EXPECT_RBRACKET                    SyntaxErrorType = 95
	EXPECT_RPAREN                      SyntaxErrorType = 96
	EXPECT_RPAREN_AFTER_MULTI          SyntaxErrorType = 97
	EXPECT_RPAREN_REQ_PARAMETER        SyntaxErrorType = 98
	EXPECT_STRING_CONTENT              SyntaxErrorType = 99
	EXPECT_WHEN_DELIMITER              SyntaxErrorType = 100
	EXPRESSION_BARE_HASH               SyntaxErrorType = 101
	FLOAT_PARSE                        SyntaxErrorType = 102
	FOR_COLLECTION                     SyntaxErrorType = 103
	FOR_IN                             SyntaxErrorType = 104
	FOR_INDEX                          SyntaxErrorType = 105
	FOR_TERM                           SyntaxErrorType = 106
	HASH_EXPRESSION_AFTER_LABEL        SyntaxErrorType = 107
	HASH_KEY                           SyntaxErrorType = 108
	HASH_ROCKET                        SyntaxErrorType = 109
	HASH_TERM                          SyntaxErrorType = 110
	HASH_VALUE                         SyntaxErrorType = 111
	HEREDOC_TERM                       SyntaxErrorType = 112
	INCOMPLETE_QUESTION_MARK           SyntaxErrorType = 113
	INCOMPLETE_VARIABLE_CLASS          SyntaxErrorType = 114
	INCOMPLETE_VARIABLE_CLASS_3_3_0    SyntaxErrorType = 115
	INCOMPLETE_VARIABLE_INSTANCE       SyntaxErrorType = 116
	INCOMPLETE_VARIABLE_INSTANCE_3_3_0 SyntaxErrorType = 117
	INVALID_CHARACTER                  SyntaxErrorType = 118
	INVALID_ENCODING_MAGIC_COMMENT     SyntaxErrorType = 119
	INVALID_FLOAT_EXPONENT             SyntaxErrorType = 120
	INVALID_MULTIBYTE_CHAR             SyntaxErrorType = 121
	INVALID_MULTIBYTE_CHARACTER        SyntaxErrorType = 122
	INVALID_MULTIBYTE_ESCAPE           SyntaxErrorType = 123
	INVALID_NUMBER_BINARY              SyntaxErrorType = 124
	INVALID_NUMBER_DECIMAL             SyntaxErrorType = 125
	INVALID_NUMBER_HEXADECIMAL         SyntaxErrorType = 126
	INVALID_NUMBER_OCTAL               SyntaxErrorType = 127
	INVALID_NUMBER_UNDERSCORE          SyntaxErrorType = 128
	INVALID_PERCENT                    SyntaxErrorType = 129
	INVALID_PRINTABLE_CHARACTER        SyntaxErrorType = 130
	INVALID_VARIABLE_GLOBAL            SyntaxErrorType = 131
	INVALID_VARIABLE_GLOBAL_3_3_0      SyntaxErrorType = 132
	IT_NOT_ALLOWED_NUMBERED            SyntaxErrorType = 133
	IT_NOT_ALLOWED_ORDINARY            SyntaxErrorType = 134
	LAMBDA_OPEN                        SyntaxErrorType = 135
	LAMBDA_TERM_BRACE                  SyntaxErrorType = 136
	LAMBDA_TERM_END                    SyntaxErrorType = 137
	LIST_I_LOWER_ELEMENT               SyntaxErrorType = 138
	LIST_I_LOWER_TERM                  SyntaxErrorType = 139
	LIST_I_UPPER_ELEMENT               SyntaxErrorType = 140
	LIST_I_UPPER_TERM                  SyntaxErrorType = 141
	LIST_W_LOWER_ELEMENT               SyntaxErrorType = 142
	LIST_W_LOWER_TERM                  SyntaxErrorType = 143
	LIST_W_UPPER_ELEMENT               SyntaxErrorType = 144
	LIST_W_UPPER_TERM                  SyntaxErrorType = 145
	MALLOC_FAILED                      SyntaxErrorType = 146
	MIXED_ENCODING                     SyntaxErrorType = 147
	MODULE_IN_METHOD                   SyntaxErrorType = 148
	MODULE_NAME                        SyntaxErrorType = 149
	MODULE_TERM                        SyntaxErrorType = 150
	MULTI_ASSIGN_MULTI_SPLATS          SyntaxErrorType = 151
	MULTI_ASSIGN_UNEXPECTED_REST       SyntaxErrorType = 152
	NO_LOCAL_VARIABLE                  SyntaxErrorType = 153
	NOT_EXPRESSION                     SyntaxErrorType = 154
	NUMBER_LITERAL_UNDERSCORE          SyntaxErrorType = 155
	NUMBERED_PARAMETER_IT              SyntaxErrorType = 156
	NUMBERED_PARAMETER_ORDINARY        SyntaxErrorType = 157
	NUMBERED_PARAMETER_OUTER_SCOPE     SyntaxErrorType = 158
	OPERATOR_MULTI_ASSIGN              SyntaxErrorType = 159
	OPERATOR_WRITE_ARGUMENTS           SyntaxErrorType = 160
	OPERATOR_WRITE_BLOCK               SyntaxErrorType = 161
	PARAMETER_ASSOC_SPLAT_MULTI        SyntaxErrorType = 162
	PARAMETER_BLOCK_MULTI              SyntaxErrorType = 163
	PARAMETER_CIRCULAR                 SyntaxErrorType = 164
	PARAMETER_METHOD_NAME              SyntaxErrorType = 165
	PARAMETER_NAME_REPEAT              SyntaxErrorType = 166
	PARAMETER_NO_DEFAULT               SyntaxErrorType = 167
	PARAMETER_NO_DEFAULT_KW            SyntaxErrorType = 168
	PARAMETER_NUMBERED_RESERVED        SyntaxErrorType = 169
	PARAMETER_ORDER                    SyntaxErrorType = 170
	PARAMETER_SPLAT_MULTI              SyntaxErrorType = 171
	PARAMETER_STAR                     SyntaxErrorType = 172
	PARAMETER_UNEXPECTED_FWD           SyntaxErrorType = 173
	PARAMETER_WILD_LOOSE_COMMA         SyntaxErrorType = 174
	PATTERN_EXPRESSION_AFTER_BRACKET   SyntaxErrorType = 175
	PATTERN_EXPRESSION_AFTER_COMMA     SyntaxErrorType = 176
	PATTERN_EXPRESSION_AFTER_HROCKET   SyntaxErrorType = 177
	PATTERN_EXPRESSION_AFTER_IN        SyntaxErrorType = 178
	PATTERN_EXPRESSION_AFTER_KEY       SyntaxErrorType = 179
	PATTERN_EXPRESSION_AFTER_PAREN     SyntaxErrorType = 180
	PATTERN_EXPRESSION_AFTER_PIN       SyntaxErrorType = 181
	PATTERN_EXPRESSION_AFTER_PIPE      SyntaxErrorType = 182
	PATTERN_EXPRESSION_AFTER_RANGE     SyntaxErrorType = 183
	PATTERN_EXPRESSION_AFTER_REST      SyntaxErrorType = 184
	PATTERN_HASH_KEY                   SyntaxErrorType = 185
	PATTERN_HASH_KEY_LABEL             SyntaxErrorType = 186
	PATTERN_IDENT_AFTER_HROCKET        SyntaxErrorType = 187
	PATTERN_LABEL_AFTER_COMMA          SyntaxErrorType = 188
	PATTERN_REST                       SyntaxErrorType = 189
	PATTERN_TERM_BRACE                 SyntaxErrorType = 190
	PATTERN_TERM_BRACKET               SyntaxErrorType = 191
	PATTERN_TERM_PAREN                 SyntaxErrorType = 192
	PIPEPIPEEQ_MULTI_ASSIGN            SyntaxErrorType = 193
	REGEXP_ENCODING_OPTION_MISMATCH    SyntaxErrorType = 194
	REGEXP_INCOMPAT_CHAR_ENCODING      SyntaxErrorType = 195
	REGEXP_INVALID_UNICODE_RANGE       SyntaxErrorType = 196
	REGEXP_NON_ESCAPED_MBC             SyntaxErrorType = 197
	REGEXP_TERM                        SyntaxErrorType = 198
	REGEXP_UTF8_CHAR_NON_UTF8_REGEXP   SyntaxErrorType = 199
	RESCUE_EXPRESSION                  SyntaxErrorType = 200
	RESCUE_MODIFIER_VALUE              SyntaxErrorType = 201
	RESCUE_TERM                        SyntaxErrorType = 202
	RESCUE_VARIABLE                    SyntaxErrorType = 203
	RETURN_INVALID                     SyntaxErrorType = 204
	SINGLETON_FOR_LITERALS             SyntaxErrorType = 205
	STATEMENT_ALIAS                    SyntaxErrorType = 206
	STATEMENT_POSTEXE_END              SyntaxErrorType = 207
	STATEMENT_PREEXE_BEGIN             SyntaxErrorType = 208
	STATEMENT_UNDEF                    SyntaxErrorType = 209
	STRING_CONCATENATION               SyntaxErrorType = 210
	STRING_INTERPOLATED_TERM           SyntaxErrorType = 211
	STRING_LITERAL_EOF                 SyntaxErrorType = 212
	STRING_LITERAL_TERM                SyntaxErrorType = 213
	SYMBOL_INVALID                     SyntaxErrorType = 214
	SYMBOL_TERM_DYNAMIC                SyntaxErrorType = 215
	SYMBOL_TERM_INTERPOLATED           SyntaxErrorType = 216
	TERNARY_COLON                      SyntaxErrorType = 217
	TERNARY_EXPRESSION_FALSE           SyntaxErrorType = 218
	TERNARY_EXPRESSION_TRUE            SyntaxErrorType = 219
	UNARY_RECEIVER                     SyntaxErrorType = 220
	UNDEF_ARGUMENT                     SyntaxErrorType = 221
	UNEXPECTED_TOKEN_CLOSE_CONTEXT     SyntaxErrorType = 222
	UNEXPECTED_TOKEN_IGNORE            SyntaxErrorType = 223
	UNTIL_TERM                         SyntaxErrorType = 224
	VOID_EXPRESSION                    SyntaxErrorType = 225
	WHILE_TERM                         SyntaxErrorType = 226
	WRITE_TARGET_IN_METHOD             SyntaxErrorType = 227
	WRITE_TARGET_READONLY              SyntaxErrorType = 228
	WRITE_TARGET_UNEXPECTED            SyntaxErrorType = 229
	XSTRING_TERM                       SyntaxErrorType = 230
)

type SyntaxWarning 

type SyntaxWarning struct {
	Message  string
	Location *Location
	Level    SyntaxWarningLevel
	Type     SyntaxWarningType
}

func NewSyntaxWarning 

func NewSyntaxWarning(
	message string,
	location *Location,
	level SyntaxWarningLevel,
	warnType SyntaxWarningType,
) *SyntaxWarning

type SyntaxWarningLevel 

type SyntaxWarningLevel int
const (
	SyntaxWarningDefault SyntaxWarningLevel = iota
	SyntaxWarningVerbose
)

type SyntaxWarningType 

type SyntaxWarningType int
const (
	AMBIGUOUS_FIRST_ARGUMENT_MINUS SyntaxWarningType = 0
	AMBIGUOUS_FIRST_ARGUMENT_PLUS  SyntaxWarningType = 1
	AMBIGUOUS_PREFIX_STAR          SyntaxWarningType = 2
	AMBIGUOUS_SLASH                SyntaxWarningType = 3
	DOT_DOT_DOT_EOL                SyntaxWarningType = 4
	EQUAL_IN_CONDITIONAL           SyntaxWarningType = 5
	END_IN_METHOD                  SyntaxWarningType = 6
	DUPLICATED_HASH_KEY            SyntaxWarningType = 7
	DUPLICATED_WHEN_CLAUSE         SyntaxWarningType = 8
	FLOAT_OUT_OF_RANGE             SyntaxWarningType = 9
	INTEGER_IN_FLIP_FLOP           SyntaxWarningType = 10
	KEYWORD_EOL                    SyntaxWarningType = 11
)

type TrueNode 

type TrueNode struct {
	Loc *Location
}

func NewTrueNode 

func NewTrueNode(loc *Location) *TrueNode

func (*TrueNode) Accept 

func (node *TrueNode) Accept(visitor NodeVisitor)

func (*TrueNode) Children 

func (node *TrueNode) Children() []Node

func (*TrueNode) MarshalJSON 

func (node *TrueNode) MarshalJSON() ([]byte, error)

type UndefNode 

type UndefNode struct {
	Names      []Node
	Keywordloc *Location
	Loc        *Location
}

func NewUndefNode 

func NewUndefNode(names []Node, keywordLoc *Location, loc *Location) *UndefNode

func (*UndefNode) Accept 

func (node *UndefNode) Accept(visitor NodeVisitor)

func (*UndefNode) Children 

func (node *UndefNode) Children() []Node

func (*UndefNode) MarshalJSON 

func (node *UndefNode) MarshalJSON() ([]byte, error)

type UnlessNode 

type UnlessNode struct {
	Keywordloc     *Location
	Predicate      Node
	Thenkeywordloc *Location
	Statements     *StatementsNode
	Consequent     *ElseNode
	Endkeywordloc  *Location
	Loc            *Location
}

func NewUnlessNode 

func NewUnlessNode(keywordLoc *Location, predicate Node, thenKeywordLoc *Location, statements *StatementsNode, consequent *ElseNode, endKeywordLoc *Location, loc *Location) *UnlessNode

func (*UnlessNode) Accept 

func (node *UnlessNode) Accept(visitor NodeVisitor)

func (*UnlessNode) Children 

func (node *UnlessNode) Children() []Node

func (*UnlessNode) MarshalJSON 

func (node *UnlessNode) MarshalJSON() ([]byte, error)

type UntilNode 

type UntilNode struct {
	Flags      LoopFlags
	Keywordloc *Location
	Closingloc *Location
	Predicate  Node
	Statements *StatementsNode
	Loc        *Location
}

func NewUntilNode 

func NewUntilNode(flags LoopFlags, keywordLoc *Location, closingLoc *Location, predicate Node, statements *StatementsNode, loc *Location) *UntilNode

func (*UntilNode) Accept 

func (node *UntilNode) Accept(visitor NodeVisitor)

func (*UntilNode) Children 

func (node *UntilNode) Children() []Node

func (*UntilNode) IsBeginModifier 

func (node *UntilNode) IsBeginModifier() bool

func (*UntilNode) MarshalJSON 

func (node *UntilNode) MarshalJSON() ([]byte, error)

type WhenNode 

type WhenNode struct {
	Keywordloc     *Location
	Conditions     []Node
	Thenkeywordloc *Location
	Statements     *StatementsNode
	Loc            *Location
}

func NewWhenNode 

func NewWhenNode(keywordLoc *Location, conditions []Node, thenKeywordLoc *Location, statements *StatementsNode, loc *Location) *WhenNode

func (*WhenNode) Accept 

func (node *WhenNode) Accept(visitor NodeVisitor)

func (*WhenNode) Children 

func (node *WhenNode) Children() []Node

func (*WhenNode) MarshalJSON 

func (node *WhenNode) MarshalJSON() ([]byte, error)

type WhileNode 

type WhileNode struct {
	Flags      LoopFlags
	Keywordloc *Location
	Closingloc *Location
	Predicate  Node
	Statements *StatementsNode
	Loc        *Location
}

func NewWhileNode 

func NewWhileNode(flags LoopFlags, keywordLoc *Location, closingLoc *Location, predicate Node, statements *StatementsNode, loc *Location) *WhileNode

func (*WhileNode) Accept 

func (node *WhileNode) Accept(visitor NodeVisitor)

func (*WhileNode) Children 

func (node *WhileNode) Children() []Node

func (*WhileNode) IsBeginModifier 

func (node *WhileNode) IsBeginModifier() bool

func (*WhileNode) MarshalJSON 

func (node *WhileNode) MarshalJSON() ([]byte, error)

type XStringNode 

type XStringNode struct {
	Flags      EncodingFlags
	Openingloc *Location
	Contentloc *Location
	Closingloc *Location
	Unescaped  string
	Loc        *Location
}

func NewXStringNode 

func NewXStringNode(flags EncodingFlags, openingLoc *Location, contentLoc *Location, closingLoc *Location, unescaped string, loc *Location) *XStringNode

func (*XStringNode) Accept 

func (node *XStringNode) Accept(visitor NodeVisitor)

func (*XStringNode) Children 

func (node *XStringNode) Children() []Node

func (*XStringNode) IsForcedBinaryEncoding 

func (node *XStringNode) IsForcedBinaryEncoding() bool

func (*XStringNode) IsForcedUtf8Encoding 

func (node *XStringNode) IsForcedUtf8Encoding() bool

func (*XStringNode) MarshalJSON 

func (node *XStringNode) MarshalJSON() ([]byte, error)

type YieldNode 

type YieldNode struct {
	Keywordloc *Location
	Lparenloc  *Location
	Arguments  *ArgumentsNode
	Rparenloc  *Location
	Loc        *Location
}

func NewYieldNode 

func NewYieldNode(keywordLoc *Location, lparenLoc *Location, arguments *ArgumentsNode, rparenLoc *Location, loc *Location) *YieldNode

func (*YieldNode) Accept 

func (node *YieldNode) Accept(visitor NodeVisitor)

func (*YieldNode) Children 

func (node *YieldNode) Children() []Node

func (*YieldNode) MarshalJSON 

func (node *YieldNode) MarshalJSON() ([]byte, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.