Merge pull request #30 from haya14busa/paren-expr

Add ast.ParenExpr

Author: haya14busa

ast/node.go

@@ -526,6 +526,15 @@ type LambdaExpr struct {
 
 func (i *LambdaExpr) Pos() Pos { return i.Lcurlybrace }
 
+// ParenExpr node represents a parenthesized expression.
+// vimlparsr: PARENEXPR .value
+type ParenExpr struct {
+	Lparen Pos  // position of "("
+	X      Expr // parenthesized expression
+}
+
+func (i *ParenExpr) Pos() Pos { return i.Lparen }
+
 // stmtNode() ensures that only ExComamnd and Comment nodes can be assigned to
 // an Statement.
 //
@@ -577,3 +586,4 @@ func (*CurlyNameLit) exprNode()  {}
 func (*CurlyNameExpr) exprNode() {}
 func (*Ident) exprNode()         {}
 func (*LambdaExpr) exprNode()    {}
+func (*ParenExpr) exprNode()     {}

ast/walk.go

@@ -198,6 +198,9 @@ func Walk(v Visitor, node Node) {
 	case *LambdaExpr:
 		walkIdentList(v, n.Params)
 
+	case *ParenExpr:
+		Walk(v, n.X)
+
 	default:
 		panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n))
 	}

autoload/vimlparser.vim

@@ -137,6 +137,7 @@ let s:NODE_REG = 89
 let s:NODE_CURLYNAMEPART = 90
 let s:NODE_CURLYNAMEEXPR = 91
 let s:NODE_LAMBDA = 92
+let s:NODE_PARENEXPR = 93
 
 let s:TOKEN_EOF = 1
 let s:TOKEN_EOL = 2
@@ -403,6 +404,7 @@ endfunction
 " CURLYNAMEPART .value
 " CURLYNAMEEXPR .value
 " LAMBDA .rlist .left
+" PARENEXPR .value
 function! s:Node(type)
   return {'type': a:type}
 endfunction
@@ -3514,7 +3516,9 @@ function! s:ExprParser.parse_expr9()
     endwhile
     return node
   elseif token.type == s:TOKEN_POPEN
-    let node = self.parse_expr1()
+    let node = s:Node(s:NODE_PARENEXPR)
+    let node.pos = token.pos
+    let node.value = self.parse_expr1()
     let token = self.tokenizer.get()
     if token.type != s:TOKEN_PCLOSE
       throw s:Err(printf('unexpected token: %s', token.value), token.pos)
@@ -4185,6 +4189,8 @@ function! s:Compiler.compile(node)
     return self.compile_curlynameexpr(a:node)
   elseif a:node.type == s:NODE_LAMBDA
     return self.compile_lambda(a:node)
+  elseif a:node.type == s:NODE_PARENEXPR
+    return self.compile_parenexpr(a:node)
   else
     throw printf('Compiler: unknown node: %s', string(a:node))
   endif
@@ -4648,6 +4654,10 @@ function! s:Compiler.compile_lambda(node)
   return printf('(lambda (%s) %s)', join(rlist, ' '), self.compile(a:node.left))
 endfunction
 
+function! s:Compiler.compile_parenexpr(node)
+  return self.compile(a:node.value)
+endfunction
+
 " TODO: under construction
 let s:RegexpParser = {}
 

compiler/compiler.go

@@ -437,6 +437,8 @@ func (c *Compiler) compileExpr(node ast.Expr) string {
 			params = append(params, p.Name)
 		}
 		return fmt.Sprintf("(lambda (%s) %s)", strings.Join(params, " "), c.compileExpr(n.Expr))
+	case *ast.ParenExpr:
+		return c.compileExpr(n.X)
 	}
 	return ""
 }

go/export.go

@@ -446,6 +446,13 @@ func newAstNode(n *VimNode, filename string) ast.Node {
 			Expr:        newExprNode(n.left, filename),
 		}
 
+	case NODE_PARENEXPR:
+		n := n.value.(*VimNode)
+		return &ast.ParenExpr{
+			Lparen: pos,
+			X:      newExprNode(n, filename),
+		}
+
 	}
 	panic(fmt.Errorf("Unknown node type: %v, node: %v", n.type_, n))
 }

go/gocompiler.vim

@@ -6,6 +6,7 @@ call extend(s:, vimlparser#import())
 
 let s:opprec = {}
 let s:opprec[s:NODE_TERNARY] = 1
+let s:opprec[s:NODE_PARENEXPR] = 1
 let s:opprec[s:NODE_OR] = 2
 let s:opprec[s:NODE_AND] = 3
 let s:opprec[s:NODE_EQUAL] = 4
@@ -280,6 +281,8 @@ function s:GoCompiler.compile(node)
     return self.compile_env(a:node)
   elseif a:node.type == s:NODE_REG
     return self.compile_reg(a:node)
+  elseif a:node.type == s:NODE_PARENEXPR
+    return self.compile_parenexpr(a:node)
   else
     throw self.err('Compiler: unknown node: %s', string(a:node))
   endif
@@ -358,6 +361,7 @@ function s:GoCompiler.compile_function(node)
     \     || name == 'compile_list'
     \     || name == 'compile_curlyname'
     \     || name == 'compile_dict'
+    \     || name == 'compile_parenexpr'
     \     ))
       return
     endif
@@ -956,6 +960,10 @@ function s:GoCompiler.compile_reg(node)
   throw 'NotImplemented: reg'
 endfunction
 
+function s:GoCompiler.compile_parenexpr(node)
+  return self.compile(a:node.value)
+endfunction
+
 function s:GoCompiler.compile_op1(node, op)
   let left = self.compile(a:node.left)
   if s:opprec[a:node.type] > s:opprec[a:node.left.type]

go/type.go

@@ -310,6 +310,10 @@ func (self *Compiler) compile_dict(n *VimNode) string {
 	}
 }
 
+func (self *Compiler) compile_parenexpr(n *VimNode) string {
+	return self.compile(n.value.(*VimNode)).(string)
+}
+
 type ParseError struct {
 	Offset int
 	Line   int

go/typedefs.vim

@@ -318,6 +318,7 @@ call extend(s:typedefs.func, {
 \   'Compiler.compile_curlynamepart': { 'in': ['*VimNode'], 'out': ['string'] },
 \   'Compiler.compile_curlynameexpr': { 'in': ['*VimNode'], 'out': ['string'] },
 \   'Compiler.compile_lambda': { 'in': ['*VimNode'], 'out': ['string'] },
+\   'Compiler.compile_parenexpr': { 'in': ['*VimNode'], 'out': ['string'] },
 \ })
 
 function! ImportTypedefs() abort

go/vimlparser.go

@@ -0,0 +1,5 @@
+; test_parenexpr
+(echo 1)
+(echo 1)
+(echo (+ (+ 1 1) 2))
+(echo (+ (+ 1 1) (* 2 (+ 3 4))))