--- /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