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) 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 (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) 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) 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) 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) 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) 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) 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 }
func (p *parser) parseLiteralType(n *parse.Node) ast.Expr { n = n.Child(0) switch n.Rule() { case arrayType: case structType: return p.parseStructType(n) case sliceType: return p.parseSliceType(n) case mapType: case typeName: default: // array } fmt.Println(n) return nil }
func (p *parser) parseTypeLit(n *parse.Node) ast.Expr { n = n.Child(0) switch n.Rule() { case arrayType: case structType: return p.parseStructType(n) case pointerType: return p.parsePointerType(n) case funcType: case interfaceType: return p.parseInterfaceType(n) case sliceType: case mapType: case channelType: } fmt.Println(n) return nil }
func (p *parser) parseStmt(n *parse.Node) ast.Stmt { n = n.Child(0) switch n.Rule() { case decl: return p.parseDeclStmt(n) case labeledStmt: return p.parseLabeledStmt(n) case simpleStmt: return p.parseSimpleStmt(n) case goStmt: return p.parseGoStmt(n) case returnStmt: return p.parseReturnStmt(n) case breakStmt: return p.parseBreakStmt(n) case continueStmt: return p.parseContinueStmt(n) case gotoStmt: return p.parseGotoStmt(n) case fallthroughStmt: return p.parseFallthroughStmt(n) case block: return p.parseBlockStmt(n) case ifStmt: return p.parseIfStmt(n) case switchStmt: return p.parseSwitchStmt(n) case selectStmt: return p.parseSelectStmt(n) case forStmt: return p.parseForStmt(n) case deferStmt: return p.parseDeferStmt(n) } return nil }