Merge pull request #110 from vim-jp/new-dict-syntax

Implement #{ ... } syntax

Author: tyru

autoload/vimlparser.vim

@@ -205,6 +205,7 @@ let s:TOKEN_DOTDOTDOT = 63
 let s:TOKEN_SHARP = 64
 let s:TOKEN_ARROW = 65
 let s:TOKEN_BLOB = 66
+let s:TOKEN_LITCOPEN = 67
 
 let s:MAX_FUNC_ARGS = 20
 
@@ -2772,8 +2773,13 @@ function! s:ExprTokenizer.get2()
     call r.seek_cur(1)
     return self.token(s:TOKEN_COLON, ':', pos)
   elseif c ==# '#'
-    call r.seek_cur(1)
-    return self.token(s:TOKEN_SHARP, '#', pos)
+    if r.p(1) ==# '{'
+      call r.seek_cur(2)
+      return self.token(s:TOKEN_LITCOPEN, '#{', pos)
+    else
+      call r.seek_cur(1)
+      return self.token(s:TOKEN_SHARP, '#', pos)
+    endif
   elseif c ==# '('
     call r.seek_cur(1)
     return self.token(s:TOKEN_POPEN, '(', pos)
@@ -2893,6 +2899,29 @@ function! s:ExprTokenizer.get_dstring()
   return s
 endfunction
 
+function! s:ExprTokenizer.get_dict_literal_key()
+  call self.reader.skip_white()
+  let r = self.reader
+  let c = r.peek()
+  if !s:isalnum(c) && c != '_' && c != '-'
+    throw s:Err(printf('unexpected token: %s', token.value), token.pos)
+  endif
+  let s = c
+  call self.reader.seek_cur(1)
+  while s:TRUE
+    let c = self.reader.p(0)
+    if c ==# '<EOF>' || c ==# '<EOL>'
+      throw s:Err('unexpectd EOL', self.reader.getpos())
+    endif
+    if !s:isalnum(c) && c != '_' && c != '-'
+      break
+    endif
+    call self.reader.seek_cur(1)
+    let s .= c
+  endwhile
+  return s
+endfunction
+
 let s:ExprParser = {}
 
 function! s:ExprParser.new(...)
@@ -3381,6 +3410,7 @@ endfunction
 "        'string'
 "        [expr1, ...]
 "        {expr1: expr1, ...}
+"        #{literal_key1: expr1, ...}
 "        {args -> expr1}
 "        &option
 "        (expr1)
@@ -3437,7 +3467,8 @@ function! s:ExprParser.parse_expr9()
         endif
       endwhile
     endif
-  elseif token.type == s:TOKEN_COPEN
+  elseif token.type == s:TOKEN_COPEN || token.type == s:TOKEN_LITCOPEN
+    let is_litdict = token.type == s:TOKEN_LITCOPEN
     let savepos = self.reader.tell()
     let nodepos = token.pos
     let token = self.tokenizer.get()
@@ -3525,7 +3556,7 @@ function! s:ExprParser.parse_expr9()
       return node
     endif
     while 1
-      let key = self.parse_expr1()
+      let key = is_litdict ? self.parse_dict_literal_key() : self.parse_expr1()
       let token = self.tokenizer.get()
       if token.type == s:TOKEN_CCLOSE
         if !empty(node.value)
@@ -3590,6 +3621,13 @@ function! s:ExprParser.parse_expr9()
   return node
 endfunction
 
+function! s:ExprParser.parse_dict_literal_key()
+  let node = s:Node(s:NODE_STRING)
+  let node.pos = self.reader.tell()
+  let node.value = "'" . self.tokenizer.get_dict_literal_key() . "'"
+  return node
+endfunction
+
 " SUBSCRIPT or CONCAT
 "   dict "." [0-9A-Za-z_]+ => (subscript dict key)
 "   str  "." expr6         => (concat str expr6)

js/vimlparser.js

@@ -397,6 +397,7 @@ var TOKEN_DOTDOTDOT = 63;
 var TOKEN_SHARP = 64;
 var TOKEN_ARROW = 65;
 var TOKEN_BLOB = 66;
+var TOKEN_LITCOPEN = 67;
 var MAX_FUNC_ARGS = 20;
 function isalpha(c) {
     return viml_eqregh(c, "^[A-Za-z]$");
@@ -2552,8 +2553,14 @@ ExprTokenizer.prototype.get2 = function() {
         return this.token(TOKEN_COLON, ":", pos);
     }
     else if (c == "#") {
-        r.seek_cur(1);
-        return this.token(TOKEN_SHARP, "#", pos);
+        if (r.p(1) == "{") {
+            r.seek_cur(2);
+            return this.token(TOKEN_LITCOPEN, "#{", pos);
+        }
+        else {
+            r.seek_cur(1);
+            return this.token(TOKEN_SHARP, "#", pos);
+        }
     }
     else if (c == "(") {
         r.seek_cur(1);
@@ -2697,6 +2704,29 @@ ExprTokenizer.prototype.get_dstring = function() {
     return s;
 }
 
+ExprTokenizer.prototype.get_dict_literal_key = function() {
+    this.reader.skip_white();
+    var r = this.reader;
+    var c = r.peek();
+    if (!isalnum(c) && c != "_" && c != "-") {
+        throw Err(viml_printf("unexpected token: %s", token.value), token.pos);
+    }
+    var s = c;
+    this.reader.seek_cur(1);
+    while (TRUE) {
+        var c = this.reader.p(0);
+        if (c == "<EOF>" || c == "<EOL>") {
+            throw Err("unexpectd EOL", this.reader.getpos());
+        }
+        if (!isalnum(c) && c != "_" && c != "-") {
+            break;
+        }
+        this.reader.seek_cur(1);
+        s += c;
+    }
+    return s;
+}
+
 function ExprParser() { this.__init__.apply(this, arguments); }
 ExprParser.prototype.__init__ = function(reader) {
     this.reader = reader;
@@ -3228,6 +3258,7 @@ ExprParser.prototype.parse_expr8 = function() {
 //        'string'
 //        [expr1, ...]
 //        {expr1: expr1, ...}
+//        #{literal_key1: expr1, ...}
 //        {args -> expr1}
 //        &option
 //        (expr1)
@@ -3292,7 +3323,8 @@ ExprParser.prototype.parse_expr9 = function() {
             }
         }
     }
-    else if (token.type == TOKEN_COPEN) {
+    else if (token.type == TOKEN_COPEN || token.type == TOKEN_LITCOPEN) {
+        var is_litdict = token.type == TOKEN_LITCOPEN;
         var savepos = this.reader.tell();
         var nodepos = token.pos;
         var token = this.tokenizer.get();
@@ -3387,7 +3419,7 @@ ExprParser.prototype.parse_expr9 = function() {
             return node;
         }
         while (1) {
-            var key = this.parse_expr1();
+            var key = is_litdict ? this.parse_dict_literal_key() : this.parse_expr1();
             var token = this.tokenizer.get();
             if (token.type == TOKEN_CCLOSE) {
                 if (!viml_empty(node.value)) {
@@ -3463,6 +3495,13 @@ ExprParser.prototype.parse_expr9 = function() {
     return node;
 }
 
+ExprParser.prototype.parse_dict_literal_key = function() {
+    var node = Node(NODE_STRING);
+    node.pos = this.reader.tell();
+    node.value = "'" + this.tokenizer.get_dict_literal_key() + "'";
+    return node;
+}
+
 // SUBSCRIPT or CONCAT
 //   dict "." [0-9A-Za-z_]+ => (subscript dict key)
 //   str  "." expr6         => (concat str expr6)

py/vimlparser.py

@@ -351,6 +351,7 @@ def viml_type(obj):
 TOKEN_SHARP = 64
 TOKEN_ARROW = 65
 TOKEN_BLOB = 66
+TOKEN_LITCOPEN = 67
 MAX_FUNC_ARGS = 20
 def isalpha(c):
     return viml_eqregh(c, "^[A-Za-z]$")
@@ -2023,8 +2024,12 @@ def get2(self):
             r.seek_cur(1)
             return self.token(TOKEN_COLON, ":", pos)
         elif c == "#":
-            r.seek_cur(1)
-            return self.token(TOKEN_SHARP, "#", pos)
+            if r.p(1) == "{":
+                r.seek_cur(2)
+                return self.token(TOKEN_LITCOPEN, "#{", pos)
+            else:
+                r.seek_cur(1)
+                return self.token(TOKEN_SHARP, "#", pos)
         elif c == "(":
             r.seek_cur(1)
             return self.token(TOKEN_POPEN, "(", pos)
@@ -2131,6 +2136,24 @@ def get_dstring(self):
                 s += c
         return s
 
+    def get_dict_literal_key(self):
+        self.reader.skip_white()
+        r = self.reader
+        c = r.peek()
+        if not isalnum(c) and c != "_" and c != "-":
+            raise VimLParserException(Err(viml_printf("unexpected token: %s", token.value), token.pos))
+        s = c
+        self.reader.seek_cur(1)
+        while TRUE:
+            c = self.reader.p(0)
+            if c == "<EOF>" or c == "<EOL>":
+                raise VimLParserException(Err("unexpectd EOL", self.reader.getpos()))
+            if not isalnum(c) and c != "_" and c != "-":
+                break
+            self.reader.seek_cur(1)
+            s += c
+        return s
+
 class ExprParser:
     def __init__(self, reader):
         self.reader = reader
@@ -2575,6 +2598,7 @@ def parse_expr8(self):
 #        'string'
 #        [expr1, ...]
 #        {expr1: expr1, ...}
+#        #{literal_key1: expr1, ...}
 #        {args -> expr1}
 #        &option
 #        (expr1)
@@ -2627,7 +2651,8 @@ def parse_expr9(self):
                         break
                     else:
                         raise VimLParserException(Err(viml_printf("unexpected token: %s", token.value), token.pos))
-        elif token.type == TOKEN_COPEN:
+        elif token.type == TOKEN_COPEN or token.type == TOKEN_LITCOPEN:
+            is_litdict = token.type == TOKEN_LITCOPEN
             savepos = self.reader.tell()
             nodepos = token.pos
             token = self.tokenizer.get()
@@ -2703,7 +2728,7 @@ def parse_expr9(self):
                 self.tokenizer.get()
                 return node
             while 1:
-                key = self.parse_expr1()
+                key = self.parse_dict_literal_key() if is_litdict else self.parse_expr1()
                 token = self.tokenizer.get()
                 if token.type == TOKEN_CCLOSE:
                     if not viml_empty(node.value):
@@ -2759,6 +2784,12 @@ def parse_expr9(self):
             raise VimLParserException(Err(viml_printf("unexpected token: %s", token.value), token.pos))
         return node
 
+    def parse_dict_literal_key(self):
+        node = Node(NODE_STRING)
+        node.pos = self.reader.tell()
+        node.value = "'" + self.tokenizer.get_dict_literal_key() + "'"
+        return node
+
 # SUBSCRIPT or CONCAT
 #   dict "." [0-9A-Za-z_]+ => (subscript dict key)
 #   str  "." expr6         => (concat str expr6)

test/test_litdict.ok

@@ -0,0 +1,8 @@
+(echo (dict))
+(echo (dict ('foo-bar' 42)))
+(echo (dict ('foo-' 42)))
+(echo (dict ('-bar' 42)))
+(echo (dict ('1-1' 0)))
+(echo (dict ('one' 1) ('two2' 2) ('3three' 3) ('44' 4)))
+(echo (dict ('x' (dict))))
+(echo (list (dict)))

test/test_litdict.vim

@@ -0,0 +1,8 @@
+echo #{}
+echo #{foo-bar: 42}
+echo #{foo-: 42}
+echo #{-bar: 42}
+echo #{1-1:0}
+echo #{one: 1, two2: 2, 3three: 3, 44: 4}
+echo #{x : {},}
+echo [#{},]