c9s Callbackgen Generate callback methods without pain 

Golang Taipei Gathering #2 2013 

No content

No content

CallbackGen 

CallbackGen = Callback Generator 

Reflection vs Static Code Generation 

Reflection handle dynamic type information in the runtime • dynamic type handling, especially interface types. • slower runtime, more CPU instructions. • more code for handling di ff erent types. • could cause runtime panic if types are not handled well. 

Code generation handle types in the compile time • static code analysis + code generation. • compilation could fail if types are not handled well. • no runtime handling, faster code. • work like generic. • code completion is possible. 

The Story started from… hand-written callbacks package main import ( "github.com/gorilla/websocket" ) type Client struct { connectCallbacks []func(c *websocket.Conn) disconnectCallbacks []func(c *websocket.Conn) } func (c *Client) OnConnect(cb func(c *websocket.Conn)) { c.connectCallbacks = append(c.connectCallbacks, cb) } func (c *Client) EmitConnect(conn *websocket.Conn) { for _, cb := range c.connectCallbacks { cb(conn) } } 

⼿寫⼀次 

⼿寫兩次 

⼿寫三次 

No content

⼿寫 N 次 

No content

No content

No content

package main import ( "github.com/gorilla/websocket" ) type Client struct { connectCallbacks []func(c *websocket.Conn) disconnectCallbacks []func(c *websocket.Conn) } func (c *Client) OnConnect(cb func(c *websocket.Conn)) { c.connectCallbacks = append(c.connectCallbacks, cb) } func (c *Client) EmitConnect(conn *websocket.Conn) { for _, cb := range c.connectCallbacks { cb(conn) } } func (c *Client) OnDisconnect(cb func(c *websocket.Conn)) { c.disconnectCallbacks = append(c.disconnectCallbacks, cb) } func (c *Client) EmitDisconnect(conn *websocket.Conn) { for _, cb := range c.disconnectCallbacks { cb(conn) } } 

package main import ( "github.com/gorilla/websocket" ) type Client struct { connectCallbacks []func(c *websocket.Conn) disconnectCallbacks []func(c *websocket.Conn) } func (c *Client) OnConnect(cb func(c *websocket.Conn)) { c.connectCallbacks = append(c.connectCallbacks, cb) } func (c *Client) EmitConnect(conn *websocket.Conn) { for _, cb := range c.connectCallbacks { cb(conn) } } func (c *Client) OnDisconnect(cb func(c *websocket.Conn)) { c.disconnectCallbacks = append(c.disconnectCallbacks, cb) } func (c *Client) EmitDisconnect(conn *websocket.Conn) { for _, cb := range c.disconnectCallbacks { cb(conn) } } package main import ( "github.com/gorilla/websocket" ) //go:generate callbackgen -type Client type Client struct { connectCallbacks []func(c *websocket.Conn) disconnectCallbacks []func(c *websocket.Conn) } 

No content

So, How Does It Work? 

Go 1.5 transit to Go compiler from C compiler 

go/types Go’s type checker 

Parsing go/{parser, ast, scanner, token} Type Checker go/types vet lint eg gorename stringer mockgen mockery 

a.go c.go b.go fmt Type Checker go/types compilation errors expressions type-checked packages imported packages 

Step 1 parse package fi les package main func parsePackage(patterns []string, tags []string) { cfg := &packages.Config{ Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedTypesInfo | packages.NeedFiles | packages.NeedSyntax | packages.NeedTypesInfo, Tests: false, BuildFlags: []string{fmt.Sprintf("-tags=%s", strings.Join(tags, " "))}, } pkgs, err := packages.Load(cfg, patterns...) if err != nil { log.Fatal(err) } } 

Step 2 traverse the syntax tree for _, pkg := range pkgs { for i, file := range pkg.Syntax { ast.Inspect(file.file, func(node ast.Node) bool { switch decl := node.(type) { case *ast.ImportSpec: case *ast.FuncDecl: // .... } return true } } } USVF

JUFSBUF
JOUP
UIF
OPEF
CMPDL
TUBUFNFOU
GVODUJPO
ʜ
FUD UIF
OPEF
UZQF
UIBU
ZPV
XBOU
UP
JOTQFDU 

type ( // An ImportSpec node represents a single package import. ImportSpec struct { Doc *CommentGroup // associated documentation; or nil Name *Ident // local package name (including "."); or nil Path *BasicLit // import path Comment *CommentGroup // line comments; or nil EndPos token.Pos // end of spec (overrides Path.Pos if nonzero) } // A ValueSpec node represents a constant or variable declaration // (ConstSpec or VarSpec production). // ValueSpec struct { Doc *CommentGroup // associated documentation; or nil Names []*Ident // value names (len(Names) > 0) Type Expr // value type; or nil Values []Expr // initial values; or nil Comment *CommentGroup // line comments; or nil } ) import ( "golang.org/x/tools/go/packages" ) a := 1 + 2 

Step 3 Resolve the AST node to Type Info switch decl := node.(type) { case *ast.FuncDecl: // get the first receiver node receiver := decl.Recv.List[0] // pass the receiver type token to the type info map receiverTypeAndValue, ok := pkg.TypesInfo.Types[receiver.Type] if !ok { return true } // inspect the REAL type switch v := recvTV.Type.(type) { case *types.Named: // type A int case *types.Pointer: // *int } } 5ZQF"OE7BMVF
DPOUBJOT
UIF
UZQF
JOGPSNBUJPO VTF
UIF
UZQF
JOGPSNBUJPO
UP
DIFDL 

Step 4 generate the code func renderCode() { var sliceCallbackTmpl = template.New("slice-callbacks").Funcs(funcMap) sliceCallbackTmpl = template.Must(sliceCallbackTmpl.Parse(` func ( {{- .RecvName }} *{{ .Field.StructName -}} ) On{{- .Field.EventName -}} (cb {{ .Field.CallbackTypeName .Qualifier -}} ) {{ .RecvName }}.{{ .Field.FieldName }} = append({{- .RecvName }}.{{ .Field.FieldName }}, cb) } func ( {{- .RecvName }} *{{ .Field.StructName -}} ) Emit{{- .Field.EventName -}} {{ .Field.CallbackParamsTuple | typeString }} for _, cb := range {{ .RecvName }}.{{ .Field.FieldName }} { cb({{ .Field.CallbackParamsVarNames | join ", " }}) } } `) sliceCallbackTmpl.Execute(&buf, TemplateArgs{ Field: field, RecvName: recvName, Qualifier: qf, GenerateRemoveMethod: *generateRemoveMethod, }) } 

Step 5 reformat the code import ( "go/format" ) src, err := format.Source(buf.Bytes()) if err != nil { // Should never happen, but can arise when developing this code. // The user can compile the output to see the error. log.Printf("warning: internal error: invalid Go generated: %s", err) log.Printf("warning: compile the package to analyze the error") return buf.Bytes() } return src 

Step 6 compile and test your code! 

Step 7 copy n paste my code, write your own codegen and have fun 

Your Filter Friends Filtering the AST nodes • FilterDecl(decl Decl, f Filter) bool • FilterFile(src *File, f Filter) bool • FilterPackage(pkg *Package, f Filter) bool • Inspect(node Node, f func(Node) bool) 

No content

Codegen For Fun 

https://github.com/MaiAmis/Careers