Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

ason

package module

Go to main page

Versions in this module

v1

v1.0.0

Mar 30, 2024

Changes in this version

+ const NodeTypeArrayType

+ const NodeTypeAssignStmt

+ const NodeTypeBadDecl

+ const NodeTypeBadExpr

+ const NodeTypeBadStmt

+ const NodeTypeBasicLit

+ const NodeTypeBinaryExpr

+ const NodeTypeBlockStmt

+ const NodeTypeBranchStmt

+ const NodeTypeCallExpr

+ const NodeTypeCaseClause

+ const NodeTypeChanType

+ const NodeTypeCommClause

+ const NodeTypeComment

+ const NodeTypeCommentGroup

+ const NodeTypeCompositeLit

+ const NodeTypeDeclStmt

+ const NodeTypeDeferStmt

+ const NodeTypeEllipsis

+ const NodeTypeEmptyStmt

+ const NodeTypeExprStmt

+ const NodeTypeField

+ const NodeTypeFieldList

+ const NodeTypeFile

+ const NodeTypeForStmt

+ const NodeTypeFuncDecl

+ const NodeTypeFuncLit

+ const NodeTypeFuncType

+ const NodeTypeGenDecl

+ const NodeTypeGoStmt

+ const NodeTypeIdent

+ const NodeTypeIfStmt

+ const NodeTypeImportSpec

+ const NodeTypeIncDecStmt

+ const NodeTypeIndexExpr

+ const NodeTypeIndexListExpr

+ const NodeTypeInterfaceType

+ const NodeTypeInvalid

+ const NodeTypeKeyValueExpr

+ const NodeTypeLabeledStmt

+ const NodeTypeMapType

+ const NodeTypeParenExpr

+ const NodeTypeRangeStmt

+ const NodeTypeReturnStmt

+ const NodeTypeSelectStmt

+ const NodeTypeSelectorExpr

+ const NodeTypeSendStmt

+ const NodeTypeSliceExpr

+ const NodeTypeStarExpr

+ const NodeTypeStructType

+ const NodeTypeSwitchStmt

+ const NodeTypeTypeAssertExpr

+ const NodeTypeTypeSpec

+ const NodeTypeTypeSwitchStmt

+ const NodeTypeUnaryExpr

+ const NodeTypeValueSpec

+ func DeRefLookup[I Ason, O ast.Node](pass *dePass, input I, deFn DeFn[I, O]) O

+ func DeserializeArrayType(pass *dePass, input *ArrayType) *ast.ArrayType

+ func DeserializeAssignStmt(pass *dePass, input *AssignStmt) *ast.AssignStmt

+ func DeserializeBadDecl(pass *dePass, input *BadDecl) *ast.BadDecl

+ func DeserializeBadExpr(pass *dePass, input *BadExpr) *ast.BadExpr

+ func DeserializeBadStmt(pass *dePass, input *BadStmt) *ast.BadStmt

+ func DeserializeBasicLit(pass *dePass, input *BasicLit) *ast.BasicLit

+ func DeserializeBinaryExpr(pass *dePass, input *BinaryExpr) *ast.BinaryExpr

+ func DeserializeBlockStmt(pass *dePass, input *BlockStmt) *ast.BlockStmt

+ func DeserializeBranchStmt(pass *dePass, input *BranchStmt) *ast.BranchStmt

+ func DeserializeCallExpr(pass *dePass, input *CallExpr) *ast.CallExpr

+ func DeserializeCaseClause(pass *dePass, input *CaseClause) *ast.CaseClause

+ func DeserializeChanType(pass *dePass, input *ChanType) *ast.ChanType

+ func DeserializeCommClause(pass *dePass, input *CommClause) *ast.CommClause

+ func DeserializeComment(pass *dePass, input *Comment) *ast.Comment

+ func DeserializeCommentGroup(pass *dePass, input *CommentGroup) *ast.CommentGroup

+ func DeserializeCompositeLit(pass *dePass, input *CompositeLit) *ast.CompositeLit

+ func DeserializeDecl(pass *dePass, decl Decl) ast.Decl

+ func DeserializeDeclStmt(pass *dePass, input *DeclStmt) *ast.DeclStmt

+ func DeserializeDeferStmt(pass *dePass, input *DeferStmt) *ast.DeferStmt

+ func DeserializeEllipsis(pass *dePass, input *Ellipsis) *ast.Ellipsis

+ func DeserializeEmptyStmt(pass *dePass, input *EmptyStmt) *ast.EmptyStmt

+ func DeserializeExpr(pass *dePass, expr Expr) ast.Expr

+ func DeserializeExprStmt(pass *dePass, input *ExprStmt) *ast.ExprStmt

+ func DeserializeField(pass *dePass, input *Field) *ast.Field

+ func DeserializeFieldList(pass *dePass, input *FieldList) *ast.FieldList

+ func DeserializeFile(pass *dePass, input *File) (*ast.File, error)

+ func DeserializeForStmt(pass *dePass, input *ForStmt) *ast.ForStmt

+ func DeserializeFuncDecl(pass *dePass, input *FuncDecl) *ast.FuncDecl

+ func DeserializeFuncLit(pass *dePass, input *FuncLit) *ast.FuncLit

+ func DeserializeFuncType(pass *dePass, input *FuncType) *ast.FuncType

+ func DeserializeGenDecl(pass *dePass, input *GenDecl) *ast.GenDecl

+ func DeserializeGoStmt(pass *dePass, input *GoStmt) *ast.GoStmt

+ func DeserializeIdent(pass *dePass, input *Ident) *ast.Ident

+ func DeserializeIfStmt(pass *dePass, input *IfStmt) *ast.IfStmt

+ func DeserializeImportSpec(pass *dePass, input *ImportSpec) *ast.ImportSpec

+ func DeserializeIncDecStmt(pass *dePass, input *IncDecStmt) *ast.IncDecStmt

+ func DeserializeIndexExpr(pass *dePass, input *IndexExpr) *ast.IndexExpr

+ func DeserializeIndexListExpr(pass *dePass, input *IndexListExpr) *ast.IndexListExpr

+ func DeserializeInterfaceType(pass *dePass, input *InterfaceType) *ast.InterfaceType

+ func DeserializeKeyValueExpr(pass *dePass, input *KeyValueExpr) *ast.KeyValueExpr

+ func DeserializeLabeledStmt(pass *dePass, input *LabeledStmt) *ast.LabeledStmt

+ func DeserializeList[I Ason, R ast.Node](pass *dePass, inputList []I, deFn DeFn[I, R]) (result []R)

+ func DeserializeMapType(pass *dePass, input *MapType) *ast.MapType

+ func DeserializeOption[I Ason, R ast.Node](pass *dePass, input I, deFn DeFn[I, R]) (empty R)

+ func DeserializeParenExpr(pass *dePass, input *ParenExpr) *ast.ParenExpr

+ func DeserializePos(pass *dePass, input Pos) token.Pos

+ func DeserializeRangeStmt(pass *dePass, input *RangeStmt) *ast.RangeStmt

+ func DeserializeReturnStmt(pass *dePass, input *ReturnStmt) *ast.ReturnStmt

+ func DeserializeSelectStmt(pass *dePass, input *SelectStmt) *ast.SelectStmt

+ func DeserializeSelectorExpr(pass *dePass, input *SelectorExpr) *ast.SelectorExpr

+ func DeserializeSendStmt(pass *dePass, input *SendStmt) *ast.SendStmt

+ func DeserializeSliceExpr(pass *dePass, input *SliceExpr) *ast.SliceExpr

+ func DeserializeSpec(pass *dePass, spec Spec) ast.Spec

+ func DeserializeStarExpr(pass *dePass, input *StarExpr) *ast.StarExpr

+ func DeserializeStmt(pass *dePass, stmt Stmt) ast.Stmt

+ func DeserializeStructType(pass *dePass, input *StructType) *ast.StructType

+ func DeserializeSwitchStmt(pass *dePass, input *SwitchStmt) *ast.SwitchStmt

+ func DeserializeTypeAssertExpr(pass *dePass, input *TypeAssertExpr) *ast.TypeAssertExpr

+ func DeserializeTypeSpec(pass *dePass, input *TypeSpec) *ast.TypeSpec

+ func DeserializeTypeSwitchStmt(pass *dePass, input *TypeSwitchStmt) *ast.TypeSwitchStmt

+ func DeserializeUnaryExpr(pass *dePass, input *UnaryExpr) *ast.UnaryExpr

+ func DeserializeValueSpec(pass *dePass, input *ValueSpec) *ast.ValueSpec

+ func IsPosValid(pos Pos) bool

+ func NewDePass(fset *token.FileSet) *dePass

+ func NewSerPass(fset *token.FileSet, options ...Mode) *serPass

+ func NewWeakRef(v interface{}) *weakRef

+ func SerRefLookup[I ast.Node, O Ason](pass *serPass, input I, serFn SerFn[I, O]) O

+ func SerializeList[I ast.Node, R Ason](pass *serPass, inputList []I, serFn SerFn[I, R]) (result []R)

+ func SerializeMap[K comparable, V ast.Node, R Ason](pass *serPass, inputMap map[K]V, serFn SerFn[V, R]) map[K]R

+ func SerializeOption[I ast.Node, R Ason](pass *serPass, input I, serFn SerFn[I, R]) (empty R)

+ type ArrayType struct

+ Elt Expr

+ Lbrack Pos

+ Len Expr

+ func SerializeArrayType(pass *serPass, input *ast.ArrayType) *ArrayType

+ type Ason interface

+ type AssignStmt struct

+ Lhs []Expr

+ Rhs []Expr

+ Tok string

+ TokPos Pos

+ func SerializeAssignStmt(pass *serPass, input *ast.AssignStmt) *AssignStmt

+ type BadDecl struct

+ From Pos

+ To Pos

+ func SerializeBadDecl(pass *serPass, input *ast.BadDecl) *BadDecl

+ type BadExpr struct

+ From Pos

+ To Pos

+ func SerializeBadExpr(pass *serPass, input *ast.BadExpr) *BadExpr

+ type BadStmt struct

+ From Pos

+ To Pos

+ func SerializeBadStmt(pass *serPass, input *ast.BadStmt) *BadStmt

+ type BasicLit struct

+ Kind string

+ Value string

+ ValuePos Pos

+ func SerializeBasicLit(pass *serPass, input *ast.BasicLit) *BasicLit

+ type BinaryExpr struct

+ Op string

+ OpPos Pos

+ X Expr

+ Y Expr

+ func SerializeBinaryExpr(pass *serPass, input *ast.BinaryExpr) *BinaryExpr

+ type BlockStmt struct

+ Lbrace Pos

+ List []Stmt

+ Rbrace Pos

+ func SerializeBlockStmt(pass *serPass, input *ast.BlockStmt) *BlockStmt

+ type BranchStmt struct

+ Label *Ident

+ Tok string

+ TokPos Pos

+ func SerializeBranchStmt(pass *serPass, input *ast.BranchStmt) *BranchStmt

+ type CallExpr struct

+ Args []Expr

+ Ellipsis Pos

+ Fun Expr

+ Lparen Pos

+ Rparen Pos

+ func SerializeCallExpr(pass *serPass, input *ast.CallExpr) *CallExpr

+ type CaseClause struct

+ Body []Stmt

+ Case Pos

+ Colon Pos

+ List []Expr

+ func SerializeCaseClause(pass *serPass, input *ast.CaseClause) *CaseClause

+ type ChanType struct

+ Arrow Pos

+ Begin Pos

+ Dir int

+ Value Expr

+ func SerializeChanType(pass *serPass, input *ast.ChanType) *ChanType

+ type CommClause struct

+ Body []Stmt

+ Case Pos

+ Colon Pos

+ Comm Stmt

+ func SerializeCommClause(pass *serPass, input *ast.CommClause) *CommClause

+ type Comment struct

+ Slash Pos

+ Text string

+ func SerializeComment(pass *serPass, input *ast.Comment) *Comment

+ type CommentGroup struct

+ List []*Comment

+ func SerializeCommentGroup(pass *serPass, input *ast.CommentGroup) *CommentGroup

+ type CompositeLit struct

+ Elts []Expr

+ Incomplete bool

+ Lbrace Pos

+ Rbrace Pos

+ Type Expr

+ func SerializeCompositeLit(pass *serPass, input *ast.CompositeLit) *CompositeLit

+ type DeFn func(*dePass, I) O

+ type Decl interface

+ func SerializeDecl(pass *serPass, decl ast.Decl) Decl

+ type DeclStmt struct

+ Decl Decl

+ func SerializeDeclStmt(pass *serPass, input *ast.DeclStmt) *DeclStmt

+ type DeferStmt struct

+ Call *CallExpr

+ Defer Pos

+ func SerializeDeferStmt(pass *serPass, input *ast.DeferStmt) *DeferStmt

+ type Ellipsis struct

+ Ellipsis Pos

+ Elt Expr

+ func SerializeEllipsis(pass *serPass, input *ast.Ellipsis) *Ellipsis

+ type EmptyStmt struct

+ Implicit bool

+ Semicolon Pos

+ func SerializeEmptyStmt(pass *serPass, input *ast.EmptyStmt) *EmptyStmt

+ type Expr interface

+ func SerializeExpr(pass *serPass, expr ast.Expr) Expr

+ type ExprStmt struct

+ X Expr

+ func SerializeExprStmt(pass *serPass, input *ast.ExprStmt) *ExprStmt

+ type Field struct

+ Comment *CommentGroup

+ Doc *CommentGroup

+ Names []*Ident

+ Tag *BasicLit

+ Type Expr

+ func SerializeField(pass *serPass, input *ast.Field) *Field

+ type FieldList struct

+ Closing Pos

+ List []*Field

+ Opening Pos

+ func SerializeFieldList(pass *serPass, input *ast.FieldList) *FieldList

+ type File struct

+ Comments []*CommentGroup

+ Decls []Decl

+ Doc *CommentGroup

+ FileEnd Pos

+ FileStart Pos

+ GoVersion string

+ Imports []*ImportSpec

+ Name *Ident

+ Package Pos

+ Scope *Scope

+ Size int

+ Unresolved []*Ident

+ func SerializeFile(pass *serPass, input *ast.File) *File

+ type ForStmt struct

+ Body *BlockStmt

+ Cond Expr

+ For Pos

+ Init Stmt

+ Post Stmt

+ func SerializeForStmt(pass *serPass, input *ast.ForStmt) *ForStmt

+ type FuncDecl struct

+ Body *BlockStmt

+ Doc *CommentGroup

+ Name *Ident

+ Recv *FieldList

+ Type *FuncType

+ func SerializeFuncDecl(pass *serPass, input *ast.FuncDecl) *FuncDecl

+ type FuncLit struct

+ Body *BlockStmt

+ Type *FuncType

+ func SerializeFuncLit(pass *serPass, input *ast.FuncLit) *FuncLit

+ type FuncType struct

+ Func Pos

+ Params *FieldList

+ Results *FieldList

+ TypeParams *FieldList

+ func SerializeFuncType(pass *serPass, input *ast.FuncType) *FuncType

+ type GenDecl struct

+ Doc *CommentGroup

+ Lparen Pos

+ Rparen Pos

+ Specs []Spec

+ Tok string

+ TokenPos Pos

+ func SerializeGenDecl(pass *serPass, input *ast.GenDecl) *GenDecl

+ type GoStmt struct

+ Call *CallExpr

+ Go Pos

+ func SerializeGoStmt(pass *serPass, input *ast.GoStmt) *GoStmt

+ type Ident struct

+ Name string

+ NamePos Pos

+ Obj *Object

+ func SerializeIdent(pass *serPass, input *ast.Ident) *Ident

+ type IfStmt struct

+ Body *BlockStmt

+ Cond Expr

+ Else Stmt

+ If Pos

+ Init Stmt

+ func SerializeIfStmt(pass *serPass, input *ast.IfStmt) *IfStmt

+ type ImportSpec struct

+ Comment *CommentGroup

+ Doc *CommentGroup

+ EndPos Pos

+ Name *Ident

+ Path *BasicLit

+ func SerializeImportSpec(pass *serPass, input *ast.ImportSpec) *ImportSpec

+ type IncDecStmt struct

+ Tok string

+ TokPos Pos

+ X Expr

+ func SerializeIncDecStmt(pass *serPass, input *ast.IncDecStmt) *IncDecStmt

+ type IndexExpr struct

+ Index Expr

+ Lbrack Pos

+ Rbrack Pos

+ X Expr

+ func SerializeIndexExpr(pass *serPass, input *ast.IndexExpr) *IndexExpr

+ type IndexListExpr struct

+ Indices []Expr

+ Lbrack Pos

+ Rbrack Pos

+ X Expr

+ func SerializeIndexListExpr(pass *serPass, input *ast.IndexListExpr) *IndexListExpr

+ type InterfaceType struct

+ Incomplete bool

+ Interface Pos

+ Methods *FieldList

+ func SerializeInterfaceType(pass *serPass, input *ast.InterfaceType) *InterfaceType

+ type KeyValueExpr struct

+ Colon Pos

+ Key Expr

+ Value Expr

+ func SerializeKeyValueExpr(pass *serPass, input *ast.KeyValueExpr) *KeyValueExpr

+ type LabeledStmt struct

+ Colon Pos

+ Label *Ident

+ Stmt Stmt

+ func SerializeLabeledStmt(pass *serPass, input *ast.LabeledStmt) *LabeledStmt

+ type Loc struct

+ End Pos

+ Start Pos

+ func SerializeLoc(pass *serPass, input ast.Node) *Loc

+ type MapType struct

+ Key Expr

+ Map Pos

+ Value Expr

+ func SerializeMapType(pass *serPass, input *ast.MapType) *MapType

+ type Mode int

+ const CacheRef

+ const Default

+ const ResolveLoc

+ const ResolveObject

+ const ResolveScope

+ const SkipComments

+ type NoPos int

+ func (*NoPos) Column() int

+ func (*NoPos) Line() int

+ func (*NoPos) Offset() int

+ type Node struct

+ Loc *Loc

+ Ref uint

+ Type string

+ type Object struct

+ Kind string

+ Name string

+ func SerializeObject(pass *serPass, input *ast.Object) *Object

+ type Package struct

+ Files map[string]*File

+ Imports map[string]*Object

+ Name string

+ Scope *Scope

+ func SerializePackage(pass *serPass, input *ast.Package) *Package

+ type ParenExpr struct

+ Lparen Pos

+ Rparen Pos

+ X Expr

+ func SerializeParenExpr(pass *serPass, input *ast.ParenExpr) *ParenExpr

+ type Pos interface

+ Column func() int

+ Line func() int

+ Offset func() int

+ func SerializePos(pass *serPass, pos token.Pos) Pos

+ type Position struct

+ Filename string

+ Location [3]int

+ func NewPosition(pos token.Position) *Position

+ func (p *Position) Column() int

+ func (p *Position) Line() int

+ func (p *Position) Offset() int

+ type RangeStmt struct

+ Body *BlockStmt

+ For Pos

+ Key Expr

+ Range Pos

+ Tok string

+ TokPos Pos

+ Value Expr

+ X Expr

+ func SerializeRangeStmt(pass *serPass, input *ast.RangeStmt) *RangeStmt

+ type ReturnStmt struct

+ Results []Expr

+ Return Pos

+ func SerializeReturnStmt(pass *serPass, input *ast.ReturnStmt) *ReturnStmt

+ type Scope struct

+ Objects map[string]*Object

+ Outer *Scope

+ func SerializeScope(pass *serPass, input *ast.Scope) *Scope

+ type SelectStmt struct

+ Body *BlockStmt

+ Select Pos

+ func SerializeSelectStmt(pass *serPass, input *ast.SelectStmt) *SelectStmt

+ type SelectorExpr struct

+ Sel *Ident

+ X Expr

+ func SerializeSelectorExpr(pass *serPass, input *ast.SelectorExpr) *SelectorExpr

+ type SendStmt struct

+ Arrow Pos

+ Chan Expr

+ Value Expr

+ func SerializeSendStmt(pass *serPass, input *ast.SendStmt) *SendStmt

+ type SerFn func(*serPass, I) O

+ type SliceExpr struct

+ High Expr

+ Lbrack Pos

+ Low Expr

+ Max Expr

+ Rbrack Pos

+ Slice3 bool

+ X Expr

+ func SerializeSliceExpr(pass *serPass, input *ast.SliceExpr) *SliceExpr

+ type Spec interface

+ func SerializeSpec(pass *serPass, spec ast.Spec) Spec

+ type StarExpr struct

+ Star Pos

+ X Expr

+ func SerializeStarExpr(pass *serPass, input *ast.StarExpr) *StarExpr

+ type Stmt interface

+ func SerializeStmt(pass *serPass, stmt ast.Stmt) Stmt

+ type StructType struct

+ Fields *FieldList

+ Incomplete bool

+ Struct Pos

+ func SerializeStructType(pass *serPass, input *ast.StructType) *StructType

+ type SwitchStmt struct

+ Body *BlockStmt

+ Init Stmt

+ Switch Pos

+ Tag Expr

+ func SerializeSwitchStmt(pass *serPass, input *ast.SwitchStmt) *SwitchStmt

+ type TypeAssertExpr struct

+ Lparen Pos

+ Rparen Pos

+ Type Expr

+ X Expr

+ func SerializeTypeAssertExpr(pass *serPass, input *ast.TypeAssertExpr) *TypeAssertExpr

+ type TypeSpec struct

+ Assign Pos

+ Comment *CommentGroup

+ Doc *CommentGroup

+ Name *Ident

+ Type Expr

+ TypeParams *FieldList

+ func SerializeTypeSpec(pass *serPass, input *ast.TypeSpec) *TypeSpec

+ type TypeSwitchStmt struct

+ Assign Stmt

+ Body *BlockStmt

+ Init Stmt

+ Switch Pos

+ func SerializeTypeSwitchStmt(pass *serPass, input *ast.TypeSwitchStmt) *TypeSwitchStmt

+ type UnaryExpr struct

+ Op string

+ OpPos Pos

+ X Expr

+ func SerializeUnaryExpr(pass *serPass, input *ast.UnaryExpr) *UnaryExpr

+ type ValueSpec struct

+ Comment *CommentGroup

+ Doc *CommentGroup

+ Names []*Ident

+ Type Expr

+ Values []Expr

+ func SerializeValueSpec(pass *serPass, input *ast.ValueSpec) *ValueSpec

v0

v0.0.1

Feb 22, 2024