func (p *parser) parseTypeName(n *parse.Node) ast.Expr {
n = n.Child(0)
if n.Rule() == identifier {
return p.parseIdent(n)
}
return p.parseQualifiedIdent(n)
}
func (p *parser) parseStructType(n *parse.Node) ast.Expr {
struct_ := n.Child(0)
return &ast.StructType{
Struct: token.Pos(struct_.Pos()),
// TODO: Fields
}
}
func (p *parser) parsePackageClause(n *parse.Node) (token.Pos, *ast.Ident) {
pac, name := n.Child(0), n.Child(1)
return token.Pos(pac.Pos()), &ast.Ident{
NamePos: token.Pos(name.Pos()),
Name: string(name.Value()),
}
}
func (p *parser) parseElement(n *parse.Node) ast.Expr {
n = n.Child(0)
if n.Is(value) {
return p.parseValue(n)
}
return p.parseKeyValue(n)
}
func (p *parser) parseSliceType(n *parse.Node) ast.Expr {
return &ast.ArrayType{
Lbrack: token.Pos(n.Child(0).Pos()),
Len: nil,
Elt: p.parseType(n.Child(2)),
}
}
func (p *parser) parseLiteralValue(n *parse.Node) (exprs []ast.Expr) {
if n.ChildCount() == 3 {
eachListItem(element, n.Child(1), func(item *parse.Node) {
exprs = append(exprs, p.parseElement(item))
})
}
return
}
func (p *parser) parseInit(n *parse.Node) ast.Stmt {
if n == nil {
return nil
}
n = n.Child(0)
fmt.Println(n)
return nil
}
func (p *parser) parseReturnStmt(n *parse.Node) ast.Stmt {
ret := ast.ReturnStmt{
Return: token.Pos(n.Child(0).Pos()),
}
if n.ChildCount() > 1 {
ret.Results = p.parseExprList(n.Child(1))
}
return &ret
}
func (p *parser) parseSignature(n *parse.Node, scope *ast.Scope) *ast.FuncType {
funcType := ast.FuncType{
Params: p.parseParams(n.Child(0), scope),
}
if n.ChildCount() > 1 {
funcType.Results = p.parseResults(n.Child(1), scope)
}
return &funcType
}
func (p *parser) parseCompositeLit(n *parse.Node) ast.Expr {
litValue := n.Child(1)
return &ast.CompositeLit{
Type: p.parseLiteralType(n.Child(0)),
Lbrace: token.Pos(litValue.Child(0).Pos()),
Elts: p.parseLiteralValue(litValue),
Rbrace: token.Pos(litValue.LastChild().Pos()),
}
}
func eachInlineListItem(n *parse.Node, visit func(*parse.Node)) {
visit(n.Child(0))
if n.ChildCount() > 1 {
n.Child(1).EachItem(func(item *parse.Node) {
visit(item.Child(1))
})
}
return
}
func (p *parser) parseIndex(n *parse.Node) ast.Expr {
index := n.Child(1)
return &ast.IndexExpr{
X: p.parsePrimaryExpr(n.Child(0)),
Lbrack: token.Pos(index.Child(0).Pos()),
Index: p.parseExpr(index.Child(1)),
Rbrack: token.Pos(index.Child(2).Pos()),
}
}
func (p *parser) parseVarSpec(n *parse.Node) *ast.ValueSpec {
if n.Is(valueSpec) {
return p.parseValueSpec(n)
}
return &ast.ValueSpec{
Names: p.parseIdentList(n.Child(0)),
Type: p.parseType(n.Child(1)),
}
}
func (p *parser) parseType(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case typeName:
return p.parseTypeName(n)
case typeLit:
return p.parseTypeLit(n)
}
return p.parseType(n.Child(1))
}
func (p *parser) parseValue(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case expr:
return p.parseExpr(n)
case literalValue:
}
fmt.Println("parseValue", n)
return nil
}
func (p *parser) parseUnaryExpr(n *parse.Node) ast.Expr {
if n.Child(0).Is(primaryExpr) {
return p.parsePrimaryExpr(n.Child(0))
}
return &ast.UnaryExpr{
OpPos: token.Pos(n.Child(0).Child(0).Pos()),
Op: token.Token(n.Child(0).Child(0).ID()),
X: p.parseUnaryExpr(n.Child(1)),
}
}
func (p *parser) parseBlock(n *parse.Node, scope *ast.Scope) *ast.BlockStmt {
block := ast.BlockStmt{
Lbrace: token.Pos(n.Child(0).Pos()),
Rbrace: token.Pos(n.LastChild().Pos()),
}
eachListItem(stmt, n.Child(1), func(item *parse.Node) {
block.List = append(block.List, p.parseStmt(item))
})
return &block
}
func (p *parser) parseGoExpr(n *parse.Node) ast.Expr {
n = n.Child(0).Child(0)
switch n.Rule() {
case expr:
return p.parseExpr(n)
case type_:
return p.parseType(n)
}
return nil
}
func (p *parser) parseResults(n *parse.Node, scope *ast.Scope) *ast.FieldList {
n = n.Child(0)
switch n.Rule() {
case parameters:
return p.parseParams(n, scope)
case type_:
return &ast.FieldList{List: []*ast.Field{{Type: p.parseType(n)}}}
}
return nil
}
func (c Comment) append(commentNode *parse.Node) Comment {
commentNode.Child(1).Each(func(citem *parse.Node) {
citem = citem.Child(0)
if citem.Is(commentText) {
c.Items = append(c.Items, citem.Get(commentText))
} else if citem.Is(comment) {
c.Comments = append(c.Comments, Comment{}.append(citem))
}
})
return c
}
func (p *parser) parsePost(n *parse.Node) ast.Stmt {
if n == nil {
return nil
}
n = n.Child(0)
if !n.Is(forClause) {
return nil
}
fmt.Println(n)
return nil
}
func (p *parser) parseCallExpr(n *parse.Node) *ast.CallExpr {
call := n.Child(1)
callExpr := ast.CallExpr{
Fun: p.parsePrimaryExpr(n.Child(0)),
Lparen: token.Pos(call.Child(0).Pos()),
Rparen: token.Pos(call.LastChild().Pos()),
}
if call.ChildCount() > 2 {
callExpr.Args, callExpr.Ellipsis = p.parseArgs(call.Child(1))
}
return &callExpr
}
func (p *parser) parseOperand(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case literal:
return p.parseLiteral(n)
case operandName:
return p.parseIdent(n)
default:
return p.parseExpr(n.Child(1))
}
return nil
}
func (p *parser) parseLiteral(n *parse.Node) ast.Expr {
n = n.Child(0)
switch n.Rule() {
case basicLit:
return p.parseBasicLit(n.Child(0))
case compositeLit:
return p.parseCompositeLit(n)
case funcLit:
return p.parseFuncLit(n)
}
return nil
}
func (p *parser) parseTopLevelDecl(n *parse.Node) ast.Decl {
n = n.Child(0)
switch n.Rule() {
case decl:
return p.parseDecl(n)
case funcDecl:
return p.parseFuncDecl(n)
case methodDecl:
return p.parseMethodDecl(n)
}
return nil
}
func (p *parser) parseSwitchStmt(n *parse.Node) ast.Stmt {
p.openScope()
n = n.Child(0)
switch n.Rule() {
case exprSwitchStmt:
return p.parseExprSwitchStmt(n)
case typeSwitchStmt:
return p.parseTypeSwitchStmt(n)
}
p.closeScope()
return nil
}
func (p *parser) parseDecl(n *parse.Node) ast.Decl {
n = n.Child(0)
switch n.Rule() {
case constDecl:
return p.parseConstDecl(n)
case typeDecl:
return p.parseTypeDecl(n)
case varDecl:
return p.parseVarDecl(n)
}
return nil
}
func (p *parser) parseElse(n *parse.Node) ast.Stmt {
if n == nil {
return nil
}
n = n.Child(0)
switch n.Rule() {
case ifStmt:
return p.parseIfStmt(n)
case block:
return p.parseBlock(n, p.topScope)
}
return nil
}
func (p *parser) parseForStmt(n *parse.Node) (r ast.Stmt) {
p.openScope()
forPos := token.Pos(n.Child(0).Pos())
n = n.Child(1)
if n.Is(block) {
return &ast.ForStmt{
For: forPos,
Body: p.parseBlock(n, p.topScope),
}
}
option := n.Child(0).Child(0)
body := p.parseBlock(n.Child(1), p.topScope)
switch option.Rule() {
case condition:
fmt.Println(option)
case forClause:
fmt.Println(option)
case rangeClause:
forStmt := p.parseRangeStmt(option)
forStmt.For, forStmt.Body = forPos, body
r = forStmt
}
p.closeScope()
return
}
func (p *parser) parseSimpleStmt(n *parse.Node) ast.Stmt {
n = n.Child(0)
switch n.Rule() {
case exprStmt:
return p.parseExprStmt(n)
case sendStmt:
case incDecStmt:
case assignment:
return p.parseAsignment(n)
case shortVarDecl:
return p.parseShortVarDecl(n)
}
fmt.Println("simpleStmt", n)
return nil
}