基础结构说明

• 普通Node,不是特定语法结构,属于某个语法结构的一部分.
  • Comment 表示一行注释 // 或者 / /
  • CommentGroup 表示多行注释
  • Field 表示结构体中的一个定义或者变量,或者函数签名当中的参数或者返回值
  • FieldList 表示以”{}”或者”()”包围的Filed列表
• Expression & Types (都划分成Expr接口)
  • BadExpr 用来表示错误表达式的占位符
  • Ident 比如报名,函数名,变量名
  • Ellipsis 省略号表达式,比如参数列表的最后一个可以写成arg…
  • BasicLit 基本字面值,数字或者字符串
  • FuncLit 函数定义
  • CompositeLit 构造类型,比如{1,2,3,4}
  • ParenExpr 括号表达式,被括号包裹的表达式
  • SelectorExpr 选择结构,类似于a.b的结构
  • IndexExpr 下标结构,类似这样的结构 expr[expr]
  • SliceExpr 切片表达式,类似这样 expr[low:mid:high]
  • TypeAssertExpr 类型断言类似于 X.(type)
  • CallExpr 调用类型,类似于 expr()
  • StarExpr 指针表达式,类似于 *X
  • UnaryExpr 一元表达式
  • BinaryExpr 二元表达式
  • KeyValueExp 键值表达式 key:value
  • ArrayType 数组类型
  • StructType 结构体类型
  • FuncType 函数类型
  • InterfaceType 接口类型
  • MapType map类型
  • ChanType 管道类型
• Statements语句
  • BadStmt 错误的语句
  • DeclStmt 在语句列表里的申明
  • EmptyStmt 空语句
  • LabeledStmt 标签语句类似于 indent:stmt
  • ExprStmt 包含单独的表达式语句
  • SendStmt chan发送语句
  • IncDecStmt 自增或者自减语句
  • AssignStmt 赋值语句
  • GoStmt Go语句
  • DeferStmt 延迟语句
  • ReturnStmt return 语句
  • BranchStmt 分支语句 例如break continue
  • BlockStmt 块语句 {} 包裹
  • IfStmt If 语句
  • CaseClause case 语句
  • SwitchStmt switch 语句
  • TypeSwitchStmt 类型switch 语句 switch x:=y.(type)
  • CommClause 发送或者接受的case语句,类似于 case x <-:
  • SelectStmt select 语句
  • ForStmt for 语句
  • RangeStmt range 语句
• Declarations声明
  • Spec type
  • Import Spec
  • Value Spec
  • Type Spec
  • BadDecl 错误申明
  • GenDecl 一般申明(和Spec相关,比如 import “a”,var a,type a)
• FuncDecl 函数申明
  • Files and Packages
  • File 代表一个源文件节点,包含了顶级元素.
  • Package 代表一个包,包含了很多文件.

以上内容转载自某片大神文章..具体地址忘了，知道的告知一下加上连接

定义函数

&ast.FuncDecl{
        Name: id("NewEndpoints"), //函数名称
        Body: //函数内语句包含在这里
        Type: &ast.FuncType{ //这里定义函数参数和返回结果
            Params: //函数参数
            Results: &ast.FieldList{
                List: []*ast.Field{
                    &ast.Field{
                        Type: &ast.StarExpr{ //返回指针类型
                            X: ast.NewIdent("Endpoints"),
                            //.e.g *Endpoints
                        },
                    },
                    &ast.Field{
                        Type: &ast.SelectorExpr{
                            X:   ast.NewIdent("a"),
                            Sel: ast.NewIdent("b"),
                        },
                        //返回包对象.e.g : a.b
                    },
                },
            },
        },
    }

例子：

   // i.method
   //=== Add
   //=== Update
   //=== UpdateName
   //=== UpdateParent
   //=== UpdateEnableState
   //=== QueryByCode
   //=== QueryByLikeName
   //=== QueryList
   //=== AllTree
   //=== AllChildrenCode
   elts := make([]ast.Expr, len(i.methods))
   for index, v := range i.methods {
       elts[index] = &ast.KeyValueExpr{
           Key: ast.NewIdent(v.name.Name),
           Value: &ast.CallExpr{
               Fun: ast.NewIdent("Make" + i.prefix + v.name.Name + "Endpoint"),
               Args: []ast.Expr{
                   &ast.BasicLit{
                       Kind:  token.TYPE,
                       Value: "s",
                   },
               },
           },
       }
   }
   return &ast.FuncDecl{
       Name: ast.NewIdent("New" + i.prefix + "Endpoints"),
       Body: &ast.BlockStmt{
           List: []ast.Stmt{
               &ast.AssignStmt{
                   Lhs: []ast.Expr{
                       ast.NewIdent("s"),
                   },
                   Tok: token.DEFINE,
                   Rhs: []ast.Expr{
                       &ast.CompositeLit{
                           Type: ast.NewIdent("service." + i.prefix + "Service"),
                       },
                   },
               },
               &ast.ReturnStmt{
                   Results: []ast.Expr{
                       &ast.UnaryExpr{
                           Op: token.AND,
                           X: &ast.CompositeLit{
                               Type: ast.NewIdent(i.prefix + "Endpoints"),
                               Elts: elts,
                           },
                       },
                   },
               },
           },
       },
       Type: &ast.FuncType{
           Results: &ast.FieldList{
               List: []*ast.Field{
                   {
                       Type: &ast.StarExpr{
                           X: ast.NewIdent(i.prefix + "Endpoints"),
                       },
                   },
               },
           },
       },
   }
结果：
   func NewDeptEndpoints() *DeptEndpoints {
   s := service.DeptService{}
   return &DeptEndpoints{
       Add:               MakeDeptAddEndpoint(s),
       Update:            MakeDeptUpdateEndpoint(s),
       UpdateName:        MakeDeptUpdateNameEndpoint(s),
       UpdateParent:      MakeDeptUpdateParentEndpoint(s),
       UpdateEnableState: MakeDeptUpdateEnableStateEndpoint(s),
       QueryByCode:       MakeDeptQueryByCodeEndpoint(s),
       QueryByLikeName:   MakeDeptQueryByLikeNameEndpoint(s),
       QueryList:         MakeDeptQueryListEndpoint(s),
       AllTree:           MakeDeptAllTreeEndpoint(s),
       AllChildrenCode:   MakeDeptAllChildrenCodeEndpoint(s)}
}

语句

dbCall := &ast.CallExpr{ //表达式语句
        Fun: &ast.Ident{
            Name: "db.TagConnect", //表达式内容
        },
        Args: []ast.Expr{ //表达式参数集合
            &ast.BasicLit{
                Kind:  token.TYPE,
                Value: "dbtag",
            },
        },
        //结果就是: db.TagConnect(dbtag)
    }
    db := ast.AssignStmt{ //赋值语句
        Lhs: []ast.Expr{
            &ast.Ident{ //变量名称
                Name: "q",
            },
        },
        Tok: token.DEFINE, //注意这个值一定要有这里表示":="
        Rhs: []ast.Expr{dbCall}, //后面的表达式
    }
    //整体执行结果: q := db.TagConnect(dbtag)

结构体注释

&ast.GenDecl{
    Doc://注释内容
    Tok:   token.TYPE,
    Specs: []ast.Spec{&ast.TypeSpec{
        Name: name,
        Type: &ast.StructType{
            Fields: fields,
        },
    }},
}

- 结果:
//注释内容
type name struct {
    fields...
}