asty

package
v0.1.8 Latest Latest
Warning

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

 Go to latest Published: Feb 3, 2023 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ChanDirToString = map[ast.ChanDir]string{
	ast.SEND:            "SEND",
	ast.RECV:            "RECV",
	ast.SEND | ast.RECV: "BOTH",
}
View Source 
var StringToChanDir = map[string]ast.ChanDir{
	"SEND": ast.SEND,
	"RECV": ast.RECV,
	"BOTH": ast.SEND | ast.RECV,
}
View Source 
var StringToToken = map[string]token.Token{}

Functions

func JSONToSource 

func JSONToSource(input, output string, options Options) error

func Loop 

func Loop(input, output string, comments bool) error

func MarshalJSONDecls 

func MarshalJSONDecls(decls []IDeclNode) ([]json.RawMessage, error)

func SourceToJSON 

func SourceToJSON(input, output string, indent string, options Options) error

Types

type ArrayTypeNode 

type ArrayTypeNode struct {
	Node
	Lbrack *PositionNode `json:"Lbrack,omitempty"`
	Len    IExprNode     `json:"Len"`
	Elt    IExprNode     `json:"Elt"`
}

func (ArrayTypeNode) GetRefId 

func (node ArrayTypeNode) GetRefId() int

func (*ArrayTypeNode) UnmarshalExpr 

func (node *ArrayTypeNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*ArrayTypeNode) UnmarshalJSON 

func (node *ArrayTypeNode) UnmarshalJSON(data []byte) error

type ArrayTypeNodeAlias 

type ArrayTypeNodeAlias struct {
	Node
	Lbrack *PositionNode
	Len    json.RawMessage
	Elt    json.RawMessage
}

type AssignStmtNode 

type AssignStmtNode struct {
	Node
	Lhs    []IExprNode   `json:"Lhs"`
	TokPos *PositionNode `json:"TokPos,omitempty"`
	Tok    string        `json:"Tok"`
	Rhs    []IExprNode   `json:"Rhs"`
}

func (AssignStmtNode) GetRefId 

func (node AssignStmtNode) GetRefId() int

func (*AssignStmtNode) UnmarshalJSON 

func (node *AssignStmtNode) UnmarshalJSON(data []byte) error

func (*AssignStmtNode) UnmarshalStmt 

func (node *AssignStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type AssignStmtNodeAlias 

type AssignStmtNodeAlias struct {
	Node
	Lhs    []json.RawMessage
	TokPos *PositionNode
	Tok    string
	Rhs    []json.RawMessage
}

type BadDeclNode 

type BadDeclNode struct {
	Node
	From *PositionNode `json:"From,omitempty"`
	To   *PositionNode `json:"To,omitempty"`
}

func (BadDeclNode) GetRefId 

func (node BadDeclNode) GetRefId() int

func (*BadDeclNode) UnmarshalDecl 

func (node *BadDeclNode) UnmarshalDecl(um IDeclUnmarshaller) ast.Decl

type BadExprNode 

type BadExprNode struct {
	Node
	From *PositionNode `json:"From,omitempty"`
	To   *PositionNode `json:"To,omitempty"`
}

func (BadExprNode) GetRefId 

func (node BadExprNode) GetRefId() int

func (*BadExprNode) UnmarshalExpr 

func (node *BadExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

type BadStmtNode 

type BadStmtNode struct {
	Node
	From *PositionNode `json:"From,omitempty"`
	To   *PositionNode `json:"To,omitempty"`
}

func (BadStmtNode) GetRefId 

func (node BadStmtNode) GetRefId() int

func (*BadStmtNode) UnmarshalStmt 

func (node *BadStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type BasicLitNode 

type BasicLitNode struct {
	Node
	ValuePos *PositionNode `json:"ValuePos,omitempty"`
	Kind     string        `json:"Kind"`
	Value    string        `json:"Value"`
}

func (BasicLitNode) GetRefId 

func (node BasicLitNode) GetRefId() int

func (*BasicLitNode) UnmarshalExpr 

func (node *BasicLitNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

type BinaryExprNode 

type BinaryExprNode struct {
	Node
	X     IExprNode     `json:"X"`
	OpPos *PositionNode `json:"OpPos,omitempty"`
	Op    string        `json:"Op"`
	Y     IExprNode     `json:"Y"`
}

func (BinaryExprNode) GetRefId 

func (node BinaryExprNode) GetRefId() int

func (*BinaryExprNode) UnmarshalExpr 

func (node *BinaryExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*BinaryExprNode) UnmarshalJSON 

func (node *BinaryExprNode) UnmarshalJSON(data []byte) error

type BinaryExprNodeAlias 

type BinaryExprNodeAlias struct {
	Node
	X     json.RawMessage
	OpPos *PositionNode
	Op    string
	Y     json.RawMessage
}

type BlockStmtNode 

type BlockStmtNode struct {
	Node
	Lbrace *PositionNode `json:"Lbrace,omitempty"`
	List   []IStmtNode   `json:"List"`
	Rbrace *PositionNode `json:"Rbrace,omitempty"`
}

func (BlockStmtNode) GetRefId 

func (node BlockStmtNode) GetRefId() int

func (*BlockStmtNode) UnmarshalJSON 

func (node *BlockStmtNode) UnmarshalJSON(data []byte) error

func (*BlockStmtNode) UnmarshalStmt 

func (node *BlockStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type BlockStmtNodeAlias 

type BlockStmtNodeAlias struct {
	Node
	Lbrace *PositionNode
	List   []json.RawMessage
	Rbrace *PositionNode
}

type BranchStmtNode 

type BranchStmtNode struct {
	Node
	TokPos *PositionNode `json:"TokPos,omitempty"`
	Tok    string        `json:"Tok"`
	Label  *IdentNode    `json:"Label"`
}

func (BranchStmtNode) GetRefId 

func (node BranchStmtNode) GetRefId() int

func (*BranchStmtNode) UnmarshalStmt 

func (node *BranchStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type CallExprNode 

type CallExprNode struct {
	Node
	Fun      IExprNode     `json:"Fun"`
	Lparen   *PositionNode `json:"Lparen,omitempty"`
	Args     []IExprNode   `json:"Args"`
	Ellipsis *PositionNode `json:"Ellipsis,omitempty"`
	Rparen   *PositionNode `json:"Rparen,omitempty"`
}

func (CallExprNode) GetRefId 

func (node CallExprNode) GetRefId() int

func (*CallExprNode) UnmarshalExpr 

func (node *CallExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*CallExprNode) UnmarshalJSON 

func (node *CallExprNode) UnmarshalJSON(data []byte) error

type CallExprNodeAlias 

type CallExprNodeAlias struct {
	Node
	Fun      json.RawMessage
	Lparen   *PositionNode
	Args     []json.RawMessage
	Ellipsis *PositionNode
	Rparen   *PositionNode
}

type CaseClauseNode 

type CaseClauseNode struct {
	Node
	Case  *PositionNode `json:"Case,omitempty"`
	List  []IExprNode   `json:"List"`
	Colon *PositionNode `json:"Colon,omitempty"`
	Body  []IStmtNode   `json:"Body"`
}

func (CaseClauseNode) GetRefId 

func (node CaseClauseNode) GetRefId() int

func (*CaseClauseNode) UnmarshalJSON 

func (node *CaseClauseNode) UnmarshalJSON(data []byte) error

func (*CaseClauseNode) UnmarshalStmt 

func (node *CaseClauseNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type CaseClauseNodeAlias 

type CaseClauseNodeAlias struct {
	Node
	Case  *PositionNode
	List  []json.RawMessage
	Colon *PositionNode
	Body  []json.RawMessage
}

type ChanTypeNode 

type ChanTypeNode struct {
	Node
	Begin *PositionNode `json:"Begin,omitempty"`
	Arrow *PositionNode `json:"Arrow,omitempty"`
	Dir   string        `json:"Dir"`
	Value IExprNode     `json:"Value"`
}

func (ChanTypeNode) GetRefId 

func (node ChanTypeNode) GetRefId() int

func (*ChanTypeNode) UnmarshalExpr 

func (node *ChanTypeNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*ChanTypeNode) UnmarshalJSON 

func (node *ChanTypeNode) UnmarshalJSON(data []byte) error

type ChanTypeNodeAlias 

type ChanTypeNodeAlias struct {
	Node
	Begin *PositionNode
	Arrow *PositionNode
	Dir   string
	Value json.RawMessage
}

type CommClauseNode 

type CommClauseNode struct {
	Node
	Case  *PositionNode `json:"Case,omitempty"`
	Comm  IStmtNode     `json:"Comm"`
	Colon *PositionNode `json:"Colon,omitempty"`
	Body  []IStmtNode   `json:"Body"`
}

func (CommClauseNode) GetRefId 

func (node CommClauseNode) GetRefId() int

func (*CommClauseNode) UnmarshalJSON 

func (node *CommClauseNode) UnmarshalJSON(data []byte) error

func (*CommClauseNode) UnmarshalStmt 

func (node *CommClauseNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type CommClauseNodeAlias 

type CommClauseNodeAlias struct {
	Node
	Case  *PositionNode
	Comm  json.RawMessage
	Colon *PositionNode
	Body  []json.RawMessage
}

type CommentGroupNode 

type CommentGroupNode struct {
	Node
	List []*CommentNode `json:"List,omitempty"`
}

func (CommentGroupNode) GetRefId 

func (node CommentGroupNode) GetRefId() int

type CommentNode 

type CommentNode struct {
	Node
	Slash *PositionNode `json:"Slash,omitempty"`
	Text  string        `json:"Text"`
}

func (CommentNode) GetRefId 

func (node CommentNode) GetRefId() int

type CompositeLitNode 

type CompositeLitNode struct {
	Node
	Type       IExprNode     `json:"Type"`
	Lbrace     *PositionNode `json:"Lbrace,omitempty"`
	Elts       []IExprNode   `json:"Elts"`
	Rbrace     *PositionNode `json:"Rbrace,omitempty"`
	Incomplete bool          `json:"Incomplete"`
}

func (CompositeLitNode) GetRefId 

func (node CompositeLitNode) GetRefId() int

func (*CompositeLitNode) UnmarshalExpr 

func (node *CompositeLitNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*CompositeLitNode) UnmarshalJSON 

func (node *CompositeLitNode) UnmarshalJSON(data []byte) error

type CompositeLitNodeAlias 

type CompositeLitNodeAlias struct {
	Node
	Type       json.RawMessage
	Lbrace     *PositionNode
	Elts       []json.RawMessage
	Rbrace     *PositionNode
	Incomplete bool
}

type DeclStmtNode 

type DeclStmtNode struct {
	Node
	Decl IDeclNode `json:"Decl"`
}

func (DeclStmtNode) GetRefId 

func (node DeclStmtNode) GetRefId() int

func (*DeclStmtNode) UnmarshalJSON 

func (node *DeclStmtNode) UnmarshalJSON(data []byte) error

func (*DeclStmtNode) UnmarshalStmt 

func (node *DeclStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type DeclStmtNodeAlias 

type DeclStmtNodeAlias struct {
	Node
	Decl json.RawMessage
}

type DeferStmtNode 

type DeferStmtNode struct {
	Node
	Defer *PositionNode `json:"Defer,omitempty"`
	Call  *CallExprNode `json:"Call"`
}

func (DeferStmtNode) GetRefId 

func (node DeferStmtNode) GetRefId() int

func (*DeferStmtNode) UnmarshalStmt 

func (node *DeferStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type EllipsisNode 

type EllipsisNode struct {
	Node
	Ellipsis *PositionNode `json:"Ellipsis,omitempty"`
	Elt      IExprNode     `json:"Elt"`
}

func (EllipsisNode) GetRefId 

func (node EllipsisNode) GetRefId() int

func (*EllipsisNode) UnmarshalExpr 

func (node *EllipsisNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*EllipsisNode) UnmarshalJSON 

func (node *EllipsisNode) UnmarshalJSON(data []byte) error

type EllipsisNodeAlias 

type EllipsisNodeAlias struct {
	Node
	Ellipsis *PositionNode
	Elt      json.RawMessage
}

type EmptyStmtNode 

type EmptyStmtNode struct {
	Node
	Semicolon *PositionNode `json:"Semicolon,omitempty"`
	Implicit  bool          `json:"Implicit"`
}

func (EmptyStmtNode) GetRefId 

func (node EmptyStmtNode) GetRefId() int

func (*EmptyStmtNode) UnmarshalStmt 

func (node *EmptyStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type ExprStmtNode 

type ExprStmtNode struct {
	Node
	X IExprNode `json:"X,omitempty"`
}

func (ExprStmtNode) GetRefId 

func (node ExprStmtNode) GetRefId() int

func (*ExprStmtNode) UnmarshalJSON 

func (node *ExprStmtNode) UnmarshalJSON(data []byte) error

func (*ExprStmtNode) UnmarshalStmt 

func (node *ExprStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type ExprStmtNodeAlias 

type ExprStmtNodeAlias struct {
	Node
	X json.RawMessage
}

type FieldListNode 

type FieldListNode struct {
	Node
	Opening *PositionNode `json:"Opening,omitempty"`
	List    []*FieldNode  `json:"List"`
	Closing *PositionNode `json:"Closing,omitempty"`
}

func (FieldListNode) GetRefId 

func (node FieldListNode) GetRefId() int

type FieldNode 

type FieldNode struct {
	Node
	Doc     *CommentGroupNode `json:"Doc,omitempty"`
	Names   []*IdentNode      `json:"Names"`
	Type    IExprNode         `json:"Type"`
	Tag     *BasicLitNode     `json:"Tag,omitempty"`
	Comment *CommentGroupNode `json:"Comment,omitempty"`
}

func (FieldNode) GetRefId 

func (node FieldNode) GetRefId() int

func (*FieldNode) UnmarshalJSON 

func (node *FieldNode) UnmarshalJSON(data []byte) error

type FieldNodeAlias 

type FieldNodeAlias struct {
	Node
	Doc     *CommentGroupNode
	Names   []*IdentNode
	Type    json.RawMessage
	Tag     *BasicLitNode
	Comment *CommentGroupNode
}

type FileNode 

type FileNode struct {
	Node
	Doc        *CommentGroupNode   `json:"Doc,omitempty"`
	Package    *PositionNode       `json:"Package,omitempty"`
	Name       *IdentNode          `json:"Name"`
	Decls      []IDeclNode         `json:"Decls,omitempty"`
	Imports    []*ImportSpecNode   `json:"Imports,omitempty"`
	Unresolved []*IdentNode        `json:"Unresolved,omitempty"`
	Comments   []*CommentGroupNode `json:"Comments,omitempty"`
	FileSet    *token.FileSet      `json:"FileSet,omitempty"`
}

func (FileNode) GetRefId 

func (node FileNode) GetRefId() int

func (*FileNode) MarshalJSON 

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

func (*FileNode) UnmarshalJSON 

func (node *FileNode) UnmarshalJSON(data []byte) error

type FileNodeAlias 

type FileNodeAlias struct {
	Node
	Doc        *CommentGroupNode
	Package    *PositionNode
	Name       *IdentNode
	Decls      []json.RawMessage
	Imports    []*ImportSpecNode
	Unresolved []*IdentNode
	Comments   []*CommentGroupNode
	FileSet    json.RawMessage
}

type ForStmtNode 

type ForStmtNode struct {
	Node
	For  *PositionNode  `json:"For,omitempty"`
	Init IStmtNode      `json:"Init"`
	Cond IExprNode      `json:"Cond"`
	Post IStmtNode      `json:"Post"`
	Body *BlockStmtNode `json:"Body"`
}

func (ForStmtNode) GetRefId 

func (node ForStmtNode) GetRefId() int

func (*ForStmtNode) UnmarshalJSON 

func (node *ForStmtNode) UnmarshalJSON(data []byte) error

func (*ForStmtNode) UnmarshalStmt 

func (node *ForStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type ForStmtNodeAlias 

type ForStmtNodeAlias struct {
	Node
	For  *PositionNode
	Init json.RawMessage
	Cond json.RawMessage
	Post json.RawMessage
	Body *BlockStmtNode
}

type FuncDeclNode 

type FuncDeclNode struct {
	Node
	Doc  *CommentGroupNode `json:"Doc,omitempty"`
	Recv *FieldListNode    `json:"Recv"`
	Name *IdentNode        `json:"Name"`
	Type *FuncTypeNode     `json:"Type"`
	Body *BlockStmtNode    `json:"Body"`
}

func (FuncDeclNode) GetRefId 

func (node FuncDeclNode) GetRefId() int

func (*FuncDeclNode) UnmarshalDecl 

func (node *FuncDeclNode) UnmarshalDecl(um IDeclUnmarshaller) ast.Decl

type FuncLitNode 

type FuncLitNode struct {
	Node
	Type *FuncTypeNode  `json:"Type"`
	Body *BlockStmtNode `json:"Body"`
}

func (FuncLitNode) GetRefId 

func (node FuncLitNode) GetRefId() int

func (*FuncLitNode) UnmarshalExpr 

func (node *FuncLitNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

type FuncTypeNode 

type FuncTypeNode struct {
	Node
	Func       *PositionNode  `json:"Func,omitempty"`
	TypeParams *FieldListNode `json:"TypeParams"`
	Params     *FieldListNode `json:"Params"`
	Results    *FieldListNode `json:"Results"`
}

func (FuncTypeNode) GetRefId 

func (node FuncTypeNode) GetRefId() int

func (*FuncTypeNode) UnmarshalExpr 

func (node *FuncTypeNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

type GenDeclNode 

type GenDeclNode struct {
	Node
	Doc    *CommentGroupNode `json:"Doc,omitempty"`
	TokPos *PositionNode     `json:"TokPos,omitempty"`
	Tok    string            `json:"Tok"`
	Lparen *PositionNode     `json:"Lparen,omitempty"`
	Specs  []ISpecNode       `json:"Specs"`
	Rparen *PositionNode     `json:"Rparen,omitempty"`
}

func (GenDeclNode) GetRefId 

func (node GenDeclNode) GetRefId() int

func (*GenDeclNode) UnmarshalDecl 

func (node *GenDeclNode) UnmarshalDecl(um IDeclUnmarshaller) ast.Decl

func (*GenDeclNode) UnmarshalJSON 

func (node *GenDeclNode) UnmarshalJSON(data []byte) error

type GenDeclNodeAlias 

type GenDeclNodeAlias struct {
	Node
	Doc    *CommentGroupNode
	TokPos *PositionNode
	Tok    string
	Lparen *PositionNode
	Specs  []json.RawMessage
	Rparen *PositionNode
}

type GoStmtNode 

type GoStmtNode struct {
	Node
	Go   *PositionNode `json:"Go,omitempty"`
	Call *CallExprNode `json:"Call"`
}

func (GoStmtNode) GetRefId 

func (node GoStmtNode) GetRefId() int

func (*GoStmtNode) UnmarshalStmt 

func (node *GoStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type IDeclNode 

type IDeclNode interface {
	INode
	UnmarshalDecl(IDeclUnmarshaller) ast.Decl
}

func MakeDecl 

func MakeDecl(nodeType string) IDeclNode

func UnmarshalJSONDecl 

func UnmarshalJSONDecl(data json.RawMessage) (IDeclNode, error)

func UnmarshalJSONDecls 

func UnmarshalJSONDecls(data []json.RawMessage) ([]IDeclNode, error)

type IDeclUnmarshaller 

type IDeclUnmarshaller interface {
	UnmarshalBadDeclNode(node *BadDeclNode) *ast.BadDecl
	UnmarshalGenDeclNode(node *GenDeclNode) *ast.GenDecl
	UnmarshalFuncDeclNode(node *FuncDeclNode) *ast.FuncDecl
}

type IExprNode 

type IExprNode interface {
	INode
	UnmarshalExpr(IExprUnmarshaller) ast.Expr
}

func MakeExpr 

func MakeExpr(nodeType string) IExprNode

func UnmarshalJSONExpr 

func UnmarshalJSONExpr(data json.RawMessage) (IExprNode, error)

func UnmarshalJSONExprs 

func UnmarshalJSONExprs(data []json.RawMessage) ([]IExprNode, error)

type IExprUnmarshaller 

type IExprUnmarshaller interface {
	UnmarshalBadExprNode(node *BadExprNode) *ast.BadExpr
	UnmarshalIdentNode(node *IdentNode) *ast.Ident
	UnmarshalEllipsisNode(node *EllipsisNode) *ast.Ellipsis
	UnmarshalBasicLitNode(node *BasicLitNode) *ast.BasicLit
	UnmarshalFuncLitNode(node *FuncLitNode) *ast.FuncLit
	UnmarshalCompositeLitNode(node *CompositeLitNode) *ast.CompositeLit
	UnmarshalParenExprNode(node *ParenExprNode) *ast.ParenExpr
	UnmarshalSelectorExprNode(node *SelectorExprNode) *ast.SelectorExpr
	UnmarshalIndexExprNode(node *IndexExprNode) *ast.IndexExpr
	UnmarshalIndexListExprNode(node *IndexListExprNode) *ast.IndexListExpr
	UnmarshalSliceExprNode(node *SliceExprNode) *ast.SliceExpr
	UnmarshalTypeAssertExprNode(node *TypeAssertExprNode) *ast.TypeAssertExpr
	UnmarshalCallExprNode(node *CallExprNode) *ast.CallExpr
	UnmarshalStarExprNode(node *StarExprNode) *ast.StarExpr
	UnmarshalUnaryExprNode(node *UnaryExprNode) *ast.UnaryExpr
	UnmarshalBinaryExprNode(node *BinaryExprNode) *ast.BinaryExpr
	UnmarshalKeyValueExprNode(node *KeyValueExprNode) *ast.KeyValueExpr
	UnmarshalArrayTypeNode(node *ArrayTypeNode) *ast.ArrayType
	UnmarshalStructTypeNode(node *StructTypeNode) *ast.StructType
	UnmarshalFuncTypeNode(node *FuncTypeNode) *ast.FuncType
	UnmarshalInterfaceTypeNode(node *InterfaceTypeNode) *ast.InterfaceType
	UnmarshalMapTypeNode(node *MapTypeNode) *ast.MapType
	UnmarshalChanTypeNode(node *ChanTypeNode) *ast.ChanType
}

type INode 

type INode interface {
	GetRefId() int
}

type ISpecNode 

type ISpecNode interface {
	INode
	UnmarshalSpec(ISpecUnmarshaller) ast.Spec
}

func MakeSpec 

func MakeSpec(nodeType string) ISpecNode

func UnmarshalJSONSpec 

func UnmarshalJSONSpec(data json.RawMessage) (ISpecNode, error)

func UnmarshalJSONSpecs 

func UnmarshalJSONSpecs(data []json.RawMessage) ([]ISpecNode, error)

type ISpecUnmarshaller 

type ISpecUnmarshaller interface {
	UnmarshalImportSpecNode(node *ImportSpecNode) *ast.ImportSpec
	UnmarshalValueSpecNode(node *ValueSpecNode) *ast.ValueSpec
	UnmarshalTypeSpecNode(node *TypeSpecNode) *ast.TypeSpec
}

type IStmtNode 

type IStmtNode interface {
	INode
	UnmarshalStmt(IStmtUnmarshaller) ast.Stmt
}

func MakeStmt 

func MakeStmt(nodeType string) IStmtNode

func UnmarshalJSONStmt 

func UnmarshalJSONStmt(data json.RawMessage) (IStmtNode, error)

func UnmarshalJSONStmts 

func UnmarshalJSONStmts(data []json.RawMessage) ([]IStmtNode, error)

type IStmtUnmarshaller 

type IStmtUnmarshaller interface {
	UnmarshalBadStmtNode(node *BadStmtNode) *ast.BadStmt
	UnmarshalDeclStmtNode(node *DeclStmtNode) *ast.DeclStmt
	UnmarshalEmptyStmtNode(node *EmptyStmtNode) *ast.EmptyStmt
	UnmarshalLabeledStmtNode(node *LabeledStmtNode) *ast.LabeledStmt
	UnmarshalExprStmtNode(node *ExprStmtNode) *ast.ExprStmt
	UnmarshalSendStmtNode(node *SendStmtNode) *ast.SendStmt
	UnmarshalIncDecStmtNode(node *IncDecStmtNode) *ast.IncDecStmt
	UnmarshalAssignStmtNode(node *AssignStmtNode) *ast.AssignStmt
	UnmarshalGoStmtNode(node *GoStmtNode) *ast.GoStmt
	UnmarshalDeferStmtNode(node *DeferStmtNode) *ast.DeferStmt
	UnmarshalReturnStmtNode(node *ReturnStmtNode) *ast.ReturnStmt
	UnmarshalBranchStmtNode(node *BranchStmtNode) *ast.BranchStmt
	UnmarshalBlockStmtNode(node *BlockStmtNode) *ast.BlockStmt
	UnmarshalIfStmtNode(node *IfStmtNode) *ast.IfStmt
	UnmarshalCaseClauseNode(node *CaseClauseNode) *ast.CaseClause
	UnmarshalSwitchStmtNode(node *SwitchStmtNode) *ast.SwitchStmt
	UnmarshalTypeSwitchStmtNode(node *TypeSwitchStmtNode) *ast.TypeSwitchStmt
	UnmarshalCommClauseNode(node *CommClauseNode) *ast.CommClause
	UnmarshalSelectStmtNode(node *SelectStmtNode) *ast.SelectStmt
	UnmarshalForStmtNode(node *ForStmtNode) *ast.ForStmt
	UnmarshalRangeStmtNode(node *RangeStmtNode) *ast.RangeStmt
}

type IdentNode 

type IdentNode struct {
	Node
	NamePos *PositionNode `json:"NamePos,omitempty"`
	Name    string        `json:"Name"`
}

func (IdentNode) GetRefId 

func (node IdentNode) GetRefId() int

func (*IdentNode) UnmarshalExpr 

func (node *IdentNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

type IfStmtNode 

type IfStmtNode struct {
	Node
	If   *PositionNode  `json:"If,omitempty"`
	Init IStmtNode      `json:"Init"`
	Cond IExprNode      `json:"Cond"`
	Body *BlockStmtNode `json:"Body"`
	Else IStmtNode      `json:"Else"`
}

func (IfStmtNode) GetRefId 

func (node IfStmtNode) GetRefId() int

func (*IfStmtNode) UnmarshalJSON 

func (node *IfStmtNode) UnmarshalJSON(data []byte) error

func (*IfStmtNode) UnmarshalStmt 

func (node *IfStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type IfStmtNodeAlias 

type IfStmtNodeAlias struct {
	Node
	If   *PositionNode
	Init json.RawMessage
	Cond json.RawMessage
	Body *BlockStmtNode
	Else json.RawMessage
}

type ImportSpecNode 

type ImportSpecNode struct {
	Node
	Doc     *CommentGroupNode `json:"Doc,omitempty"`
	Name    *IdentNode        `json:"Name"`
	Path    *BasicLitNode     `json:"Path"`
	Comment *CommentGroupNode `json:"Comment,omitempty"`
	EndPos  *PositionNode     `json:"EndPos,omitempty"`
}

func (ImportSpecNode) GetRefId 

func (node ImportSpecNode) GetRefId() int

func (*ImportSpecNode) UnmarshalSpec 

func (node *ImportSpecNode) UnmarshalSpec(um ISpecUnmarshaller) ast.Spec

type IncDecStmtNode 

type IncDecStmtNode struct {
	Node
	X      IExprNode     `json:"X"`
	TokPos *PositionNode `json:"TokPos,omitempty"`
	Tok    string        `json:"Tok"`
}

func (IncDecStmtNode) GetRefId 

func (node IncDecStmtNode) GetRefId() int

func (*IncDecStmtNode) UnmarshalJSON 

func (node *IncDecStmtNode) UnmarshalJSON(data []byte) error

func (*IncDecStmtNode) UnmarshalStmt 

func (node *IncDecStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type IncDecStmtNodeAlias 

type IncDecStmtNodeAlias struct {
	Node
	X      json.RawMessage
	TokPos *PositionNode
	Tok    string
}

type IndexExprNode 

type IndexExprNode struct {
	Node
	X      IExprNode     `json:"X"`
	Lbrack *PositionNode `json:"Lbrack,omitempty"`
	Index  IExprNode     `json:"Index"`
	Rbrack *PositionNode `json:"Rbrack,omitempty"`
}

func (IndexExprNode) GetRefId 

func (node IndexExprNode) GetRefId() int

func (*IndexExprNode) UnmarshalExpr 

func (node *IndexExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*IndexExprNode) UnmarshalJSON 

func (node *IndexExprNode) UnmarshalJSON(data []byte) error

type IndexExprNodeAlias 

type IndexExprNodeAlias struct {
	Node
	X      json.RawMessage
	Lbrack *PositionNode
	Index  json.RawMessage
	Rbrack *PositionNode
}

type IndexListExprNode 

type IndexListExprNode struct {
	Node
	X       IExprNode     `json:"X"`
	Lbrack  *PositionNode `json:"Lbrack,omitempty"`
	Indices []IExprNode   `json:"Indices"`
	Rbrack  *PositionNode `json:"Rbrack,omitempty"`
}

func (IndexListExprNode) GetRefId 

func (node IndexListExprNode) GetRefId() int

func (*IndexListExprNode) UnmarshalExpr 

func (node *IndexListExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*IndexListExprNode) UnmarshalJSON 

func (node *IndexListExprNode) UnmarshalJSON(data []byte) error

type IndexListExprNodeAlias 

type IndexListExprNodeAlias struct {
	Node
	X       json.RawMessage
	Lbrack  *PositionNode
	Indices []json.RawMessage
	Rbrack  *PositionNode
}

type InterfaceTypeNode 

type InterfaceTypeNode struct {
	Node
	Interface  *PositionNode  `json:"Interface,omitempty"`
	Methods    *FieldListNode `json:"Methods"`
	Incomplete bool           `json:"Incomplete"`
}

func (InterfaceTypeNode) GetRefId 

func (node InterfaceTypeNode) GetRefId() int

func (*InterfaceTypeNode) UnmarshalExpr 

func (node *InterfaceTypeNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

type KeyValueExprNode 

type KeyValueExprNode struct {
	Node
	Key   IExprNode     `json:"Key"`
	Colon *PositionNode `json:"Colon,omitempty"`
	Value IExprNode     `json:"Value"`
}

func (KeyValueExprNode) GetRefId 

func (node KeyValueExprNode) GetRefId() int

func (*KeyValueExprNode) UnmarshalExpr 

func (node *KeyValueExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*KeyValueExprNode) UnmarshalJSON 

func (node *KeyValueExprNode) UnmarshalJSON(data []byte) error

type KeyValueExprNodeAlias 

type KeyValueExprNodeAlias struct {
	Node
	Key   json.RawMessage
	Colon *PositionNode
	Value json.RawMessage
}

type LabeledStmtNode 

type LabeledStmtNode struct {
	Node
	Label *IdentNode    `json:"Label"`
	Colon *PositionNode `json:"Colon,omitempty"`
	Stmt  IStmtNode     `json:"Stmt"`
}

func (LabeledStmtNode) GetRefId 

func (node LabeledStmtNode) GetRefId() int

func (*LabeledStmtNode) UnmarshalJSON 

func (node *LabeledStmtNode) UnmarshalJSON(data []byte) error

func (*LabeledStmtNode) UnmarshalStmt 

func (node *LabeledStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type LabeledStmtNodeAlias 

type LabeledStmtNodeAlias struct {
	Node
	Label *IdentNode
	Colon *PositionNode
	Stmt  json.RawMessage
}

type MapTypeNode 

type MapTypeNode struct {
	Node
	Map   *PositionNode `json:"Map,omitempty"`
	Key   IExprNode     `json:"Key"`
	Value IExprNode     `json:"Value"`
}

func (MapTypeNode) GetRefId 

func (node MapTypeNode) GetRefId() int

func (*MapTypeNode) UnmarshalExpr 

func (node *MapTypeNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*MapTypeNode) UnmarshalJSON 

func (node *MapTypeNode) UnmarshalJSON(data []byte) error

type MapTypeNodeAlias 

type MapTypeNodeAlias struct {
	Node
	Map   *PositionNode
	Key   json.RawMessage
	Value json.RawMessage
}

type Marshaller 

type Marshaller struct {
	Options
	// contains filtered or unexported fields
}

func NewMarshaller 

func NewMarshaller(options Options) *Marshaller

func (*Marshaller) FileSet 

func (m *Marshaller) FileSet() *token.FileSet

func (*Marshaller) MarshalArrayType 

func (m *Marshaller) MarshalArrayType(node *ast.ArrayType) *ArrayTypeNode

func (*Marshaller) MarshalAssignStmt 

func (m *Marshaller) MarshalAssignStmt(stmt *ast.AssignStmt) *AssignStmtNode

func (*Marshaller) MarshalBadDecl 

func (m *Marshaller) MarshalBadDecl(decl *ast.BadDecl) *BadDeclNode

func (*Marshaller) MarshalBadExpr 

func (m *Marshaller) MarshalBadExpr(node *ast.BadExpr) *BadExprNode

func (*Marshaller) MarshalBadStmt 

func (m *Marshaller) MarshalBadStmt(stmt *ast.BadStmt) *BadStmtNode

func (*Marshaller) MarshalBasicLit 

func (m *Marshaller) MarshalBasicLit(node *ast.BasicLit) *BasicLitNode

func (*Marshaller) MarshalBinaryExpr 

func (m *Marshaller) MarshalBinaryExpr(node *ast.BinaryExpr) *BinaryExprNode

func (*Marshaller) MarshalBlockStmt 

func (m *Marshaller) MarshalBlockStmt(stmt *ast.BlockStmt) *BlockStmtNode

func (*Marshaller) MarshalBranchStmt 

func (m *Marshaller) MarshalBranchStmt(stmt *ast.BranchStmt) *BranchStmtNode

func (*Marshaller) MarshalCallExpr 

func (m *Marshaller) MarshalCallExpr(node *ast.CallExpr) *CallExprNode

func (*Marshaller) MarshalCaseClause 

func (m *Marshaller) MarshalCaseClause(stmt *ast.CaseClause) *CaseClauseNode

func (*Marshaller) MarshalChanType 

func (m *Marshaller) MarshalChanType(node *ast.ChanType) *ChanTypeNode

func (*Marshaller) MarshalCommClause 

func (m *Marshaller) MarshalCommClause(stmt *ast.CommClause) *CommClauseNode

func (*Marshaller) MarshalComment 

func (m *Marshaller) MarshalComment(comment *ast.Comment) *CommentNode

func (*Marshaller) MarshalCommentGroup 

func (m *Marshaller) MarshalCommentGroup(group *ast.CommentGroup) *CommentGroupNode

func (*Marshaller) MarshalCommentGroups 

func (m *Marshaller) MarshalCommentGroups(groups []*ast.CommentGroup) []*CommentGroupNode

func (*Marshaller) MarshalComments 

func (m *Marshaller) MarshalComments(comments []*ast.Comment) []*CommentNode

func (*Marshaller) MarshalCompositeLit 

func (m *Marshaller) MarshalCompositeLit(node *ast.CompositeLit) *CompositeLitNode

func (*Marshaller) MarshalDecl 

func (m *Marshaller) MarshalDecl(node ast.Decl) IDeclNode

func (*Marshaller) MarshalDeclStmt 

func (m *Marshaller) MarshalDeclStmt(stmt *ast.DeclStmt) *DeclStmtNode

func (*Marshaller) MarshalDecls 

func (m *Marshaller) MarshalDecls(decls []ast.Decl) []IDeclNode

func (*Marshaller) MarshalDeferStmt 

func (m *Marshaller) MarshalDeferStmt(stmt *ast.DeferStmt) *DeferStmtNode

func (*Marshaller) MarshalEllipsis 

func (m *Marshaller) MarshalEllipsis(node *ast.Ellipsis) *EllipsisNode

func (*Marshaller) MarshalEmptyStmt 

func (m *Marshaller) MarshalEmptyStmt(stmt *ast.EmptyStmt) *EmptyStmtNode

func (*Marshaller) MarshalExpr 

func (m *Marshaller) MarshalExpr(node ast.Expr) IExprNode

func (*Marshaller) MarshalExprStmt 

func (m *Marshaller) MarshalExprStmt(stmt *ast.ExprStmt) *ExprStmtNode

func (*Marshaller) MarshalExprs 

func (m *Marshaller) MarshalExprs(exprs []ast.Expr) []IExprNode

func (*Marshaller) MarshalField 

func (m *Marshaller) MarshalField(node *ast.Field) *FieldNode

func (*Marshaller) MarshalFieldList 

func (m *Marshaller) MarshalFieldList(node *ast.FieldList) *FieldListNode

func (*Marshaller) MarshalFields 

func (m *Marshaller) MarshalFields(fields []*ast.Field) []*FieldNode

func (*Marshaller) MarshalFile 

func (m *Marshaller) MarshalFile(node *ast.File) *FileNode

func (*Marshaller) MarshalForStmt 

func (m *Marshaller) MarshalForStmt(stmt *ast.ForStmt) *ForStmtNode

func (*Marshaller) MarshalFuncDecl 

func (m *Marshaller) MarshalFuncDecl(decl *ast.FuncDecl) *FuncDeclNode

func (*Marshaller) MarshalFuncLit 

func (m *Marshaller) MarshalFuncLit(node *ast.FuncLit) *FuncLitNode

func (*Marshaller) MarshalFuncType 

func (m *Marshaller) MarshalFuncType(node *ast.FuncType) *FuncTypeNode

func (*Marshaller) MarshalGenDecl 

func (m *Marshaller) MarshalGenDecl(decl *ast.GenDecl) *GenDeclNode

func (*Marshaller) MarshalGoStmt 

func (m *Marshaller) MarshalGoStmt(stmt *ast.GoStmt) *GoStmtNode

func (*Marshaller) MarshalIdent 

func (m *Marshaller) MarshalIdent(node *ast.Ident) *IdentNode

func (*Marshaller) MarshalIdents 

func (m *Marshaller) MarshalIdents(idents []*ast.Ident) []*IdentNode

func (*Marshaller) MarshalIfStmt 

func (m *Marshaller) MarshalIfStmt(stmt *ast.IfStmt) *IfStmtNode

func (*Marshaller) MarshalImportSpec 

func (m *Marshaller) MarshalImportSpec(spec *ast.ImportSpec) *ImportSpecNode

func (*Marshaller) MarshalImportSpecs added in v0.1.7 

func (m *Marshaller) MarshalImportSpecs(imports []*ast.ImportSpec) []*ImportSpecNode

func (*Marshaller) MarshalIncDecStmt 

func (m *Marshaller) MarshalIncDecStmt(stmt *ast.IncDecStmt) *IncDecStmtNode

func (*Marshaller) MarshalIndexExpr 

func (m *Marshaller) MarshalIndexExpr(node *ast.IndexExpr) *IndexExprNode

func (*Marshaller) MarshalIndexListExpr 

func (m *Marshaller) MarshalIndexListExpr(node *ast.IndexListExpr) *IndexListExprNode

func (*Marshaller) MarshalInterfaceType 

func (m *Marshaller) MarshalInterfaceType(node *ast.InterfaceType) *InterfaceTypeNode

func (*Marshaller) MarshalKeyValueExpr 

func (m *Marshaller) MarshalKeyValueExpr(node *ast.KeyValueExpr) *KeyValueExprNode

func (*Marshaller) MarshalLabeledStmt 

func (m *Marshaller) MarshalLabeledStmt(stmt *ast.LabeledStmt) *LabeledStmtNode

func (*Marshaller) MarshalMapType 

func (m *Marshaller) MarshalMapType(node *ast.MapType) *MapTypeNode

func (*Marshaller) MarshalNode 

func (m *Marshaller) MarshalNode(nodeType string, _ ast.Node) Node

func (*Marshaller) MarshalParenExpr 

func (m *Marshaller) MarshalParenExpr(node *ast.ParenExpr) *ParenExprNode

func (*Marshaller) MarshalPosition 

func (m *Marshaller) MarshalPosition(pos token.Pos) *PositionNode

func (*Marshaller) MarshalRangeStmt 

func (m *Marshaller) MarshalRangeStmt(stmt *ast.RangeStmt) *RangeStmtNode

func (*Marshaller) MarshalReturnStmt 

func (m *Marshaller) MarshalReturnStmt(stmt *ast.ReturnStmt) *ReturnStmtNode

func (*Marshaller) MarshalSelectStmt 

func (m *Marshaller) MarshalSelectStmt(stmt *ast.SelectStmt) *SelectStmtNode

func (*Marshaller) MarshalSelectorExpr 

func (m *Marshaller) MarshalSelectorExpr(node *ast.SelectorExpr) *SelectorExprNode

func (*Marshaller) MarshalSendStmt 

func (m *Marshaller) MarshalSendStmt(stmt *ast.SendStmt) *SendStmtNode

func (*Marshaller) MarshalSliceExpr 

func (m *Marshaller) MarshalSliceExpr(node *ast.SliceExpr) *SliceExprNode

func (*Marshaller) MarshalSpec 

func (m *Marshaller) MarshalSpec(node ast.Spec) ISpecNode

func (*Marshaller) MarshalSpecs 

func (m *Marshaller) MarshalSpecs(specs []ast.Spec) []ISpecNode

func (*Marshaller) MarshalStarExpr 

func (m *Marshaller) MarshalStarExpr(node *ast.StarExpr) *StarExprNode

func (*Marshaller) MarshalStmt 

func (m *Marshaller) MarshalStmt(node ast.Stmt) IStmtNode

func (*Marshaller) MarshalStmts 

func (m *Marshaller) MarshalStmts(stmts []ast.Stmt) []IStmtNode

func (*Marshaller) MarshalStructType 

func (m *Marshaller) MarshalStructType(node *ast.StructType) *StructTypeNode

func (*Marshaller) MarshalSwitchStmt 

func (m *Marshaller) MarshalSwitchStmt(stmt *ast.SwitchStmt) *SwitchStmtNode

func (*Marshaller) MarshalTypeAssertExpr 

func (m *Marshaller) MarshalTypeAssertExpr(node *ast.TypeAssertExpr) *TypeAssertExprNode

func (*Marshaller) MarshalTypeSpec 

func (m *Marshaller) MarshalTypeSpec(spec *ast.TypeSpec) *TypeSpecNode

func (*Marshaller) MarshalTypeSwitchStmt 

func (m *Marshaller) MarshalTypeSwitchStmt(stmt *ast.TypeSwitchStmt) *TypeSwitchStmtNode

func (*Marshaller) MarshalUnaryExpr 

func (m *Marshaller) MarshalUnaryExpr(node *ast.UnaryExpr) *UnaryExprNode

func (*Marshaller) MarshalValueSpec 

func (m *Marshaller) MarshalValueSpec(spec *ast.ValueSpec) *ValueSpecNode

type Node 

type Node struct {
	NodeType string `json:"NodeType"`
	RefId    int    `json:"RefId,omitempty"`
}

type Options added in v0.1.7 

type Options struct {
	WithPositions  bool
	WithComments   bool
	WithReferences bool
	WithImports    bool
}

type PackageNode 

type PackageNode struct {
	Node
	Name string
	//	Scope   *Scope
	//	Imports map[string]*Object
	Files map[string]*FileNode
}

func (PackageNode) GetRefId 

func (node PackageNode) GetRefId() int

type ParenExprNode 

type ParenExprNode struct {
	Node
	Lparen *PositionNode `json:"Lparen,omitempty"`
	X      IExprNode     `json:"X"`
	Rparen *PositionNode `json:"Rparen,omitempty"`
}

func (ParenExprNode) GetRefId 

func (node ParenExprNode) GetRefId() int

func (*ParenExprNode) UnmarshalExpr 

func (node *ParenExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*ParenExprNode) UnmarshalJSON 

func (node *ParenExprNode) UnmarshalJSON(data []byte) error

type ParenExprNodeAlias 

type ParenExprNodeAlias struct {
	Node
	Lparen *PositionNode
	X      json.RawMessage
	Rparen *PositionNode
}

type PositionNode 

type PositionNode struct {
	Node
	Filename string `json:"Filename"`
	Offset   int    `json:"Offset"`
	Line     int    `json:"Line"`
	Column   int    `json:"Column"`
}

type RangeStmtNode 

type RangeStmtNode struct {
	Node
	For    *PositionNode  `json:"For,omitempty"`
	Key    IExprNode      `json:"Key"`
	Value  IExprNode      `json:"Value"`
	TokPos *PositionNode  `json:"TokPos,omitempty"`
	Tok    string         `json:"Tok"`
	X      IExprNode      `json:"X"`
	Body   *BlockStmtNode `json:"Body"`
}

func (RangeStmtNode) GetRefId 

func (node RangeStmtNode) GetRefId() int

func (*RangeStmtNode) UnmarshalJSON 

func (node *RangeStmtNode) UnmarshalJSON(data []byte) error

func (*RangeStmtNode) UnmarshalStmt 

func (node *RangeStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type RangeStmtNodeAlias 

type RangeStmtNodeAlias struct {
	Node
	For    *PositionNode
	Key    json.RawMessage
	Value  json.RawMessage
	TokPos *PositionNode
	Tok    string
	X      json.RawMessage
	Body   *BlockStmtNode
}

type ReturnStmtNode 

type ReturnStmtNode struct {
	Node
	Return  *PositionNode `json:"Return,omitempty"`
	Results []IExprNode   `json:"Results"`
}

func (ReturnStmtNode) GetRefId 

func (node ReturnStmtNode) GetRefId() int

func (*ReturnStmtNode) UnmarshalJSON 

func (node *ReturnStmtNode) UnmarshalJSON(data []byte) error

func (*ReturnStmtNode) UnmarshalStmt 

func (node *ReturnStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type ReturnStmtNodeAlias 

type ReturnStmtNodeAlias struct {
	Node
	Return  *PositionNode
	Results []json.RawMessage
}

type SelectStmtNode 

type SelectStmtNode struct {
	Node
	Select *PositionNode  `json:"Select,omitempty"`
	Body   *BlockStmtNode `json:"Body"`
}

func (SelectStmtNode) GetRefId 

func (node SelectStmtNode) GetRefId() int

func (*SelectStmtNode) UnmarshalStmt 

func (node *SelectStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type SelectorExprNode 

type SelectorExprNode struct {
	Node
	X   IExprNode  `json:"X,omitempty"`
	Sel *IdentNode `json:"Sel,omitempty"`
}

func (SelectorExprNode) GetRefId 

func (node SelectorExprNode) GetRefId() int

func (*SelectorExprNode) UnmarshalExpr 

func (node *SelectorExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*SelectorExprNode) UnmarshalJSON 

func (node *SelectorExprNode) UnmarshalJSON(data []byte) error

type SelectorExprNodeAlias 

type SelectorExprNodeAlias struct {
	Node
	X   json.RawMessage
	Sel *IdentNode
}

type SendStmtNode 

type SendStmtNode struct {
	Node
	Chan  IExprNode     `json:"Chan"`
	Arrow *PositionNode `json:"Arrow,omitempty"`
	Value IExprNode     `json:"Value"`
}

func (SendStmtNode) GetRefId 

func (node SendStmtNode) GetRefId() int

func (*SendStmtNode) UnmarshalJSON 

func (node *SendStmtNode) UnmarshalJSON(data []byte) error

func (*SendStmtNode) UnmarshalStmt 

func (node *SendStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type SendStmtNodeAlias 

type SendStmtNodeAlias struct {
	Node
	Chan  json.RawMessage
	Arrow *PositionNode
	Value json.RawMessage
}

type SliceExprNode 

type SliceExprNode struct {
	Node
	X      IExprNode     `json:"X"`
	Lbrack *PositionNode `json:"Lbrack,omitempty"`
	Low    IExprNode     `json:"Low"`
	High   IExprNode     `json:"High"`
	Max    IExprNode     `json:"Max"`
	Slice3 bool          `json:"Slice3"`
	Rbrack *PositionNode `json:"Rbrack,omitempty"`
}

func (SliceExprNode) GetRefId 

func (node SliceExprNode) GetRefId() int

func (*SliceExprNode) UnmarshalExpr 

func (node *SliceExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*SliceExprNode) UnmarshalJSON 

func (node *SliceExprNode) UnmarshalJSON(data []byte) error

type SliceExprNodeAlias 

type SliceExprNodeAlias struct {
	Node
	X      json.RawMessage
	Lbrack *PositionNode
	Low    json.RawMessage
	High   json.RawMessage
	Max    json.RawMessage
	Slice3 bool
	Rbrack *PositionNode
}

type StarExprNode 

type StarExprNode struct {
	Node
	Star *PositionNode `json:"Star,omitempty"`
	X    IExprNode     `json:"X"`
}

func (StarExprNode) GetRefId 

func (node StarExprNode) GetRefId() int

func (*StarExprNode) UnmarshalExpr 

func (node *StarExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*StarExprNode) UnmarshalJSON 

func (node *StarExprNode) UnmarshalJSON(data []byte) error

type StarExprNodeAlias 

type StarExprNodeAlias struct {
	Node
	Star *PositionNode
	X    json.RawMessage
}

type StructTypeNode 

type StructTypeNode struct {
	Node
	Struct     *PositionNode  `json:"Struct,omitempty"`
	Fields     *FieldListNode `json:"Fields"`
	Incomplete bool           `json:"Incomplete"`
}

func (StructTypeNode) GetRefId 

func (node StructTypeNode) GetRefId() int

func (*StructTypeNode) UnmarshalExpr 

func (node *StructTypeNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

type SwitchStmtNode 

type SwitchStmtNode struct {
	Node
	Switch *PositionNode  `json:"Switch,omitempty"`
	Init   IStmtNode      `json:"Init"`
	Tag    IExprNode      `json:"Tag"`
	Body   *BlockStmtNode `json:"Body"`
}

func (SwitchStmtNode) GetRefId 

func (node SwitchStmtNode) GetRefId() int

func (*SwitchStmtNode) UnmarshalJSON 

func (node *SwitchStmtNode) UnmarshalJSON(data []byte) error

func (*SwitchStmtNode) UnmarshalStmt 

func (node *SwitchStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type SwitchStmtNodeAlias 

type SwitchStmtNodeAlias struct {
	Node
	Switch *PositionNode
	Init   json.RawMessage
	Tag    json.RawMessage
	Body   *BlockStmtNode
}

type TypeAssertExprNode 

type TypeAssertExprNode struct {
	Node
	X      IExprNode     `json:"X"`
	Lparen *PositionNode `json:"Lparen,omitempty"`
	Type   IExprNode     `json:"Type"`
	Rparen *PositionNode `json:"Rparen,omitempty"`
}

func (TypeAssertExprNode) GetRefId 

func (node TypeAssertExprNode) GetRefId() int

func (*TypeAssertExprNode) UnmarshalExpr 

func (node *TypeAssertExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*TypeAssertExprNode) UnmarshalJSON 

func (node *TypeAssertExprNode) UnmarshalJSON(data []byte) error

type TypeAssertExprNodeAlias 

type TypeAssertExprNodeAlias struct {
	Node
	X      json.RawMessage
	Lparen *PositionNode
	Type   json.RawMessage
	Rparen *PositionNode
}

type TypeSpecNode 

type TypeSpecNode struct {
	Node
	Doc        *CommentGroupNode `json:"Doc,omitempty"`
	Name       *IdentNode        `json:"Name"`
	TypeParams *FieldListNode    `json:"TypeParams"`
	Assign     *PositionNode     `json:"Assign,omitempty"`
	Type       IExprNode         `json:"Type"`
	Comment    *CommentGroupNode `json:"Comment,omitempty"`
}

func (TypeSpecNode) GetRefId 

func (node TypeSpecNode) GetRefId() int

func (*TypeSpecNode) UnmarshalJSON 

func (node *TypeSpecNode) UnmarshalJSON(data []byte) error

func (*TypeSpecNode) UnmarshalSpec 

func (node *TypeSpecNode) UnmarshalSpec(um ISpecUnmarshaller) ast.Spec

type TypeSpecNodeAlias 

type TypeSpecNodeAlias struct {
	Node
	Doc        *CommentGroupNode
	Name       *IdentNode
	TypeParams *FieldListNode
	Assign     *PositionNode
	Type       json.RawMessage
	Comment    *CommentGroupNode
}

type TypeSwitchStmtNode 

type TypeSwitchStmtNode struct {
	Node
	Switch *PositionNode  `json:"Switch,omitempty"`
	Init   IStmtNode      `json:"Init"`
	Assign IStmtNode      `json:"Assign"`
	Body   *BlockStmtNode `json:"Body"`
}

func (TypeSwitchStmtNode) GetRefId 

func (node TypeSwitchStmtNode) GetRefId() int

func (*TypeSwitchStmtNode) UnmarshalJSON 

func (node *TypeSwitchStmtNode) UnmarshalJSON(data []byte) error

func (*TypeSwitchStmtNode) UnmarshalStmt 

func (node *TypeSwitchStmtNode) UnmarshalStmt(um IStmtUnmarshaller) ast.Stmt

type TypeSwitchStmtNodeAlias 

type TypeSwitchStmtNodeAlias struct {
	Node
	Switch *PositionNode
	Init   json.RawMessage
	Assign json.RawMessage
	Body   *BlockStmtNode
}

type UnaryExprNode 

type UnaryExprNode struct {
	Node
	OpPos *PositionNode `json:"OpPos,omitempty"`
	Op    string        `json:"Op"`
	X     IExprNode     `json:"X"`
}

func (UnaryExprNode) GetRefId 

func (node UnaryExprNode) GetRefId() int

func (*UnaryExprNode) UnmarshalExpr 

func (node *UnaryExprNode) UnmarshalExpr(um IExprUnmarshaller) ast.Expr

func (*UnaryExprNode) UnmarshalJSON 

func (node *UnaryExprNode) UnmarshalJSON(data []byte) error

type UnaryExprNodeAlias 

type UnaryExprNodeAlias struct {
	Node
	OpPos *PositionNode
	Op    string
	X     json.RawMessage
}

type Unmarshaller 

type Unmarshaller struct {
	Options
	// contains filtered or unexported fields
}

func NewUnmarshaller 

func NewUnmarshaller(options Options) *Unmarshaller

func (*Unmarshaller) FileSet 

func (um *Unmarshaller) FileSet() *token.FileSet

func (*Unmarshaller) UnmarshalArrayTypeNode 

func (um *Unmarshaller) UnmarshalArrayTypeNode(node *ArrayTypeNode) *ast.ArrayType

func (*Unmarshaller) UnmarshalAssignStmtNode 

func (um *Unmarshaller) UnmarshalAssignStmtNode(node *AssignStmtNode) *ast.AssignStmt

func (*Unmarshaller) UnmarshalBadDeclNode 

func (um *Unmarshaller) UnmarshalBadDeclNode(node *BadDeclNode) *ast.BadDecl

func (*Unmarshaller) UnmarshalBadExprNode 

func (um *Unmarshaller) UnmarshalBadExprNode(node *BadExprNode) *ast.BadExpr

func (*Unmarshaller) UnmarshalBadStmtNode 

func (um *Unmarshaller) UnmarshalBadStmtNode(node *BadStmtNode) *ast.BadStmt

func (*Unmarshaller) UnmarshalBasicLitNode 

func (um *Unmarshaller) UnmarshalBasicLitNode(node *BasicLitNode) *ast.BasicLit

func (*Unmarshaller) UnmarshalBinaryExprNode 

func (um *Unmarshaller) UnmarshalBinaryExprNode(node *BinaryExprNode) *ast.BinaryExpr

func (*Unmarshaller) UnmarshalBlockStmtNode 

func (um *Unmarshaller) UnmarshalBlockStmtNode(node *BlockStmtNode) *ast.BlockStmt

func (*Unmarshaller) UnmarshalBranchStmtNode 

func (um *Unmarshaller) UnmarshalBranchStmtNode(node *BranchStmtNode) *ast.BranchStmt

func (*Unmarshaller) UnmarshalCallExprNode 

func (um *Unmarshaller) UnmarshalCallExprNode(node *CallExprNode) *ast.CallExpr

func (*Unmarshaller) UnmarshalCaseClauseNode 

func (um *Unmarshaller) UnmarshalCaseClauseNode(node *CaseClauseNode) *ast.CaseClause

func (*Unmarshaller) UnmarshalChanTypeNode 

func (um *Unmarshaller) UnmarshalChanTypeNode(node *ChanTypeNode) *ast.ChanType

func (*Unmarshaller) UnmarshalCommClauseNode 

func (um *Unmarshaller) UnmarshalCommClauseNode(node *CommClauseNode) *ast.CommClause

func (*Unmarshaller) UnmarshalCommentGroupNode 

func (um *Unmarshaller) UnmarshalCommentGroupNode(node *CommentGroupNode) *ast.CommentGroup

func (*Unmarshaller) UnmarshalCommentGroupNodes 

func (um *Unmarshaller) UnmarshalCommentGroupNodes(comments []*CommentGroupNode) []*ast.CommentGroup

func (*Unmarshaller) UnmarshalCommentNode 

func (um *Unmarshaller) UnmarshalCommentNode(node *CommentNode) *ast.Comment

func (*Unmarshaller) UnmarshalCommentNodes 

func (um *Unmarshaller) UnmarshalCommentNodes(nodes []*CommentNode) []*ast.Comment

func (*Unmarshaller) UnmarshalCompositeLitNode 

func (um *Unmarshaller) UnmarshalCompositeLitNode(node *CompositeLitNode) *ast.CompositeLit

func (*Unmarshaller) UnmarshalDecl 

func (um *Unmarshaller) UnmarshalDecl(decl IDeclNode) ast.Decl

func (*Unmarshaller) UnmarshalDeclNodes 

func (um *Unmarshaller) UnmarshalDeclNodes(nodes []IDeclNode) []ast.Decl

func (*Unmarshaller) UnmarshalDeclStmtNode 

func (um *Unmarshaller) UnmarshalDeclStmtNode(node *DeclStmtNode) *ast.DeclStmt

func (*Unmarshaller) UnmarshalDeferStmtNode 

func (um *Unmarshaller) UnmarshalDeferStmtNode(node *DeferStmtNode) *ast.DeferStmt

func (*Unmarshaller) UnmarshalEllipsisNode 

func (um *Unmarshaller) UnmarshalEllipsisNode(node *EllipsisNode) *ast.Ellipsis

func (*Unmarshaller) UnmarshalEmptyStmtNode 

func (um *Unmarshaller) UnmarshalEmptyStmtNode(node *EmptyStmtNode) *ast.EmptyStmt

func (*Unmarshaller) UnmarshalExpr 

func (um *Unmarshaller) UnmarshalExpr(expr IExprNode) ast.Expr

func (*Unmarshaller) UnmarshalExprNodes 

func (um *Unmarshaller) UnmarshalExprNodes(nodes []IExprNode) []ast.Expr

func (*Unmarshaller) UnmarshalExprStmtNode 

func (um *Unmarshaller) UnmarshalExprStmtNode(node *ExprStmtNode) *ast.ExprStmt

func (*Unmarshaller) UnmarshalFieldListNode 

func (um *Unmarshaller) UnmarshalFieldListNode(node *FieldListNode) *ast.FieldList

func (*Unmarshaller) UnmarshalFieldNode 

func (um *Unmarshaller) UnmarshalFieldNode(node *FieldNode) *ast.Field

func (*Unmarshaller) UnmarshalFieldNodes 

func (um *Unmarshaller) UnmarshalFieldNodes(nodes []*FieldNode) []*ast.Field

func (*Unmarshaller) UnmarshalFileNode 

func (um *Unmarshaller) UnmarshalFileNode(node *FileNode) *ast.File

func (*Unmarshaller) UnmarshalForStmtNode 

func (um *Unmarshaller) UnmarshalForStmtNode(node *ForStmtNode) *ast.ForStmt

func (*Unmarshaller) UnmarshalFuncDeclNode 

func (um *Unmarshaller) UnmarshalFuncDeclNode(node *FuncDeclNode) *ast.FuncDecl

func (*Unmarshaller) UnmarshalFuncLitNode 

func (um *Unmarshaller) UnmarshalFuncLitNode(node *FuncLitNode) *ast.FuncLit

func (*Unmarshaller) UnmarshalFuncTypeNode 

func (um *Unmarshaller) UnmarshalFuncTypeNode(node *FuncTypeNode) *ast.FuncType

func (*Unmarshaller) UnmarshalGenDeclNode 

func (um *Unmarshaller) UnmarshalGenDeclNode(node *GenDeclNode) *ast.GenDecl

func (*Unmarshaller) UnmarshalGoStmtNode 

func (um *Unmarshaller) UnmarshalGoStmtNode(node *GoStmtNode) *ast.GoStmt

func (*Unmarshaller) UnmarshalIdentNode 

func (um *Unmarshaller) UnmarshalIdentNode(node *IdentNode) *ast.Ident

func (*Unmarshaller) UnmarshalIdentNodes 

func (um *Unmarshaller) UnmarshalIdentNodes(nodes []*IdentNode) []*ast.Ident

func (*Unmarshaller) UnmarshalIfStmtNode 

func (um *Unmarshaller) UnmarshalIfStmtNode(node *IfStmtNode) *ast.IfStmt

func (*Unmarshaller) UnmarshalImportSpecNode 

func (um *Unmarshaller) UnmarshalImportSpecNode(node *ImportSpecNode) *ast.ImportSpec

func (*Unmarshaller) UnmarshalImportSpecNodes 

func (um *Unmarshaller) UnmarshalImportSpecNodes(imports []*ImportSpecNode) []*ast.ImportSpec

func (*Unmarshaller) UnmarshalIncDecStmtNode 

func (um *Unmarshaller) UnmarshalIncDecStmtNode(node *IncDecStmtNode) *ast.IncDecStmt

func (*Unmarshaller) UnmarshalIndexExprNode 

func (um *Unmarshaller) UnmarshalIndexExprNode(node *IndexExprNode) *ast.IndexExpr

func (*Unmarshaller) UnmarshalIndexListExprNode 

func (um *Unmarshaller) UnmarshalIndexListExprNode(node *IndexListExprNode) *ast.IndexListExpr

func (*Unmarshaller) UnmarshalInterfaceTypeNode 

func (um *Unmarshaller) UnmarshalInterfaceTypeNode(node *InterfaceTypeNode) *ast.InterfaceType

func (*Unmarshaller) UnmarshalKeyValueExprNode 

func (um *Unmarshaller) UnmarshalKeyValueExprNode(node *KeyValueExprNode) *ast.KeyValueExpr

func (*Unmarshaller) UnmarshalLabeledStmtNode 

func (um *Unmarshaller) UnmarshalLabeledStmtNode(node *LabeledStmtNode) *ast.LabeledStmt

func (*Unmarshaller) UnmarshalMapTypeNode 

func (um *Unmarshaller) UnmarshalMapTypeNode(node *MapTypeNode) *ast.MapType

func (*Unmarshaller) UnmarshalParenExprNode 

func (um *Unmarshaller) UnmarshalParenExprNode(node *ParenExprNode) *ast.ParenExpr

func (*Unmarshaller) UnmarshalPositionNode 

func (um *Unmarshaller) UnmarshalPositionNode(node *PositionNode) token.Pos

func (*Unmarshaller) UnmarshalRangeStmtNode 

func (um *Unmarshaller) UnmarshalRangeStmtNode(node *RangeStmtNode) *ast.RangeStmt

func (*Unmarshaller) UnmarshalReturnStmtNode 

func (um *Unmarshaller) UnmarshalReturnStmtNode(node *ReturnStmtNode) *ast.ReturnStmt

func (*Unmarshaller) UnmarshalSelectStmtNode 

func (um *Unmarshaller) UnmarshalSelectStmtNode(node *SelectStmtNode) *ast.SelectStmt

func (*Unmarshaller) UnmarshalSelectorExprNode 

func (um *Unmarshaller) UnmarshalSelectorExprNode(node *SelectorExprNode) *ast.SelectorExpr

func (*Unmarshaller) UnmarshalSendStmtNode 

func (um *Unmarshaller) UnmarshalSendStmtNode(node *SendStmtNode) *ast.SendStmt

func (*Unmarshaller) UnmarshalSliceExprNode 

func (um *Unmarshaller) UnmarshalSliceExprNode(node *SliceExprNode) *ast.SliceExpr

func (*Unmarshaller) UnmarshalSpec 

func (um *Unmarshaller) UnmarshalSpec(spec ISpecNode) ast.Spec

func (*Unmarshaller) UnmarshalSpecNodes 

func (um *Unmarshaller) UnmarshalSpecNodes(nodes []ISpecNode) []ast.Spec

func (*Unmarshaller) UnmarshalStarExprNode 

func (um *Unmarshaller) UnmarshalStarExprNode(node *StarExprNode) *ast.StarExpr

func (*Unmarshaller) UnmarshalStmt 

func (um *Unmarshaller) UnmarshalStmt(stmt IStmtNode) ast.Stmt

func (*Unmarshaller) UnmarshalStmtNodes 

func (um *Unmarshaller) UnmarshalStmtNodes(nodes []IStmtNode) []ast.Stmt

func (*Unmarshaller) UnmarshalStructTypeNode 

func (um *Unmarshaller) UnmarshalStructTypeNode(node *StructTypeNode) *ast.StructType

func (*Unmarshaller) UnmarshalSwitchStmtNode 

func (um *Unmarshaller) UnmarshalSwitchStmtNode(node *SwitchStmtNode) *ast.SwitchStmt

func (*Unmarshaller) UnmarshalTypeAssertExprNode 

func (um *Unmarshaller) UnmarshalTypeAssertExprNode(node *TypeAssertExprNode) *ast.TypeAssertExpr

func (*Unmarshaller) UnmarshalTypeSpecNode 

func (um *Unmarshaller) UnmarshalTypeSpecNode(node *TypeSpecNode) *ast.TypeSpec

func (*Unmarshaller) UnmarshalTypeSwitchStmtNode 

func (um *Unmarshaller) UnmarshalTypeSwitchStmtNode(node *TypeSwitchStmtNode) *ast.TypeSwitchStmt

func (*Unmarshaller) UnmarshalUnaryExprNode 

func (um *Unmarshaller) UnmarshalUnaryExprNode(node *UnaryExprNode) *ast.UnaryExpr

func (*Unmarshaller) UnmarshalValueSpecNode 

func (um *Unmarshaller) UnmarshalValueSpecNode(node *ValueSpecNode) *ast.ValueSpec

type ValueSpecNode 

type ValueSpecNode struct {
	Node
	Doc     *CommentGroupNode `json:"Doc,omitempty"`
	Names   []*IdentNode      `json:"Names"`
	Type    IExprNode         `json:"Type"`
	Values  []IExprNode       `json:"Values"`
	Comment *CommentGroupNode `json:"Comment,omitempty"`
}

func (ValueSpecNode) GetRefId 

func (node ValueSpecNode) GetRefId() int

func (*ValueSpecNode) UnmarshalJSON 

func (node *ValueSpecNode) UnmarshalJSON(data []byte) error

func (*ValueSpecNode) UnmarshalSpec 

func (node *ValueSpecNode) UnmarshalSpec(um ISpecUnmarshaller) ast.Spec

type ValueSpecNodeAlias 

type ValueSpecNodeAlias struct {
	Node
	Doc     *CommentGroupNode
	Names   []*IdentNode
	Type    json.RawMessage
	Values  []json.RawMessage
	Comment *CommentGroupNode
}

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.