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) 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) 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) 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) parseStructType(n *parse.Node) ast.Expr {
	struct_ := n.Child(0)
	return &ast.StructType{
		Struct: token.Pos(struct_.Pos()),
		// TODO: Fields
	}
}

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) parseImports(n *parse.Node) (decls []ast.Decl, specs []*ast.ImportSpec) {
	n.EachItem(func(item *parse.Node) {
		decl, ss := p.parseImportDecl(item.Child(0))
		decls = append(decls, decl)
		specs = append(specs, ss...)
	})
	return
}

func newProduct(productNode *parse.Node) *Product {
	return &Product{
		Name: productNode.Get(productName),
		Version: Version{
			Text: productNode.Get(productVersion),
		},
	}
}

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 (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) 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) 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) 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 (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) 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) 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
}