mirror of
https://github.com/woodpecker-ci/woodpecker.git
synced 2024-12-13 03:56:39 +00:00
c28f7cb29f
Initial part of #435
242 lines
6.3 KiB
Go
242 lines
6.3 KiB
Go
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)
|
|
}
|