+++ /dev/null
-package pattern
-
-import (
- "fmt"
- "go/ast"
- "go/token"
- "go/types"
- "reflect"
-)
-
-var astTypes = map[string]reflect.Type{
- "Ellipsis": reflect.TypeOf(ast.Ellipsis{}),
- "RangeStmt": reflect.TypeOf(ast.RangeStmt{}),
- "AssignStmt": reflect.TypeOf(ast.AssignStmt{}),
- "IndexExpr": reflect.TypeOf(ast.IndexExpr{}),
- "Ident": reflect.TypeOf(ast.Ident{}),
- "ValueSpec": reflect.TypeOf(ast.ValueSpec{}),
- "GenDecl": reflect.TypeOf(ast.GenDecl{}),
- "BinaryExpr": reflect.TypeOf(ast.BinaryExpr{}),
- "ForStmt": reflect.TypeOf(ast.ForStmt{}),
- "ArrayType": reflect.TypeOf(ast.ArrayType{}),
- "DeferStmt": reflect.TypeOf(ast.DeferStmt{}),
- "MapType": reflect.TypeOf(ast.MapType{}),
- "ReturnStmt": reflect.TypeOf(ast.ReturnStmt{}),
- "SliceExpr": reflect.TypeOf(ast.SliceExpr{}),
- "StarExpr": reflect.TypeOf(ast.StarExpr{}),
- "UnaryExpr": reflect.TypeOf(ast.UnaryExpr{}),
- "SendStmt": reflect.TypeOf(ast.SendStmt{}),
- "SelectStmt": reflect.TypeOf(ast.SelectStmt{}),
- "ImportSpec": reflect.TypeOf(ast.ImportSpec{}),
- "IfStmt": reflect.TypeOf(ast.IfStmt{}),
- "GoStmt": reflect.TypeOf(ast.GoStmt{}),
- "Field": reflect.TypeOf(ast.Field{}),
- "SelectorExpr": reflect.TypeOf(ast.SelectorExpr{}),
- "StructType": reflect.TypeOf(ast.StructType{}),
- "KeyValueExpr": reflect.TypeOf(ast.KeyValueExpr{}),
- "FuncType": reflect.TypeOf(ast.FuncType{}),
- "FuncLit": reflect.TypeOf(ast.FuncLit{}),
- "FuncDecl": reflect.TypeOf(ast.FuncDecl{}),
- "ChanType": reflect.TypeOf(ast.ChanType{}),
- "CallExpr": reflect.TypeOf(ast.CallExpr{}),
- "CaseClause": reflect.TypeOf(ast.CaseClause{}),
- "CommClause": reflect.TypeOf(ast.CommClause{}),
- "CompositeLit": reflect.TypeOf(ast.CompositeLit{}),
- "EmptyStmt": reflect.TypeOf(ast.EmptyStmt{}),
- "SwitchStmt": reflect.TypeOf(ast.SwitchStmt{}),
- "TypeSwitchStmt": reflect.TypeOf(ast.TypeSwitchStmt{}),
- "TypeAssertExpr": reflect.TypeOf(ast.TypeAssertExpr{}),
- "TypeSpec": reflect.TypeOf(ast.TypeSpec{}),
- "InterfaceType": reflect.TypeOf(ast.InterfaceType{}),
- "BranchStmt": reflect.TypeOf(ast.BranchStmt{}),
- "IncDecStmt": reflect.TypeOf(ast.IncDecStmt{}),
- "BasicLit": reflect.TypeOf(ast.BasicLit{}),
-}
-
-func ASTToNode(node interface{}) Node {
- switch node := node.(type) {
- case *ast.File:
- panic("cannot convert *ast.File to Node")
- case nil:
- return Nil{}
- case string:
- return String(node)
- case token.Token:
- return Token(node)
- case *ast.ExprStmt:
- return ASTToNode(node.X)
- case *ast.BlockStmt:
- if node == nil {
- return Nil{}
- }
- return ASTToNode(node.List)
- case *ast.FieldList:
- if node == nil {
- return Nil{}
- }
- return ASTToNode(node.List)
- case *ast.BasicLit:
- if node == nil {
- return Nil{}
- }
- case *ast.ParenExpr:
- return ASTToNode(node.X)
- }
-
- if node, ok := node.(ast.Node); ok {
- name := reflect.TypeOf(node).Elem().Name()
- T, ok := structNodes[name]
- if !ok {
- panic(fmt.Sprintf("internal error: unhandled type %T", node))
- }
-
- if reflect.ValueOf(node).IsNil() {
- return Nil{}
- }
- v := reflect.ValueOf(node).Elem()
- objs := make([]Node, T.NumField())
- for i := 0; i < T.NumField(); i++ {
- f := v.FieldByName(T.Field(i).Name)
- objs[i] = ASTToNode(f.Interface())
- }
-
- n, err := populateNode(name, objs, false)
- if err != nil {
- panic(fmt.Sprintf("internal error: %s", err))
- }
- return n
- }
-
- s := reflect.ValueOf(node)
- if s.Kind() == reflect.Slice {
- if s.Len() == 0 {
- return List{}
- }
- if s.Len() == 1 {
- return ASTToNode(s.Index(0).Interface())
- }
-
- tail := List{}
- for i := s.Len() - 1; i >= 0; i-- {
- head := ASTToNode(s.Index(i).Interface())
- l := List{
- Head: head,
- Tail: tail,
- }
- tail = l
- }
- return tail
- }
-
- panic(fmt.Sprintf("internal error: unhandled type %T", node))
-}
-
-func NodeToAST(node Node, state State) interface{} {
- switch node := node.(type) {
- case Binding:
- v, ok := state[node.Name]
- if !ok {
- // really we want to return an error here
- panic("XXX")
- }
- switch v := v.(type) {
- case types.Object:
- return &ast.Ident{Name: v.Name()}
- default:
- return v
- }
- case Builtin, Any, Object, Function, Not, Or:
- panic("XXX")
- case List:
- if (node == List{}) {
- return []ast.Node{}
- }
- x := []ast.Node{NodeToAST(node.Head, state).(ast.Node)}
- x = append(x, NodeToAST(node.Tail, state).([]ast.Node)...)
- return x
- case Token:
- return token.Token(node)
- case String:
- return string(node)
- case Nil:
- return nil
- }
-
- name := reflect.TypeOf(node).Name()
- T, ok := astTypes[name]
- if !ok {
- panic(fmt.Sprintf("internal error: unhandled type %T", node))
- }
- v := reflect.ValueOf(node)
- out := reflect.New(T)
- for i := 0; i < T.NumField(); i++ {
- fNode := v.FieldByName(T.Field(i).Name)
- if (fNode == reflect.Value{}) {
- continue
- }
- fAST := out.Elem().FieldByName(T.Field(i).Name)
- switch fAST.Type().Kind() {
- case reflect.Slice:
- c := reflect.ValueOf(NodeToAST(fNode.Interface().(Node), state))
- if c.Kind() != reflect.Slice {
- // it's a single node in the pattern, we have to wrap
- // it in a slice
- slice := reflect.MakeSlice(fAST.Type(), 1, 1)
- slice.Index(0).Set(c)
- c = slice
- }
- switch fAST.Interface().(type) {
- case []ast.Node:
- switch cc := c.Interface().(type) {
- case []ast.Node:
- fAST.Set(c)
- case []ast.Expr:
- var slice []ast.Node
- for _, el := range cc {
- slice = append(slice, el)
- }
- fAST.Set(reflect.ValueOf(slice))
- default:
- panic("XXX")
- }
- case []ast.Expr:
- switch cc := c.Interface().(type) {
- case []ast.Node:
- var slice []ast.Expr
- for _, el := range cc {
- slice = append(slice, el.(ast.Expr))
- }
- fAST.Set(reflect.ValueOf(slice))
- case []ast.Expr:
- fAST.Set(c)
- default:
- panic("XXX")
- }
- default:
- panic("XXX")
- }
- case reflect.Int:
- c := reflect.ValueOf(NodeToAST(fNode.Interface().(Node), state))
- switch c.Kind() {
- case reflect.String:
- tok, ok := tokensByString[c.Interface().(string)]
- if !ok {
- // really we want to return an error here
- panic("XXX")
- }
- fAST.SetInt(int64(tok))
- case reflect.Int:
- fAST.Set(c)
- default:
- panic(fmt.Sprintf("internal error: unexpected kind %s", c.Kind()))
- }
- default:
- r := NodeToAST(fNode.Interface().(Node), state)
- if r != nil {
- fAST.Set(reflect.ValueOf(r))
- }
- }
- }
-
- return out.Interface().(ast.Node)
-}
projects / dotfiles / .git / blobdiff