refactor: format #15702

1 files changed, 1623 insertions, 1644 deletions

diff --git a/src/nvim/viml/parser/expressions.c b/src/nvim/viml/parser/expressions.c
index 967d656dc5..c2aa923c49 100644
--- a/src/nvim/viml/parser/expressions.c
+++ b/src/nvim/viml/parser/expressions.c
@@ -50,20 +50,19 @@
 // 7. 'isident' no longer applies to environment variables, they always include
 //    ASCII alphanumeric characters and underscore and nothing except this.
 
+#include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
-#include <assert.h>
 #include <string.h>
 
-#include "nvim/vim.h"
-#include "nvim/memory.h"
-#include "nvim/types.h"
-#include "nvim/charset.h"
 #include "nvim/ascii.h"
 #include "nvim/assert.h"
-#include "nvim/lib/kvec.h"
+#include "nvim/charset.h"
 #include "nvim/eval/typval.h"
-
+#include "nvim/lib/kvec.h"
+#include "nvim/memory.h"
+#include "nvim/types.h"
+#include "nvim/vim.h"
 #include "nvim/viml/parser/expressions.h"
 #include "nvim/viml/parser/parser.h"
 
@@ -143,10 +142,8 @@ typedef enum {
 ///                   numbers are not supported.
 /// @param[in]  exponent  Exponent to scale by.
 /// @param[in]  exponent_negative  True if exponent is negative.
-static inline float_T scale_number(const float_T num,
-                                   const uint8_t base,
-                                   const uvarnumber_T exponent,
-                                   const bool exponent_negative)
+static inline float_T scale_number(const float_T num, const uint8_t base,
+                                   const uvarnumber_T exponent, const bool exponent_negative)
   FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_CONST
 {
   if (num == 0 || exponent == 0) {
@@ -200,7 +197,7 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
     if (ret.len < pline.size \
         && strchr("?#", pline.data[ret.len]) != NULL) { \
       ret.data.cmp.ccs = \
-          (ExprCaseCompareStrategy)pline.data[ret.len]; \
+        (ExprCaseCompareStrategy)pline.data[ret.len]; \
       ret.len++; \
     } else { \
       ret.data.cmp.ccs = kCCStrategyUseOption; \
@@ -209,12 +206,12 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
   switch (schar) {
     // Paired brackets.
 #define BRACKET(typ, opning, clsing) \
-    case opning: \
-    case clsing: { \
-      ret.type = typ; \
-      ret.data.brc.closing = (schar == clsing); \
-      break; \
-    }
+case opning: \
+case clsing: { \
+  ret.type = typ; \
+  ret.data.brc.closing = (schar == clsing); \
+  break; \
+}
     BRACKET(kExprLexParenthesis, '(', ')')
     BRACKET(kExprLexBracket, '[', ']')
     BRACKET(kExprLexFigureBrace, '{', '}')
@@ -222,10 +219,10 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
 
     // Single character tokens without data.
 #define CHAR(typ, ch) \
-    case ch: { \
-      ret.type = typ; \
-      break; \
-    }
+case ch: { \
+  ret.type = typ; \
+  break; \
+}
     CHAR(kExprLexQuestion, '?')
     CHAR(kExprLexColon, ':')
     CHAR(kExprLexComma, ',')
@@ -233,198 +230,265 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
 
     // Multiplication/division/modulo.
 #define MUL(mul_type, ch) \
-    case ch: { \
-      ret.type = kExprLexMultiplication; \
-      ret.data.mul.type = mul_type; \
-      break; \
-    }
+case ch: { \
+  ret.type = kExprLexMultiplication; \
+  ret.data.mul.type = mul_type; \
+  break; \
+}
     MUL(kExprLexMulMul, '*')
     MUL(kExprLexMulDiv, '/')
     MUL(kExprLexMulMod, '%')
 #undef MUL
 
 #define CHARREG(typ, cond) \
-    do { \
-      ret.type = typ; \
-      for (; (ret.len < pline.size \
-              && cond(pline.data[ret.len])) \
-           ; ret.len++) { \
-      } \
-    } while (0)
-
-    // Whitespace.
-    case ' ':
-    case TAB: {
-      CHARREG(kExprLexSpacing, ascii_iswhite);
-      break;
-    }
-
-    // Control character, except for NUL, NL and TAB.
-    case Ctrl_A: case Ctrl_B: case Ctrl_C: case Ctrl_D: case Ctrl_E:
-    case Ctrl_F: case Ctrl_G: case Ctrl_H:
+  do { \
+    ret.type = typ; \
+    for (; (ret.len < pline.size \
+            && cond(pline.data[ret.len])) \
+         ; ret.len++) { \
+    } \
+  } while (0)
 
-    case Ctrl_K: case Ctrl_L: case Ctrl_M: case Ctrl_N: case Ctrl_O:
-    case Ctrl_P: case Ctrl_Q: case Ctrl_R: case Ctrl_S: case Ctrl_T:
-    case Ctrl_U: case Ctrl_V: case Ctrl_W: case Ctrl_X: case Ctrl_Y:
-    case Ctrl_Z: {
+  // Whitespace.
+  case ' ':
+  case TAB:
+    CHARREG(kExprLexSpacing, ascii_iswhite);
+    break;
+
+  // Control character, except for NUL, NL and TAB.
+  case Ctrl_A:
+  case Ctrl_B:
+  case Ctrl_C:
+  case Ctrl_D:
+  case Ctrl_E:
+  case Ctrl_F:
+  case Ctrl_G:
+  case Ctrl_H:
+
+  case Ctrl_K:
+  case Ctrl_L:
+  case Ctrl_M:
+  case Ctrl_N:
+  case Ctrl_O:
+  case Ctrl_P:
+  case Ctrl_Q:
+  case Ctrl_R:
+  case Ctrl_S:
+  case Ctrl_T:
+  case Ctrl_U:
+  case Ctrl_V:
+  case Ctrl_W:
+  case Ctrl_X:
+  case Ctrl_Y:
+  case Ctrl_Z:
 #define ISCTRL(schar) (schar < ' ')
-      CHARREG(kExprLexInvalid, ISCTRL);
-      ret.data.err.type = kExprLexSpacing;
-      ret.data.err.msg =
-          _("E15: Invalid control character present in input: %.*s");
-      break;
+    CHARREG(kExprLexInvalid, ISCTRL);
+    ret.data.err.type = kExprLexSpacing;
+    ret.data.err.msg =
+      _("E15: Invalid control character present in input: %.*s");
+    break;
 #undef ISCTRL
-    }
 
-    // Number.
-    case '0': case '1': case '2': case '3': case '4': case '5': case '6':
-    case '7': case '8': case '9': {
-      ret.data.num.is_float = false;
-      ret.data.num.base = 10;
-      size_t frac_start = 0;
-      size_t exp_start = 0;
-      size_t frac_end = 0;
-      bool exp_negative = false;
-      CHARREG(kExprLexNumber, ascii_isdigit);
-      if (flags & kELFlagAllowFloat) {
-        const LexExprToken non_float_ret = ret;
+  // Number.
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9': {
+    ret.data.num.is_float = false;
+    ret.data.num.base = 10;
+    size_t frac_start = 0;
+    size_t exp_start = 0;
+    size_t frac_end = 0;
+    bool exp_negative = false;
+    CHARREG(kExprLexNumber, ascii_isdigit);
+    if (flags & kELFlagAllowFloat) {
+      const LexExprToken non_float_ret = ret;
+      if (pline.size > ret.len + 1
+          && pline.data[ret.len] == '.'
+          && ascii_isdigit(pline.data[ret.len + 1])) {
+        ret.len++;
+        frac_start = ret.len;
+        frac_end = ret.len;
+        ret.data.num.is_float = true;
+        for (; ret.len < pline.size && ascii_isdigit(pline.data[ret.len])
+             ; ret.len++) {
+          // A small optimization: trailing zeroes in fractional part do not
+          // add anything to significand, so it is useless to include them in
+          // frac_end.
+          if (pline.data[ret.len] != '0') {
+            frac_end = ret.len + 1;
+          }
+        }
         if (pline.size > ret.len + 1
-            && pline.data[ret.len] == '.'
-            && ascii_isdigit(pline.data[ret.len + 1])) {
+            && (pline.data[ret.len] == 'e'
+                || pline.data[ret.len] == 'E')
+            && ((pline.size > ret.len + 2
+                 && (pline.data[ret.len + 1] == '+'
+                     || pline.data[ret.len + 1] == '-')
+                 && ascii_isdigit(pline.data[ret.len + 2]))
+                || ascii_isdigit(pline.data[ret.len + 1]))) {
           ret.len++;
-          frac_start = ret.len;
-          frac_end = ret.len;
-          ret.data.num.is_float = true;
-          for (; ret.len < pline.size && ascii_isdigit(pline.data[ret.len])
-               ; ret.len++) {
-            // A small optimization: trailing zeroes in fractional part do not
-            // add anything to significand, so it is useless to include them in
-            // frac_end.
-            if (pline.data[ret.len] != '0') {
-              frac_end = ret.len + 1;
-            }
-          }
-          if (pline.size > ret.len + 1
-              && (pline.data[ret.len] == 'e'
-                  || pline.data[ret.len] == 'E')
-              && ((pline.size > ret.len + 2
-                   && (pline.data[ret.len + 1] == '+'
-                       || pline.data[ret.len + 1] == '-')
-                   && ascii_isdigit(pline.data[ret.len + 2]))
-                  || ascii_isdigit(pline.data[ret.len + 1]))) {
+          if (pline.data[ret.len] == '+'
+              || (exp_negative = (pline.data[ret.len] == '-'))) {
             ret.len++;
-            if (pline.data[ret.len] == '+'
-                || (exp_negative = (pline.data[ret.len] == '-'))) {
-              ret.len++;
-            }
-            exp_start = ret.len;
-            CHARREG(kExprLexNumber, ascii_isdigit);
           }
-        }
-        if (pline.size > ret.len
-            && (pline.data[ret.len] == '.'
-                || ASCII_ISALPHA(pline.data[ret.len]))) {
-          ret = non_float_ret;
+          exp_start = ret.len;
+          CHARREG(kExprLexNumber, ascii_isdigit);
         }
       }
-      // TODO(ZyX-I): detect overflows
-      if (ret.data.num.is_float) {
-        // Vim used to use string2float here which in turn uses strtod(). There
-        // are two problems with this approach:
-        // 1. strtod() is locale-dependent. Not sure how it is worked around so
-        //    that I do not see relevant bugs, but it still does not look like
-        //    a good idea.
-        // 2. strtod() does not accept length argument.
-        //
-        // The below variant of parsing floats was recognized as acceptable
-        // because it is basically how uClibc does the thing: it generates
-        // a number ignoring decimal point (but recording its position), then
-        // uses recorded position to scale number down when processing exponent.
-        float_T significand_part = 0;
-        uvarnumber_T exp_part = 0;
-        const size_t frac_size = (size_t)(frac_end - frac_start);
-        for (size_t i = 0; i < frac_end; i++) {
-          if (i == frac_start - 1) {
-            continue;
-          }
-          significand_part = significand_part * 10 + (pline.data[i] - '0');
-        }
-        if (exp_start) {
-          vim_str2nr(pline.data + exp_start, NULL, NULL, 0, NULL, &exp_part,
-                     (int)(ret.len - exp_start), false);
+      if (pline.size > ret.len
+          && (pline.data[ret.len] == '.'
+              || ASCII_ISALPHA(pline.data[ret.len]))) {
+        ret = non_float_ret;
+      }
+    }
+    // TODO(ZyX-I): detect overflows
+    if (ret.data.num.is_float) {
+      // Vim used to use string2float here which in turn uses strtod(). There
+      // are two problems with this approach:
+      // 1. strtod() is locale-dependent. Not sure how it is worked around so
+      //    that I do not see relevant bugs, but it still does not look like
+      //    a good idea.
+      // 2. strtod() does not accept length argument.
+      //
+      // The below variant of parsing floats was recognized as acceptable
+      // because it is basically how uClibc does the thing: it generates
+      // a number ignoring decimal point (but recording its position), then
+      // uses recorded position to scale number down when processing exponent.
+      float_T significand_part = 0;
+      uvarnumber_T exp_part = 0;
+      const size_t frac_size = (size_t)(frac_end - frac_start);
+      for (size_t i = 0; i < frac_end; i++) {
+        if (i == frac_start - 1) {
+          continue;
         }
-        if (exp_negative) {
-          exp_part += frac_size;
+        significand_part = significand_part * 10 + (pline.data[i] - '0');
+      }
+      if (exp_start) {
+        vim_str2nr(pline.data + exp_start, NULL, NULL, 0, NULL, &exp_part,
+                   (int)(ret.len - exp_start), false);
+      }
+      if (exp_negative) {
+        exp_part += frac_size;
+      } else {
+        if (exp_part < frac_size) {
+          exp_negative = true;
+          exp_part = frac_size - exp_part;
         } else {
-          if (exp_part < frac_size) {
-            exp_negative = true;
-            exp_part = frac_size - exp_part;
-          } else {
-            exp_part -= frac_size;
-          }
+          exp_part -= frac_size;
         }
-        ret.data.num.val.floating = scale_number(significand_part, 10, exp_part,
-                                                 exp_negative);
-      } else {
-        int len;
-        int prep;
-        vim_str2nr(pline.data, &prep, &len, STR2NR_ALL, NULL,
-                   &ret.data.num.val.integer, (int)pline.size, false);
-        ret.len = (size_t)len;
-        const uint8_t bases[] = {
-          [0] = 10,
-          ['0'] = 8,
-          ['x'] = 16, ['X'] = 16,
-          ['b'] = 2, ['B'] = 2,
-        };
-        ret.data.num.base = bases[prep];
       }
-      break;
+      ret.data.num.val.floating = scale_number(significand_part, 10, exp_part,
+                                               exp_negative);
+    } else {
+      int len;
+      int prep;
+      vim_str2nr(pline.data, &prep, &len, STR2NR_ALL, NULL,
+                 &ret.data.num.val.integer, (int)pline.size, false);
+      ret.len = (size_t)len;
+      const uint8_t bases[] = {
+        [0] = 10,
+        ['0'] = 8,
+        ['x'] = 16, ['X'] = 16,
+        ['b'] = 2, ['B'] = 2,
+      };
+      ret.data.num.base = bases[prep];
     }
+    break;
+  }
 
 #define ISWORD_OR_AUTOLOAD(x) \
-      (ascii_isident(x) || (x) == AUTOLOAD_CHAR)
-
-    // Environment variable.
-    case '$': {
-      CHARREG(kExprLexEnv, ascii_isident);
-      break;
-    }
-
-    // Normal variable/function name.
-    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
-    case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
-    case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
-    case 'v': case 'w': case 'x': case 'y': case 'z':
-    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
-    case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
-    case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
-    case 'V': case 'W': case 'X': case 'Y': case 'Z':
-    case '_': {
-      ret.data.var.scope = 0;
-      ret.data.var.autoload = false;
-      CHARREG(kExprLexPlainIdentifier, ascii_isident);
-      // "is" and "isnot" operators.
-      if (!(flags & kELFlagIsNotCmp)
-          && ((ret.len == 2 && memcmp(pline.data, "is", 2) == 0)
-              || (ret.len == 5 && memcmp(pline.data, "isnot", 5) == 0))) {
-        ret.type = kExprLexComparison;
-        ret.data.cmp.type = kExprCmpIdentical;
-        ret.data.cmp.inv = (ret.len == 5);
-        GET_CCS(ret, pline);
+  (ascii_isident(x) || (x) == AUTOLOAD_CHAR)
+
+  // Environment variable.
+  case '$':
+    CHARREG(kExprLexEnv, ascii_isident);
+    break;
+
+  // Normal variable/function name.
+  case 'a':
+  case 'b':
+  case 'c':
+  case 'd':
+  case 'e':
+  case 'f':
+  case 'g':
+  case 'h':
+  case 'i':
+  case 'j':
+  case 'k':
+  case 'l':
+  case 'm':
+  case 'n':
+  case 'o':
+  case 'p':
+  case 'q':
+  case 'r':
+  case 's':
+  case 't':
+  case 'u':
+  case 'v':
+  case 'w':
+  case 'x':
+  case 'y':
+  case 'z':
+  case 'A':
+  case 'B':
+  case 'C':
+  case 'D':
+  case 'E':
+  case 'F':
+  case 'G':
+  case 'H':
+  case 'I':
+  case 'J':
+  case 'K':
+  case 'L':
+  case 'M':
+  case 'N':
+  case 'O':
+  case 'P':
+  case 'Q':
+  case 'R':
+  case 'S':
+  case 'T':
+  case 'U':
+  case 'V':
+  case 'W':
+  case 'X':
+  case 'Y':
+  case 'Z':
+  case '_':
+    ret.data.var.scope = 0;
+    ret.data.var.autoload = false;
+    CHARREG(kExprLexPlainIdentifier, ascii_isident);
+    // "is" and "isnot" operators.
+    if (!(flags & kELFlagIsNotCmp)
+        && ((ret.len == 2 && memcmp(pline.data, "is", 2) == 0)
+            || (ret.len == 5 && memcmp(pline.data, "isnot", 5) == 0))) {
+      ret.type = kExprLexComparison;
+      ret.data.cmp.type = kExprCmpIdentical;
+      ret.data.cmp.inv = (ret.len == 5);
+      GET_CCS(ret, pline);
       // Scope: `s:`, etc.
-      } else if (ret.len == 1
-                 && pline.size > 1
-                 && memchr(EXPR_VAR_SCOPE_LIST, schar,
-                           sizeof(EXPR_VAR_SCOPE_LIST)) != NULL
-                 && pline.data[ret.len] == ':'
-                 && !(flags & kELFlagForbidScope)) {
-        ret.len++;
-        ret.data.var.scope = (ExprVarScope)schar;
-        CHARREG(kExprLexPlainIdentifier, ISWORD_OR_AUTOLOAD);
-        ret.data.var.autoload = (
-            memchr(pline.data + 2, AUTOLOAD_CHAR, ret.len - 2)
-            != NULL);
+    } else if (ret.len == 1
+               && pline.size > 1
+               && memchr(EXPR_VAR_SCOPE_LIST, schar,
+                         sizeof(EXPR_VAR_SCOPE_LIST)) != NULL
+               && pline.data[ret.len] == ':'
+               && !(flags & kELFlagForbidScope)) {
+      ret.len++;
+      ret.data.var.scope = (ExprVarScope)schar;
+      CHARREG(kExprLexPlainIdentifier, ISWORD_OR_AUTOLOAD);
+      ret.data.var.autoload = (
+                               memchr(pline.data + 2, AUTOLOAD_CHAR, ret.len - 2)
+                               != NULL);
       // Previous CHARREG stopped at autoload character in order to make it
       // possible to detect `is#`. Continue now with autoload characters
       // included.
@@ -432,221 +496,213 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
       // Warning: there is ambiguity for the lexer: `is#Foo(1)` is a call of
       // function `is#Foo()`, `1is#Foo(1)` is a comparison `1 is# Foo(1)`. This
       // needs to be resolved on the higher level where context is available.
-      } else if (pline.size > ret.len
-                 && pline.data[ret.len] == AUTOLOAD_CHAR) {
-        ret.data.var.autoload = true;
-        CHARREG(kExprLexPlainIdentifier, ISWORD_OR_AUTOLOAD);
-      }
-      break;
+    } else if (pline.size > ret.len
+               && pline.data[ret.len] == AUTOLOAD_CHAR) {
+      ret.data.var.autoload = true;
+      CHARREG(kExprLexPlainIdentifier, ISWORD_OR_AUTOLOAD);
     }
+    break;
 
 #undef ISWORD_OR_AUTOLOAD
 #undef CHARREG
 
-    // Option.
-    case '&': {
+  // Option.
+  case '&': {
 #define OPTNAMEMISS(ret) \
-        do { \
-          ret.type = kExprLexInvalid; \
-          ret.data.err.type = kExprLexOption; \
-          ret.data.err.msg = _("E112: Option name missing: %.*s"); \
-        } while (0)
-      if (pline.size > 1 && pline.data[1] == '&') {
-        ret.type = kExprLexAnd;
-        ret.len++;
-        break;
+  do { \
+    ret.type = kExprLexInvalid; \
+    ret.data.err.type = kExprLexOption; \
+    ret.data.err.msg = _("E112: Option name missing: %.*s"); \
+  } while (0)
+    if (pline.size > 1 && pline.data[1] == '&') {
+      ret.type = kExprLexAnd;
+      ret.len++;
+      break;
+    }
+    if (pline.size == 1 || !ASCII_ISALPHA(pline.data[1])) {
+      OPTNAMEMISS(ret);
+      break;
+    }
+    ret.type = kExprLexOption;
+    if (pline.size > 2
+        && pline.data[2] == ':'
+        && memchr(EXPR_OPT_SCOPE_LIST, pline.data[1],
+                  sizeof(EXPR_OPT_SCOPE_LIST)) != NULL) {
+      ret.len += 2;
+      ret.data.opt.scope = (ExprOptScope)pline.data[1];
+      ret.data.opt.name = pline.data + 3;
+    } else {
+      ret.data.opt.scope = kExprOptScopeUnspecified;
+      ret.data.opt.name = pline.data + 1;
+    }
+    const char *p = ret.data.opt.name;
+    const char *const e = pline.data + pline.size;
+    if (e - p >= 4 && p[0] == 't' && p[1] == '_') {
+      ret.data.opt.len = 4;
+      ret.len += 4;
+    } else {
+      for (; p < e && ASCII_ISALPHA(*p); p++) {
       }
-      if (pline.size == 1 || !ASCII_ISALPHA(pline.data[1])) {
+      ret.data.opt.len = (size_t)(p - ret.data.opt.name);
+      if (ret.data.opt.len == 0) {
         OPTNAMEMISS(ret);
-        break;
-      }
-      ret.type = kExprLexOption;
-      if (pline.size > 2
-          && pline.data[2] == ':'
-          && memchr(EXPR_OPT_SCOPE_LIST, pline.data[1],
-                    sizeof(EXPR_OPT_SCOPE_LIST)) != NULL) {
-        ret.len += 2;
-        ret.data.opt.scope = (ExprOptScope)pline.data[1];
-        ret.data.opt.name = pline.data + 3;
       } else {
-        ret.data.opt.scope = kExprOptScopeUnspecified;
-        ret.data.opt.name = pline.data + 1;
-      }
-      const char *p = ret.data.opt.name;
-      const char *const e = pline.data + pline.size;
-      if (e - p >= 4 && p[0] == 't' && p[1] == '_') {
-        ret.data.opt.len = 4;
-        ret.len += 4;
-      } else {
-        for (; p < e && ASCII_ISALPHA(*p); p++) {
-        }
-        ret.data.opt.len = (size_t)(p - ret.data.opt.name);
-        if (ret.data.opt.len == 0) {
-          OPTNAMEMISS(ret);
-        } else {
-          ret.len += ret.data.opt.len;
-        }
+        ret.len += ret.data.opt.len;
       }
-      break;
-#undef OPTNAMEMISS
     }
+    break;
+#undef OPTNAMEMISS
+  }
 
-    // Register.
-    case '@': {
-      ret.type = kExprLexRegister;
-      if (pline.size > 1) {
-        ret.len++;
-        ret.data.reg.name = (uint8_t)pline.data[1];
-      } else {
-        ret.data.reg.name = -1;
-      }
-      break;
+  // Register.
+  case '@':
+    ret.type = kExprLexRegister;
+    if (pline.size > 1) {
+      ret.len++;
+      ret.data.reg.name = (uint8_t)pline.data[1];
+    } else {
+      ret.data.reg.name = -1;
     }
-
-    // Single quoted string.
-    case '\'': {
-      ret.type = kExprLexSingleQuotedString;
-      ret.data.str.closed = false;
-      for (; ret.len < pline.size && !ret.data.str.closed; ret.len++) {
-        if (pline.data[ret.len] == '\'') {
-          if (ret.len + 1 < pline.size && pline.data[ret.len + 1] == '\'') {
-            ret.len++;
-          } else {
-            ret.data.str.closed = true;
-          }
+    break;
+
+  // Single quoted string.
+  case '\'':
+    ret.type = kExprLexSingleQuotedString;
+    ret.data.str.closed = false;
+    for (; ret.len < pline.size && !ret.data.str.closed; ret.len++) {
+      if (pline.data[ret.len] == '\'') {
+        if (ret.len + 1 < pline.size && pline.data[ret.len + 1] == '\'') {
+          ret.len++;
+        } else {
+          ret.data.str.closed = true;
         }
       }
-      break;
     }
-
-    // Double quoted string.
-    case '"': {
-      ret.type = kExprLexDoubleQuotedString;
-      ret.data.str.closed = false;
-      for (; ret.len < pline.size && !ret.data.str.closed; ret.len++) {
-        if (pline.data[ret.len] == '\\') {
-          if (ret.len + 1 < pline.size) {
-            ret.len++;
-          }
-        } else if (pline.data[ret.len] == '"') {
-          ret.data.str.closed = true;
+    break;
+
+  // Double quoted string.
+  case '"':
+    ret.type = kExprLexDoubleQuotedString;
+    ret.data.str.closed = false;
+    for (; ret.len < pline.size && !ret.data.str.closed; ret.len++) {
+      if (pline.data[ret.len] == '\\') {
+        if (ret.len + 1 < pline.size) {
+          ret.len++;
         }
+      } else if (pline.data[ret.len] == '"') {
+        ret.data.str.closed = true;
       }
-      break;
     }
-
-    // Unary not, (un)equality and regex (not) match comparison operators.
-    case '!':
-    case '=': {
-      if (pline.size == 1) {
-        ret.type = (schar == '!' ? kExprLexNot : kExprLexAssignment);
-        ret.data.ass.type = kExprAsgnPlain;
-        break;
-      }
-      ret.type = kExprLexComparison;
-      ret.data.cmp.inv = (schar == '!');
-      if (pline.data[1] == '=') {
-        ret.data.cmp.type = kExprCmpEqual;
-        ret.len++;
-      } else if (pline.data[1] == '~') {
-        ret.data.cmp.type = kExprCmpMatches;
-        ret.len++;
-      } else if (schar == '!') {
-        ret.type = kExprLexNot;
-      } else {
-        ret.type = kExprLexAssignment;
-        ret.data.ass.type = kExprAsgnPlain;
-      }
-      GET_CCS(ret, pline);
+    break;
+
+  // Unary not, (un)equality and regex (not) match comparison operators.
+  case '!':
+  case '=':
+    if (pline.size == 1) {
+      ret.type = (schar == '!' ? kExprLexNot : kExprLexAssignment);
+      ret.data.ass.type = kExprAsgnPlain;
       break;
     }
-
-    // Less/greater [or equal to] comparison operators.
-    case '>':
-    case '<': {
-      ret.type = kExprLexComparison;
-      const bool haseqsign = (pline.size > 1 && pline.data[1] == '=');
-      if (haseqsign) {
-        ret.len++;
-      }
-      GET_CCS(ret, pline);
-      ret.data.cmp.inv = (schar == '<');
-      ret.data.cmp.type = ((ret.data.cmp.inv ^ haseqsign)
+    ret.type = kExprLexComparison;
+    ret.data.cmp.inv = (schar == '!');
+    if (pline.data[1] == '=') {
+      ret.data.cmp.type = kExprCmpEqual;
+      ret.len++;
+    } else if (pline.data[1] == '~') {
+      ret.data.cmp.type = kExprCmpMatches;
+      ret.len++;
+    } else if (schar == '!') {
+      ret.type = kExprLexNot;
+    } else {
+      ret.type = kExprLexAssignment;
+      ret.data.ass.type = kExprAsgnPlain;
+    }
+    GET_CCS(ret, pline);
+    break;
+
+  // Less/greater [or equal to] comparison operators.
+  case '>':
+  case '<': {
+    ret.type = kExprLexComparison;
+    const bool haseqsign = (pline.size > 1 && pline.data[1] == '=');
+    if (haseqsign) {
+      ret.len++;
+    }
+    GET_CCS(ret, pline);
+    ret.data.cmp.inv = (schar == '<');
+    ret.data.cmp.type = ((ret.data.cmp.inv ^ haseqsign)
                            ? kExprCmpGreaterOrEqual
                            : kExprCmpGreater);
-      break;
-    }
+    break;
+  }
 
-    // Minus sign, arrow from lambdas or augmented assignment.
-    case '-': {
-      if (pline.size > 1 && pline.data[1] == '>') {
-        ret.len++;
-        ret.type = kExprLexArrow;
-      } else if (pline.size > 1 && pline.data[1] == '=') {
-        ret.len++;
-        ret.type = kExprLexAssignment;
-        ret.data.ass.type = kExprAsgnSubtract;
-      } else {
-        ret.type = kExprLexMinus;
-      }
-      break;
+  // Minus sign, arrow from lambdas or augmented assignment.
+  case '-': {
+    if (pline.size > 1 && pline.data[1] == '>') {
+      ret.len++;
+      ret.type = kExprLexArrow;
+    } else if (pline.size > 1 && pline.data[1] == '=') {
+      ret.len++;
+      ret.type = kExprLexAssignment;
+      ret.data.ass.type = kExprAsgnSubtract;
+    } else {
+      ret.type = kExprLexMinus;
     }
+    break;
+  }
 
     // Sign or augmented assignment.
 #define CHAR_OR_ASSIGN(ch, ch_type, ass_type) \
-    case ch: { \
-      if (pline.size > 1 && pline.data[1] == '=') { \
-        ret.len++; \
-        ret.type = kExprLexAssignment; \
-        ret.data.ass.type = ass_type; \
-      } else { \
-        ret.type = ch_type; \
-      } \
-      break; \
-    }
+case ch: { \
+  if (pline.size > 1 && pline.data[1] == '=') { \
+    ret.len++; \
+    ret.type = kExprLexAssignment; \
+    ret.data.ass.type = ass_type; \
+  } else { \
+    ret.type = ch_type; \
+  } \
+  break; \
+}
     CHAR_OR_ASSIGN('+', kExprLexPlus, kExprAsgnAdd)
     CHAR_OR_ASSIGN('.', kExprLexDot, kExprAsgnConcat)
 #undef CHAR_OR_ASSIGN
 
-    // Expression end because Ex command ended.
-    case NUL:
-    case NL: {
-      if (flags & kELFlagForbidEOC) {
-        ret.type = kExprLexInvalid;
-        ret.data.err.msg = _("E15: Unexpected EOC character: %.*s");
-        ret.data.err.type = kExprLexSpacing;
-      } else {
-        ret.type = kExprLexEOC;
-      }
-      break;
-    }
-
-    case '|': {
-      if (pline.size >= 2 && pline.data[ret.len] == '|') {
-        // "||" is or.
-        ret.len++;
-        ret.type = kExprLexOr;
-      } else if (flags & kELFlagForbidEOC) {
-        // Note: `<C-r>=1 | 2<CR>` actually yields 1 in Vim without any
-        //       errors. This will be changed here.
-        ret.type = kExprLexInvalid;
-        ret.data.err.msg = _("E15: Unexpected EOC character: %.*s");
-        ret.data.err.type = kExprLexOr;
-      } else {
-        ret.type = kExprLexEOC;
-      }
-      break;
+  // Expression end because Ex command ended.
+  case NUL:
+  case NL:
+    if (flags & kELFlagForbidEOC) {
+      ret.type = kExprLexInvalid;
+      ret.data.err.msg = _("E15: Unexpected EOC character: %.*s");
+      ret.data.err.type = kExprLexSpacing;
+    } else {
+      ret.type = kExprLexEOC;
     }
-
-    // Everything else is not valid.
-    default: {
-      ret.len = (size_t)utfc_ptr2len_len((const char_u *)pline.data,
-                                         (int)pline.size);
+    break;
+
+  case '|':
+    if (pline.size >= 2 && pline.data[ret.len] == '|') {
+      // "||" is or.
+      ret.len++;
+      ret.type = kExprLexOr;
+    } else if (flags & kELFlagForbidEOC) {
+      // Note: `<C-r>=1 | 2<CR>` actually yields 1 in Vim without any
+      //       errors. This will be changed here.
       ret.type = kExprLexInvalid;
-      ret.data.err.type = kExprLexPlainIdentifier;
-      ret.data.err.msg = _("E15: Unidentified character: %.*s");
-      break;
+      ret.data.err.msg = _("E15: Unexpected EOC character: %.*s");
+      ret.data.err.type = kExprLexOr;
+    } else {
+      ret.type = kExprLexEOC;
     }
+    break;
+
+  // Everything else is not valid.
+  default:
+    ret.len = (size_t)utfc_ptr2len_len((const char_u *)pline.data,
+                                       (int)pline.size);
+    ret.type = kExprLexInvalid;
+    ret.data.err.type = kExprLexPlainIdentifier;
+    ret.data.err.msg = _("E15: Unidentified character: %.*s");
+    break;
   }
 #undef GET_CCS
 viml_pexpr_next_token_adv_return:
@@ -737,8 +793,7 @@ static const char *const eltkn_opt_scope_tab[] = {
 ///
 /// @return Token represented in a string form, in a static buffer (overwritten
 ///         on each call).
-const char *viml_pexpr_repr_token(const ParserState *const pstate,
-                                  const LexExprToken token,
+const char *viml_pexpr_repr_token(const ParserState *const pstate, const LexExprToken token,
                                   size_t *const ret_size)
   FUNC_ATTR_WARN_UNUSED_RESULT
 {
@@ -756,10 +811,10 @@ const char *viml_pexpr_repr_token(const ParserState *const pstate,
          eltkn_type_tab[token.type]);
   switch (token.type) {
 #define TKNARGS(tkn_type, ...) \
-    case tkn_type: { \
-      ADDSTR(__VA_ARGS__); \
-      break; \
-    }
+case tkn_type: { \
+  ADDSTR(__VA_ARGS__); \
+  break; \
+}
     TKNARGS(kExprLexComparison, "(type=%s,ccs=%s,inv=%i)",
             eltkn_cmp_type_tab[token.data.cmp.type],
             ccs_tab[token.data.cmp.ccs],
@@ -769,7 +824,7 @@ const char *viml_pexpr_repr_token(const ParserState *const pstate,
     TKNARGS(kExprLexAssignment, "(type=%s)",
             expr_asgn_type_tab[token.data.ass.type])
     TKNARGS(kExprLexRegister, "(name=%s)", intchar2str(token.data.reg.name))
-    case kExprLexDoubleQuotedString:
+  case kExprLexDoubleQuotedString:
     TKNARGS(kExprLexSingleQuotedString, "(closed=%i)",
             (int)token.data.str.closed)
     TKNARGS(kExprLexOption, "(scope=%s,name=%.*s)",
@@ -785,19 +840,17 @@ const char *viml_pexpr_repr_token(const ParserState *const pstate,
                      ? (double)token.data.num.val.floating
                      : (double)token.data.num.val.integer))
     TKNARGS(kExprLexInvalid, "(msg=%s)", token.data.err.msg)
-    default: {
-      // No additional arguments.
-      break;
-    }
+  default:
+    // No additional arguments.
+    break;
 #undef TKNARGS
   }
   if (pstate == NULL) {
     ADDSTR("::%zu", token.len);
   } else {
     *p++ = ':';
-    memmove(
-        p, &pstate->reader.lines.items[token.start.line].data[token.start.col],
-        token.len);
+    memmove(p, &pstate->reader.lines.items[token.start.line].data[token.start.col],
+            token.len);
     p += token.len;
     *p = NUL;
   }
@@ -886,9 +939,8 @@ static const char *intchar2str(const int ch)
 #include <stdio.h>
 
 REAL_FATTR_UNUSED
-static inline void viml_pexpr_debug_print_ast_node(
-    const ExprASTNode *const *const eastnode_p,
-    const char *const prefix)
+static inline void viml_pexpr_debug_print_ast_node(const ExprASTNode *const *const eastnode_p,
+                                                   const char *const prefix)
 {
   if (*eastnode_p == NULL) {
     fprintf(stderr, "%s %p : NULL\n", prefix, (void *)eastnode_p);
@@ -901,35 +953,33 @@ static inline void viml_pexpr_debug_print_ast_node(
 }
 
 REAL_FATTR_UNUSED
-static inline void viml_pexpr_debug_print_ast_stack(
-    const ExprASTStack *const ast_stack,
-    const char *const msg)
+static inline void viml_pexpr_debug_print_ast_stack(const ExprASTStack *const ast_stack,
+                                                    const char *const msg)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_ALWAYS_INLINE
 {
   fprintf(stderr, "\n%sstack: %zu:\n", msg, kv_size(*ast_stack));
   for (size_t i = 0; i < kv_size(*ast_stack); i++) {
-    viml_pexpr_debug_print_ast_node(
-        (const ExprASTNode *const *)kv_A(*ast_stack, i),
-        "-");
+    viml_pexpr_debug_print_ast_node((const ExprASTNode *const *)kv_A(*ast_stack, i),
+                                    "-");
   }
 }
 
 REAL_FATTR_UNUSED
-static inline void viml_pexpr_debug_print_token(
-    const ParserState *const pstate, const LexExprToken token)
+static inline void viml_pexpr_debug_print_token(const ParserState *const pstate,
+                                                const LexExprToken token)
   FUNC_ATTR_ALWAYS_INLINE
 {
   fprintf(stderr, "\ntkn: %s\n", viml_pexpr_repr_token(pstate, token, NULL));
 }
 #define PSTACK(msg) \
-    viml_pexpr_debug_print_ast_stack(&ast_stack, #msg)
+  viml_pexpr_debug_print_ast_stack(&ast_stack, #msg)
 #define PSTACK_P(msg) \
-    viml_pexpr_debug_print_ast_stack(ast_stack, #msg)
+  viml_pexpr_debug_print_ast_stack(ast_stack, #msg)
 #define PNODE_P(eastnode_p, msg) \
-    viml_pexpr_debug_print_ast_node((const ExprASTNode *const *)eastnode_p, \
-                                    (#msg))
+  viml_pexpr_debug_print_ast_node((const ExprASTNode *const *)eastnode_p, \
+                                  (#msg))
 #define PTOKEN(tkn) \
-    viml_pexpr_debug_print_token(pstate, tkn)
+  viml_pexpr_debug_print_token(pstate, tkn)
 #endif
 
 const uint8_t node_maxchildren[] = {
@@ -1009,50 +1059,48 @@ void viml_pexpr_free_ast(ExprAST ast)
     } else if (*cur_node != NULL) {
       kv_drop(ast_stack, 1);
       switch ((*cur_node)->type) {
-        case kExprNodeDoubleQuotedString:
-        case kExprNodeSingleQuotedString: {
-          xfree((*cur_node)->data.str.value);
-          break;
-        }
-        case kExprNodeMissing:
-        case kExprNodeOpMissing:
-        case kExprNodeTernary:
-        case kExprNodeTernaryValue:
-        case kExprNodeRegister:
-        case kExprNodeSubscript:
-        case kExprNodeListLiteral:
-        case kExprNodeUnaryPlus:
-        case kExprNodeBinaryPlus:
-        case kExprNodeNested:
-        case kExprNodeCall:
-        case kExprNodePlainIdentifier:
-        case kExprNodePlainKey:
-        case kExprNodeComplexIdentifier:
-        case kExprNodeUnknownFigure:
-        case kExprNodeLambda:
-        case kExprNodeDictLiteral:
-        case kExprNodeCurlyBracesIdentifier:
-        case kExprNodeAssignment:
-        case kExprNodeComma:
-        case kExprNodeColon:
-        case kExprNodeArrow:
-        case kExprNodeComparison:
-        case kExprNodeConcat:
-        case kExprNodeConcatOrSubscript:
-        case kExprNodeInteger:
-        case kExprNodeFloat:
-        case kExprNodeOr:
-        case kExprNodeAnd:
-        case kExprNodeUnaryMinus:
-        case kExprNodeBinaryMinus:
-        case kExprNodeNot:
-        case kExprNodeMultiplication:
-        case kExprNodeDivision:
-        case kExprNodeMod:
-        case kExprNodeOption:
-        case kExprNodeEnvironment: {
-          break;
-        }
+      case kExprNodeDoubleQuotedString:
+      case kExprNodeSingleQuotedString:
+        xfree((*cur_node)->data.str.value);
+        break;
+      case kExprNodeMissing:
+      case kExprNodeOpMissing:
+      case kExprNodeTernary:
+      case kExprNodeTernaryValue:
+      case kExprNodeRegister:
+      case kExprNodeSubscript:
+      case kExprNodeListLiteral:
+      case kExprNodeUnaryPlus:
+      case kExprNodeBinaryPlus:
+      case kExprNodeNested:
+      case kExprNodeCall:
+      case kExprNodePlainIdentifier:
+      case kExprNodePlainKey:
+      case kExprNodeComplexIdentifier:
+      case kExprNodeUnknownFigure:
+      case kExprNodeLambda:
+      case kExprNodeDictLiteral:
+      case kExprNodeCurlyBracesIdentifier:
+      case kExprNodeAssignment:
+      case kExprNodeComma:
+      case kExprNodeColon:
+      case kExprNodeArrow:
+      case kExprNodeComparison:
+      case kExprNodeConcat:
+      case kExprNodeConcatOrSubscript:
+      case kExprNodeInteger:
+      case kExprNodeFloat:
+      case kExprNodeOr:
+      case kExprNodeAnd:
+      case kExprNodeUnaryMinus:
+      case kExprNodeBinaryMinus:
+      case kExprNodeNot:
+      case kExprNodeMultiplication:
+      case kExprNodeDivision:
+      case kExprNodeMod:
+      case kExprNodeOption:
+      case kExprNodeEnvironment:
+        break;
       }
       xfree(*cur_node);
       *cur_node = NULL;
@@ -1204,10 +1252,8 @@ static inline ExprOpAssociativity node_ass(const ExprASTNode node)
 /// @param[out]  ast_err  Location where error is saved, if any.
 ///
 /// @return True if no errors occurred, false otherwise.
-static bool viml_pexpr_handle_bop(const ParserState *const pstate,
-                                  ExprASTStack *const ast_stack,
-                                  ExprASTNode *const bop_node,
-                                  ExprASTWantedNode *const want_node_p,
+static bool viml_pexpr_handle_bop(const ParserState *const pstate, ExprASTStack *const ast_stack,
+                                  ExprASTNode *const bop_node, ExprASTWantedNode *const want_node_p,
                                   ExprASTError *const ast_err)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -1223,8 +1269,8 @@ static bool viml_pexpr_handle_bop(const ParserState *const pstate,
                                   : node_lvl(*bop_node));
 #ifndef NDEBUG
   const ExprOpAssociativity bop_node_ass = (
-      (bop_node->type == kExprNodeCall
-       || bop_node->type == kExprNodeSubscript)
+                                            (bop_node->type == kExprNodeCall
+                                             || bop_node->type == kExprNodeSubscript)
       ? kEOpAssLeft
       : node_ass(*bop_node));
 #endif
@@ -1301,8 +1347,7 @@ static bool viml_pexpr_handle_bop(const ParserState *const pstate,
 /// @param[in]  shift  Number of bytes to shift.
 ///
 /// @return Shifted position.
-static inline ParserPosition shifted_pos(const ParserPosition pos,
-                                         const size_t shift)
+static inline ParserPosition shifted_pos(const ParserPosition pos, const size_t shift)
   FUNC_ATTR_CONST FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_WARN_UNUSED_RESULT
 {
   return (ParserPosition) { .line = pos.line, .col = pos.col + shift };
@@ -1316,8 +1361,7 @@ static inline ParserPosition shifted_pos(const ParserPosition pos,
 /// @param[in]  new_col  New column.
 ///
 /// @return Shifted position.
-static inline ParserPosition recol_pos(const ParserPosition pos,
-                                       const size_t new_col)
+static inline ParserPosition recol_pos(const ParserPosition pos, const size_t new_col)
   FUNC_ATTR_CONST FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_WARN_UNUSED_RESULT
 {
   return (ParserPosition) { .line = pos.line, .col = new_col };
@@ -1328,22 +1372,22 @@ static inline ParserPosition recol_pos(const ParserPosition pos,
 
 /// Highlight current token with the given group
 #define HL_CUR_TOKEN(g) \
-        viml_parser_highlight(pstate, cur_token.start, cur_token.len, \
-                              HL(g))
+  viml_parser_highlight(pstate, cur_token.start, cur_token.len, \
+                        HL(g))
 
 /// Allocate new node, saving some values
 #define NEW_NODE(type) \
-    viml_pexpr_new_node(type)
+  viml_pexpr_new_node(type)
 
 /// Set position of the given node to position from the given token
 ///
 /// @param  cur_node  Node to modify.
 /// @param  cur_token  Token to set position from.
 #define POS_FROM_TOKEN(cur_node, cur_token) \
-    do { \
-      (cur_node)->start = cur_token.start; \
-      (cur_node)->len = cur_token.len; \
-    } while (0)
+  do { \
+    (cur_node)->start = cur_token.start; \
+    (cur_node)->len = cur_token.len; \
+  } while (0)
 
 /// Allocate new node and set its position from the current token
 ///
@@ -1352,27 +1396,27 @@ static inline ParserPosition recol_pos(const ParserPosition pos,
 /// @param  cur_node  Variable to save allocated node to.
 /// @param  typ  Node type.
 #define NEW_NODE_WITH_CUR_POS(cur_node, typ) \
-    do { \
-      (cur_node) = NEW_NODE(typ); \
-      POS_FROM_TOKEN((cur_node), cur_token); \
-      if (prev_token.type == kExprLexSpacing) { \
-        (cur_node)->start = prev_token.start; \
-        (cur_node)->len += prev_token.len; \
-      } \
-    } while (0)
+  do { \
+    (cur_node) = NEW_NODE(typ); \
+    POS_FROM_TOKEN((cur_node), cur_token); \
+    if (prev_token.type == kExprLexSpacing) { \
+      (cur_node)->start = prev_token.start; \
+      (cur_node)->len += prev_token.len; \
+    } \
+  } while (0)
 
 /// Check whether it is possible to have next expression after current
 ///
 /// For :echo: `:echo @a @a` is a valid expression. `:echo (@a @a)` is not.
 #define MAY_HAVE_NEXT_EXPR \
-    (kv_size(ast_stack) == 1)
+  (kv_size(ast_stack) == 1)
 
 /// Add operator node
 ///
 /// @param[in]  cur_node  Node to add.
 #define ADD_OP_NODE(cur_node) \
-    is_invalid |= !viml_pexpr_handle_bop(pstate, &ast_stack, cur_node, \
-                                         &want_node, &ast.err)
+  is_invalid |= !viml_pexpr_handle_bop(pstate, &ast_stack, cur_node, \
+                                       &want_node, &ast.err)
 
 /// Record missing operator: for things like
 ///
@@ -1384,33 +1428,33 @@ static inline ParserPosition recol_pos(const ParserPosition pos,
 ///
 /// (parsed as OpMissing(@a, @a)).
 #define OP_MISSING \
-    do { \
-      if (flags & kExprFlagsMulti && MAY_HAVE_NEXT_EXPR) { \
-        /* Multiple expressions allowed, return without calling */ \
-        /* viml_parser_advance(). */ \
-        goto viml_pexpr_parse_end; \
-      } else { \
-        assert(*top_node_p != NULL); \
-        ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Missing operator: %.*s")); \
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeOpMissing); \
-        cur_node->len = 0; \
-        ADD_OP_NODE(cur_node); \
-        goto viml_pexpr_parse_process_token; \
-      } \
-    } while (0)
+  do { \
+    if (flags & kExprFlagsMulti && MAY_HAVE_NEXT_EXPR) { \
+      /* Multiple expressions allowed, return without calling */ \
+      /* viml_parser_advance(). */ \
+      goto viml_pexpr_parse_end; \
+    } else { \
+      assert(*top_node_p != NULL); \
+      ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Missing operator: %.*s")); \
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeOpMissing); \
+      cur_node->len = 0; \
+      ADD_OP_NODE(cur_node); \
+      goto viml_pexpr_parse_process_token; \
+    } \
+  } while (0)
 
 /// Record missing value: for things like "* 5"
 ///
 /// @param[in]  msg  Error message.
 #define ADD_VALUE_IF_MISSING(msg) \
-        do { \
-          if (want_node == kENodeValue) { \
-            ERROR_FROM_TOKEN_AND_MSG(cur_token, (msg)); \
-            NEW_NODE_WITH_CUR_POS((*top_node_p), kExprNodeMissing); \
-            (*top_node_p)->len = 0; \
-            want_node = kENodeOperator; \
-          } \
-        } while (0)
+  do { \
+    if (want_node == kENodeValue) { \
+      ERROR_FROM_TOKEN_AND_MSG(cur_token, (msg)); \
+      NEW_NODE_WITH_CUR_POS((*top_node_p), kExprNodeMissing); \
+      (*top_node_p)->len = 0; \
+      want_node = kENodeOperator; \
+    } \
+  } while (0)
 
 /// Set AST error, unless AST already is not correct
 ///
@@ -1419,10 +1463,8 @@ static inline ParserPosition recol_pos(const ParserPosition pos,
 /// @param[in]  msg  Error message, assumed to be already translated and
 ///                  containing a single %token "%.*s".
 /// @param[in]  start  Position at which error occurred.
-static inline void east_set_error(const ParserState *const pstate,
-                                  ExprASTError *const ret_ast_err,
-                                  const char *const msg,
-                                  const ParserPosition start)
+static inline void east_set_error(const ParserState *const pstate, ExprASTError *const ret_ast_err,
+                                  const char *const msg, const ParserPosition start)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_ALWAYS_INLINE
 {
   if (ret_ast_err->msg != NULL) {
@@ -1436,21 +1478,21 @@ static inline void east_set_error(const ParserState *const pstate,
 
 /// Set error from the given token and given message
 #define ERROR_FROM_TOKEN_AND_MSG(cur_token, msg) \
-    do { \
-      is_invalid = true; \
-      east_set_error(pstate, &ast.err, msg, cur_token.start); \
-    } while (0)
+  do { \
+    is_invalid = true; \
+    east_set_error(pstate, &ast.err, msg, cur_token.start); \
+  } while (0)
 
 /// Like #ERROR_FROM_TOKEN_AND_MSG, but gets position from a node
 #define ERROR_FROM_NODE_AND_MSG(node, msg) \
-    do { \
-      is_invalid = true; \
-      east_set_error(pstate, &ast.err, msg, node->start); \
-    } while (0)
+  do { \
+    is_invalid = true; \
+    east_set_error(pstate, &ast.err, msg, node->start); \
+  } while (0)
 
 /// Set error from the given kExprLexInvalid token
 #define ERROR_FROM_TOKEN(cur_token) \
-    ERROR_FROM_TOKEN_AND_MSG(cur_token, cur_token.data.err.msg)
+  ERROR_FROM_TOKEN_AND_MSG(cur_token, cur_token.data.err.msg)
 
 /// Select figure brace type, altering highlighting as well if needed
 ///
@@ -1459,16 +1501,16 @@ static inline void east_set_error(const ParserState *const pstate,
 ///                       kExprNode prefix.
 /// @param[in]  hl  Corresponding highlighting, passed as an argument to #HL.
 #define SELECT_FIGURE_BRACE_TYPE(node, new_type, hl) \
-    do { \
-      ExprASTNode *const node_ = (node); \
-      assert(node_->type == kExprNodeUnknownFigure \
-             || node_->type == kExprNode##new_type); \
-      node_->type = kExprNode##new_type; \
-      if (pstate->colors) { \
-        kv_A(*pstate->colors, node_->data.fig.opening_hl_idx).group = \
-             HL(hl); \
-      } \
-    } while (0)
+  do { \
+    ExprASTNode *const node_ = (node); \
+    assert(node_->type == kExprNodeUnknownFigure \
+           || node_->type == kExprNode##new_type); \
+    node_->type = kExprNode##new_type; \
+    if (pstate->colors) { \
+      kv_A(*pstate->colors, node_->data.fig.opening_hl_idx).group = \
+        HL(hl); \
+    } \
+  } while (0)
 
 /// Add identifier which should constitute complex identifier node
 ///
@@ -1479,45 +1521,45 @@ static inline void east_set_error(const ParserState *const pstate,
 ///                              a trailing semicolon.
 /// @param  hl  Highlighting name to use, passed as an argument to #HL.
 #define ADD_IDENT(new_ident_node_code, hl) \
-    do { \
-      assert(want_node == kENodeOperator); \
-      /* Operator: may only be curly braces name, but only under certain */ \
-      /* conditions. */ \
+  do { \
+    assert(want_node == kENodeOperator); \
+    /* Operator: may only be curly braces name, but only under certain */ \
+    /* conditions. */ \
 \
-      /* First condition is that there is no space before a part of complex */ \
-      /* identifier. */ \
-      if (prev_token.type == kExprLexSpacing) { \
-        OP_MISSING; \
-      } \
-      switch ((*top_node_p)->type) { \
-        /* Second is that previous node is one of the identifiers: */ \
-        /* complex, plain, curly braces. */ \
+    /* First condition is that there is no space before a part of complex */ \
+    /* identifier. */ \
+    if (prev_token.type == kExprLexSpacing) { \
+      OP_MISSING; \
+    } \
+    switch ((*top_node_p)->type) { \
+    /* Second is that previous node is one of the identifiers: */ \
+    /* complex, plain, curly braces. */ \
 \
-        /* TODO(ZyX-I): Extend syntax to allow ${expr}. This is needed to */ \
-        /* handle environment variables like those bash uses for */ \
-        /* `export -f`: their names consist not only of alphanumeric */ \
-        /* characetrs. */ \
-        case kExprNodeComplexIdentifier: \
-        case kExprNodePlainIdentifier: \
-        case kExprNodeCurlyBracesIdentifier: { \
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeComplexIdentifier); \
-          cur_node->len = 0; \
-          cur_node->children = *top_node_p; \
-          *top_node_p = cur_node; \
-          kvi_push(ast_stack, &cur_node->children->next); \
-          ExprASTNode **const new_top_node_p = kv_last(ast_stack); \
-          assert(*new_top_node_p == NULL); \
-          new_ident_node_code; \
-          *new_top_node_p = cur_node; \
-          HL_CUR_TOKEN(hl); \
-          break; \
-        } \
-        default: { \
-          OP_MISSING; \
-          break; \
-        } \
-      } \
-    } while (0)
+    /* TODO(ZyX-I): Extend syntax to allow ${expr}. This is needed to */ \
+    /* handle environment variables like those bash uses for */ \
+    /* `export -f`: their names consist not only of alphanumeric */ \
+    /* characetrs. */ \
+    case kExprNodeComplexIdentifier: \
+    case kExprNodePlainIdentifier: \
+    case kExprNodeCurlyBracesIdentifier: { \
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeComplexIdentifier); \
+      cur_node->len = 0; \
+      cur_node->children = *top_node_p; \
+      *top_node_p = cur_node; \
+      kvi_push(ast_stack, &cur_node->children->next); \
+      ExprASTNode **const new_top_node_p = kv_last(ast_stack); \
+      assert(*new_top_node_p == NULL); \
+      new_ident_node_code; \
+      *new_top_node_p = cur_node; \
+      HL_CUR_TOKEN(hl); \
+      break; \
+    } \
+    default: { \
+      OP_MISSING; \
+      break; \
+    } \
+    } \
+  } while (0)
 
 /// Determine whether given parse type is an assignment
 ///
@@ -1551,10 +1593,8 @@ typedef struct {
 /// @param[in]  ast_stack  Parser AST stack, used to detect whether current
 ///                        string is a regex.
 /// @param[in]  is_invalid  Whether currently processed token is not valid.
-static void parse_quoted_string(ParserState *const pstate,
-                                ExprASTNode *const node,
-                                const LexExprToken token,
-                                const ExprASTStack ast_stack,
+static void parse_quoted_string(ParserState *const pstate, ExprASTNode *const node,
+                                const LexExprToken token, const ExprASTStack ast_stack,
                                 const bool is_invalid)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -1577,10 +1617,10 @@ static void parse_quoted_string(ParserState *const pstate,
       p = chunk_e + 2;
       if (pstate->colors) {
         kvi_push(shifts, ((StringShift) {
-            .start = token.start.col + (size_t)(chunk_e - s),
-            .orig_len = 2,
-            .act_len = 1,
-            .escape_not_known = false,
+          .start = token.start.col + (size_t)(chunk_e - s),
+          .orig_len = 2,
+          .act_len = 1,
+          .escape_not_known = false,
         }));
       }
     }
@@ -1613,70 +1653,74 @@ static void parse_quoted_string(ParserState *const pstate,
           break;
         }
         switch (*p) {
-          // A "\<x>" form occupies at least 4 characters, and produces up to
-          // 6 characters: reserve space for 2 extra, but do not compute actual
-          // length just now, it would be costy.
-          case '<': {
-            size += 2;
-            break;
-          }
-          // Hexadecimal, always single byte, but at least three bytes each.
-          case 'x': case 'X': {
+        // A "\<x>" form occupies at least 4 characters, and produces up to
+        // 6 characters: reserve space for 2 extra, but do not compute actual
+        // length just now, it would be costy.
+        case '<':
+          size += 2;
+          break;
+        // Hexadecimal, always single byte, but at least three bytes each.
+        case 'x':
+        case 'X':
+          size--;
+          if (ascii_isxdigit(p[1])) {
             size--;
-            if (ascii_isxdigit(p[1])) {
+            if (p + 2 < e && ascii_isxdigit(p[2])) {
               size--;
-              if (p + 2 < e && ascii_isxdigit(p[2])) {
-                size--;
-              }
             }
-            break;
           }
-          // Unicode
-          //
-          // \uF takes 1 byte which is 2 bytes less then escape sequence.
-          // \uFF: 2 bytes, 2 bytes less.
-          // \uFFF: 3 bytes, 2 bytes less.
-          // \uFFFF: 3 bytes, 3 bytes less.
-          // \UFFFFF: 4 bytes, 3 bytes less.
-          // \UFFFFFF: 5 bytes, 3 bytes less.
-          // \UFFFFFFF: 6 bytes, 3 bytes less.
-          // \U7FFFFFFF: 6 bytes, 4 bytes less.
-          case 'u': case 'U': {
-            const char *const esc_start = p;
-            size_t n = (*p == 'u' ? 4 : 8);
-            int nr = 0;
+          break;
+        // Unicode
+        //
+        // \uF takes 1 byte which is 2 bytes less then escape sequence.
+        // \uFF: 2 bytes, 2 bytes less.
+        // \uFFF: 3 bytes, 2 bytes less.
+        // \uFFFF: 3 bytes, 3 bytes less.
+        // \UFFFFF: 4 bytes, 3 bytes less.
+        // \UFFFFFF: 5 bytes, 3 bytes less.
+        // \UFFFFFFF: 6 bytes, 3 bytes less.
+        // \U7FFFFFFF: 6 bytes, 4 bytes less.
+        case 'u':
+        case 'U': {
+          const char *const esc_start = p;
+          size_t n = (*p == 'u' ? 4 : 8);
+          int nr = 0;
+          p++;
+          while (p + 1 < e && n-- && ascii_isxdigit(p[1])) {
             p++;
-            while (p + 1 < e && n-- && ascii_isxdigit(p[1])) {
-              p++;
-              nr = (nr << 4) + hex2nr(*p);
-            }
-            // Escape length: (esc_start - 1) points to "\\", esc_start to "u"
-            // or "U", p to the byte after last byte. So escape sequence
-            // occupies p - (esc_start - 1), but it stands for a utf_char2len
-            // bytes.
-            size -= (size_t)((p - (esc_start - 1)) - utf_char2len(nr));
-            p--;
-            break;
+            nr = (nr << 4) + hex2nr(*p);
           }
-          // Octal, always single byte, but at least two bytes each.
-          case '0': case '1': case '2': case '3': case '4': case '5': case '6':
-          case '7': {
+          // Escape length: (esc_start - 1) points to "\\", esc_start to "u"
+          // or "U", p to the byte after last byte. So escape sequence
+          // occupies p - (esc_start - 1), but it stands for a utf_char2len
+          // bytes.
+          size -= (size_t)((p - (esc_start - 1)) - utf_char2len(nr));
+          p--;
+          break;
+        }
+        // Octal, always single byte, but at least two bytes each.
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+          size--;
+          p++;
+          if (*p >= '0' && *p <= '7') {
             size--;
             p++;
-            if (*p >= '0' && *p <= '7') {
+            if (p < e && *p >= '0' && *p <= '7') {
               size--;
               p++;
-              if (p < e && *p >= '0' && *p <= '7') {
-                size--;
-                p++;
-              }
             }
-            break;
-          }
-          default: {
-            size--;
-            break;
           }
+          break;
+        default:
+          size--;
+          break;
         }
       }
     }
@@ -1705,11 +1749,11 @@ static void parse_quoted_string(ParserState *const pstate,
         const char *const v_p_start = v_p;
         switch (*p) {
 #define SINGLE_CHAR_ESC(ch, real_ch) \
-          case ch: { \
-            *v_p++ = real_ch; \
-            p++; \
-            break; \
-          }
+case ch: { \
+  *v_p++ = real_ch; \
+  p++; \
+  break; \
+}
           SINGLE_CHAR_ESC('b', BS)
           SINGLE_CHAR_ESC('e', ESC)
           SINGLE_CHAR_ESC('f', FF)
@@ -1720,76 +1764,83 @@ static void parse_quoted_string(ParserState *const pstate,
           SINGLE_CHAR_ESC('\\', '\\')
 #undef SINGLE_CHAR_ESC
 
-          // Hexadecimal or unicode.
-          case 'X': case 'x': case 'u': case 'U': {
-            if (p + 1 < e && ascii_isxdigit(p[1])) {
-              size_t n;
-              int nr;
-              bool is_hex = (*p == 'x' || *p == 'X');
-
-              if (is_hex) {
-                n = 2;
-              } else if (*p == 'u') {
-                n = 4;
-              } else {
-                n = 8;
-              }
-              nr = 0;
-              while (p + 1 < e && n-- && ascii_isxdigit(p[1])) {
-                p++;
-                nr = (nr << 4) + hex2nr(*p);
-              }
-              p++;
-              if (is_hex) {
-                *v_p++ = (char)nr;
-              } else {
-                v_p += utf_char2bytes(nr, (char_u *)v_p);
-              }
+        // Hexadecimal or unicode.
+        case 'X':
+        case 'x':
+        case 'u':
+        case 'U':
+          if (p + 1 < e && ascii_isxdigit(p[1])) {
+            size_t n;
+            int nr;
+            bool is_hex = (*p == 'x' || *p == 'X');
+
+            if (is_hex) {
+              n = 2;
+            } else if (*p == 'u') {
+              n = 4;
             } else {
-              is_unknown = true;
-              *v_p++ = *p;
+              n = 8;
+            }
+            nr = 0;
+            while (p + 1 < e && n-- && ascii_isxdigit(p[1])) {
               p++;
+              nr = (nr << 4) + hex2nr(*p);
+            }
+            p++;
+            if (is_hex) {
+              *v_p++ = (char)nr;
+            } else {
+              v_p += utf_char2bytes(nr, (char_u *)v_p);
             }
-            break;
+          } else {
+            is_unknown = true;
+            *v_p++ = *p;
+            p++;
           }
-          // Octal: "\1", "\12", "\123".
-          case '0': case '1': case '2': case '3': case '4': case '5': case '6':
-          case '7': {
-            uint8_t ch = (uint8_t)(*p++ - '0');
+          break;
+        // Octal: "\1", "\12", "\123".
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7': {
+          uint8_t ch = (uint8_t)(*p++ - '0');
+          if (p < e && *p >= '0' && *p <= '7') {
+            ch = (uint8_t)((ch << 3) + *p++ - '0');
             if (p < e && *p >= '0' && *p <= '7') {
               ch = (uint8_t)((ch << 3) + *p++ - '0');
-              if (p < e && *p >= '0' && *p <= '7') {
-                ch = (uint8_t)((ch << 3) + *p++ - '0');
-              }
             }
-            *v_p++ = (char)ch;
-            break;
           }
-          // Special key, e.g.: "\<C-W>"
-          case '<': {
-            const size_t special_len = (
-                trans_special((const char_u **)&p, (size_t)(e - p),
-                              (char_u *)v_p, true, true));
-            if (special_len != 0) {
-              v_p += special_len;
-            } else {
-              is_unknown = true;
-              mb_copy_char((const char_u **)&p, (char_u **)&v_p);
-            }
-            break;
-          }
-          default: {
+          *v_p++ = (char)ch;
+          break;
+        }
+        // Special key, e.g.: "\<C-W>"
+        case '<': {
+          const size_t special_len = (
+                                      trans_special((const char_u **)&p, (size_t)(e - p),
+                                                    (char_u *)v_p, true, true));
+          if (special_len != 0) {
+            v_p += special_len;
+          } else {
             is_unknown = true;
             mb_copy_char((const char_u **)&p, (char_u **)&v_p);
-            break;
           }
+          break;
+        }
+        default:
+          is_unknown = true;
+          mb_copy_char((const char_u **)&p, (char_u **)&v_p);
+          break;
         }
         if (pstate->colors) {
           kvi_push(shifts, ((StringShift) {
-              .start = token.start.col + (size_t)(chunk_e - s),
-              .orig_len = (size_t)(p - chunk_e),
-              .act_len = (size_t)(v_p - (char *)v_p_start),
-              .escape_not_known = is_unknown,
+            .start = token.start.col + (size_t)(chunk_e - s),
+            .orig_len = (size_t)(p - chunk_e),
+            .act_len = (size_t)(v_p - (char *)v_p_start),
+            .escape_not_known = is_unknown,
           }));
         }
       }
@@ -1901,21 +1952,23 @@ ExprAST viml_pexpr_parse(ParserState *const pstate, const int flags)
   size_t asgn_level = 0;
   do {
     const bool is_concat_or_subscript = (
-        want_node == kENodeValue
-        && kv_size(ast_stack) > 1
-        && (*kv_Z(ast_stack, 1))->type == kExprNodeConcatOrSubscript);
+                                         want_node == kENodeValue
+                                         && kv_size(ast_stack) > 1
+                                         && (*kv_Z(ast_stack,
+                                                   1))->type == kExprNodeConcatOrSubscript);
     const int lexer_additional_flags = (
-        kELFlagPeek
-        | ((flags & kExprFlagsDisallowEOC) ? kELFlagForbidEOC : 0)
-        | ((want_node == kENodeValue
-            && (kv_size(ast_stack) == 1
-                || ((*kv_Z(ast_stack, 1))->type != kExprNodeConcat
-                    && ((*kv_Z(ast_stack, 1))->type
-                        != kExprNodeConcatOrSubscript))))
+                                        kELFlagPeek
+                                        | ((flags & kExprFlagsDisallowEOC) ? kELFlagForbidEOC : 0)
+                                        | ((want_node == kENodeValue
+                                            && (kv_size(ast_stack) == 1
+                                                || ((*kv_Z(ast_stack, 1))->type != kExprNodeConcat
+                                                    && ((*kv_Z(ast_stack, 1))->type
+                                                        != kExprNodeConcatOrSubscript))))
            ? kELFlagAllowFloat
            : 0));
-    LexExprToken cur_token = viml_pexpr_next_token(
-        pstate, want_node_to_lexer_flags[want_node] | lexer_additional_flags);
+    LexExprToken cur_token = viml_pexpr_next_token(pstate,
+                                                   want_node_to_lexer_flags[want_node] |
+                                                   lexer_additional_flags);
     if (cur_token.type == kExprLexEOC) {
       break;
     }
@@ -1924,8 +1977,8 @@ ExprAST viml_pexpr_parse(ParserState *const pstate, const int flags)
     bool is_invalid = token_invalid;
 viml_pexpr_parse_process_token:
     // May use different flags this time.
-    cur_token = viml_pexpr_next_token(
-        pstate, want_node_to_lexer_flags[want_node] | lexer_additional_flags);
+    cur_token = viml_pexpr_next_token(pstate,
+                                      want_node_to_lexer_flags[want_node] | lexer_additional_flags);
     if (tok_type == kExprLexSpacing) {
       if (is_invalid) {
         HL_CUR_TOKEN(Spacing);
@@ -1977,12 +2030,12 @@ viml_pexpr_parse_process_token:
     // for ternary and because concatenating dictionary with anything is not
     // valid. There are more cases when this will make a difference though.
     const bool node_is_key = (
-        is_concat_or_subscript
-        && (cur_token.type == kExprLexPlainIdentifier
+                              is_concat_or_subscript
+                              && (cur_token.type == kExprLexPlainIdentifier
             ? (!cur_token.data.var.autoload
                && cur_token.data.var.scope == kExprVarScopeMissing)
             : (cur_token.type == kExprLexNumber))
-        && prev_token.type != kExprLexSpacing);
+                              && prev_token.type != kExprLexSpacing);
     if (is_concat_or_subscript && !node_is_key) {
       // Note: in Vim "d. a" (this is the reason behind `prev_token.type !=
       // kExprLexSpacing` part of the condition) as well as any other "d.{expr}"
@@ -1997,951 +2050,896 @@ viml_pexpr_parse_process_token:
     // Pop some stack pt_stack items in case of misplaced nodes.
     const bool is_single_assignment = kv_last(pt_stack) == kEPTSingleAssignment;
     switch (kv_last(pt_stack)) {
-      case kEPTExpr: {
-        break;
-      }
-      case kEPTLambdaArguments: {
-        if ((want_node == kENodeOperator
-             && tok_type != kExprLexComma
-             && tok_type != kExprLexArrow)
-            || (want_node == kENodeValue
-                && !(cur_token.type == kExprLexPlainIdentifier
-                     && cur_token.data.var.scope == kExprVarScopeMissing
-                     && !cur_token.data.var.autoload)
-                && tok_type != kExprLexArrow)) {
-          lambda_node->data.fig.type_guesses.allow_lambda = false;
-          if (lambda_node->children != NULL
-              && lambda_node->children->type == kExprNodeComma) {
-            // If lambda has comma child this means that parser has already seen
-            // at least "{arg1,", so node cannot possibly be anything, but
-            // lambda.
-
-            // Vim may give E121 or E720 in this case, but it does not look
-            // right to have either because both are results of reevaluation
-            // possibly-lambda node as a dictionary and here this is not going
-            // to happen.
-            ERROR_FROM_TOKEN_AND_MSG(
-                cur_token,
-                _("E15: Expected lambda arguments list or arrow: %.*s"));
-          } else {
-            // Else it may appear that possibly-lambda node is actually
-            // a dictionary or curly-braces-name identifier.
-            lambda_node = NULL;
-            kv_drop(pt_stack, 1);
-          }
+    case kEPTExpr:
+      break;
+    case kEPTLambdaArguments:
+      if ((want_node == kENodeOperator
+           && tok_type != kExprLexComma
+           && tok_type != kExprLexArrow)
+          || (want_node == kENodeValue
+              && !(cur_token.type == kExprLexPlainIdentifier
+                   && cur_token.data.var.scope == kExprVarScopeMissing
+                   && !cur_token.data.var.autoload)
+              && tok_type != kExprLexArrow)) {
+        lambda_node->data.fig.type_guesses.allow_lambda = false;
+        if (lambda_node->children != NULL
+            && lambda_node->children->type == kExprNodeComma) {
+          // If lambda has comma child this means that parser has already seen
+          // at least "{arg1,", so node cannot possibly be anything, but
+          // lambda.
+
+          // Vim may give E121 or E720 in this case, but it does not look
+          // right to have either because both are results of reevaluation
+          // possibly-lambda node as a dictionary and here this is not going
+          // to happen.
+          ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                   _("E15: Expected lambda arguments list or arrow: %.*s"));
+        } else {
+          // Else it may appear that possibly-lambda node is actually
+          // a dictionary or curly-braces-name identifier.
+          lambda_node = NULL;
+          kv_drop(pt_stack, 1);
         }
-        break;
       }
-      case kEPTSingleAssignment:
-      case kEPTAssignment: {
-        if (want_node == kENodeValue
-            && tok_type != kExprLexBracket
-            && tok_type != kExprLexPlainIdentifier
-            && (tok_type != kExprLexFigureBrace || cur_token.data.brc.closing)
-            && !(node_is_key && tok_type == kExprLexNumber)
-            && tok_type != kExprLexEnv
-            && tok_type != kExprLexOption
-            && tok_type != kExprLexRegister) {
-          ERROR_FROM_TOKEN_AND_MSG(
-              cur_token,
-              _("E15: Expected value part of assignment lvalue: %.*s"));
-          kv_drop(pt_stack, 1);
-        } else if (want_node == kENodeOperator
-                   && tok_type != kExprLexBracket
-                   && (tok_type != kExprLexFigureBrace
-                       || cur_token.data.brc.closing)
-                   && tok_type != kExprLexDot
-                   && (tok_type != kExprLexComma || !is_single_assignment)
-                   && tok_type != kExprLexAssignment
-                   // Curly brace identifiers: will contain plain identifier or
-                   // another curly brace in position where operator is wanted.
-                   && !((tok_type == kExprLexPlainIdentifier
-                         || (tok_type == kExprLexFigureBrace
-                             && !cur_token.data.brc.closing))
-                        && prev_token.type != kExprLexSpacing)) {
-          if (flags & kExprFlagsMulti && MAY_HAVE_NEXT_EXPR) {
-            goto viml_pexpr_parse_end;
-          }
-          ERROR_FROM_TOKEN_AND_MSG(
-              cur_token,
-              _("E15: Expected assignment operator or subscript: %.*s"));
-          kv_drop(pt_stack, 1);
+      break;
+    case kEPTSingleAssignment:
+    case kEPTAssignment:
+      if (want_node == kENodeValue
+          && tok_type != kExprLexBracket
+          && tok_type != kExprLexPlainIdentifier
+          && (tok_type != kExprLexFigureBrace || cur_token.data.brc.closing)
+          && !(node_is_key && tok_type == kExprLexNumber)
+          && tok_type != kExprLexEnv
+          && tok_type != kExprLexOption
+          && tok_type != kExprLexRegister) {
+        ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                 _("E15: Expected value part of assignment lvalue: %.*s"));
+        kv_drop(pt_stack, 1);
+      } else if (want_node == kENodeOperator
+                 && tok_type != kExprLexBracket
+                 && (tok_type != kExprLexFigureBrace
+                     || cur_token.data.brc.closing)
+                 && tok_type != kExprLexDot
+                 && (tok_type != kExprLexComma || !is_single_assignment)
+                 && tok_type != kExprLexAssignment
+                 // Curly brace identifiers: will contain plain identifier or
+                 // another curly brace in position where operator is wanted.
+                 && !((tok_type == kExprLexPlainIdentifier
+                       || (tok_type == kExprLexFigureBrace
+                           && !cur_token.data.brc.closing))
+                      && prev_token.type != kExprLexSpacing)) {
+        if (flags & kExprFlagsMulti && MAY_HAVE_NEXT_EXPR) {
+          goto viml_pexpr_parse_end;
         }
-        assert(kv_size(pt_stack));
-        break;
+        ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                 _("E15: Expected assignment operator or subscript: %.*s"));
+        kv_drop(pt_stack, 1);
       }
+      assert(kv_size(pt_stack));
+      break;
     }
     assert(kv_size(pt_stack));
     const ExprASTParseType cur_pt = kv_last(pt_stack);
     assert(lambda_node == NULL || cur_pt == kEPTLambdaArguments);
     switch (tok_type) {
-      case kExprLexMissing:
-      case kExprLexSpacing:
-      case kExprLexEOC: {
-        abort();
-      }
-      case kExprLexInvalid: {
-        ERROR_FROM_TOKEN(cur_token);
-        tok_type = cur_token.data.err.type;
-        goto viml_pexpr_parse_process_token;
-      }
-      case kExprLexRegister: {
-        if (want_node == kENodeOperator) {
-          // Register in operator position: e.g. @a @a
-          OP_MISSING;
-        }
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeRegister);
-        cur_node->data.reg.name = cur_token.data.reg.name;
-        *top_node_p = cur_node;
-        want_node = kENodeOperator;
-        HL_CUR_TOKEN(Register);
-        break;
+    case kExprLexMissing:
+    case kExprLexSpacing:
+    case kExprLexEOC:
+      abort();
+    case kExprLexInvalid:
+      ERROR_FROM_TOKEN(cur_token);
+      tok_type = cur_token.data.err.type;
+      goto viml_pexpr_parse_process_token;
+    case kExprLexRegister: {
+      if (want_node == kENodeOperator) {
+        // Register in operator position: e.g. @a @a
+        OP_MISSING;
       }
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeRegister);
+      cur_node->data.reg.name = cur_token.data.reg.name;
+      *top_node_p = cur_node;
+      want_node = kENodeOperator;
+      HL_CUR_TOKEN(Register);
+      break;
+    }
 #define SIMPLE_UB_OP(op) \
-      case kExprLex##op: { \
-        if (want_node == kENodeValue) { \
-          /* Value level: assume unary operator. */ \
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeUnary##op); \
-          *top_node_p = cur_node; \
-          kvi_push(ast_stack, &cur_node->children); \
-          HL_CUR_TOKEN(Unary##op); \
-        } else { \
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeBinary##op); \
-          ADD_OP_NODE(cur_node); \
-          HL_CUR_TOKEN(Binary##op); \
-        } \
-        want_node = kENodeValue; \
-        break; \
-      }
+case kExprLex##op: { \
+  if (want_node == kENodeValue) { \
+    /* Value level: assume unary operator. */ \
+    NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeUnary##op); \
+    *top_node_p = cur_node; \
+    kvi_push(ast_stack, &cur_node->children); \
+    HL_CUR_TOKEN(Unary##op); \
+  } else { \
+    NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeBinary##op); \
+    ADD_OP_NODE(cur_node); \
+    HL_CUR_TOKEN(Binary##op); \
+  } \
+  want_node = kENodeValue; \
+  break; \
+}
       SIMPLE_UB_OP(Plus)
       SIMPLE_UB_OP(Minus)
 #undef SIMPLE_UB_OP
 #define SIMPLE_B_OP(op, msg) \
-      case kExprLex##op: { \
-        ADD_VALUE_IF_MISSING(_("E15: Unexpected " msg ": %.*s")); \
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNode##op); \
-        HL_CUR_TOKEN(op); \
-        ADD_OP_NODE(cur_node); \
-        break; \
-      }
+case kExprLex##op: { \
+  ADD_VALUE_IF_MISSING(_("E15: Unexpected " msg ": %.*s")); \
+  NEW_NODE_WITH_CUR_POS(cur_node, kExprNode##op); \
+  HL_CUR_TOKEN(op); \
+  ADD_OP_NODE(cur_node); \
+  break; \
+}
       SIMPLE_B_OP(Or, "or operator")
       SIMPLE_B_OP(And, "and operator")
 #undef SIMPLE_B_OP
-      case kExprLexMultiplication: {
-        ADD_VALUE_IF_MISSING(
-            _("E15: Unexpected multiplication-like operator: %.*s"));
-        switch (cur_token.data.mul.type) {
+    case kExprLexMultiplication:
+      ADD_VALUE_IF_MISSING(_("E15: Unexpected multiplication-like operator: %.*s"));
+      switch (cur_token.data.mul.type) {
 #define MUL_OP(lex_op_tail, node_op_tail) \
-          case kExprLexMul##lex_op_tail: { \
-            NEW_NODE_WITH_CUR_POS(cur_node, kExprNode##node_op_tail); \
-            HL_CUR_TOKEN(node_op_tail); \
-            break; \
-          }
-          MUL_OP(Mul, Multiplication)
-          MUL_OP(Div, Division)
-          MUL_OP(Mod, Mod)
+case kExprLexMul##lex_op_tail: { \
+  NEW_NODE_WITH_CUR_POS(cur_node, kExprNode##node_op_tail); \
+  HL_CUR_TOKEN(node_op_tail); \
+  break; \
+}
+        MUL_OP(Mul, Multiplication)
+        MUL_OP(Div, Division)
+        MUL_OP(Mod, Mod)
 #undef MUL_OP
-        }
-        ADD_OP_NODE(cur_node);
-        break;
       }
-      case kExprLexOption: {
-        if (want_node == kENodeOperator) {
-          OP_MISSING;
-        }
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeOption);
-        if (cur_token.type == kExprLexInvalid) {
-          assert(cur_token.len == 1
-                 || (cur_token.len == 3
-                     && pline.data[cur_token.start.col + 2] == ':'));
-          cur_node->data.opt.ident = (
-              pline.data + cur_token.start.col + cur_token.len);
-          cur_node->data.opt.ident_len = 0;
-          cur_node->data.opt.scope = (
-              cur_token.len == 3
+      ADD_OP_NODE(cur_node);
+      break;
+    case kExprLexOption: {
+      if (want_node == kENodeOperator) {
+        OP_MISSING;
+      }
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeOption);
+      if (cur_token.type == kExprLexInvalid) {
+        assert(cur_token.len == 1
+               || (cur_token.len == 3
+                   && pline.data[cur_token.start.col + 2] == ':'));
+        cur_node->data.opt.ident = (
+                                    pline.data + cur_token.start.col + cur_token.len);
+        cur_node->data.opt.ident_len = 0;
+        cur_node->data.opt.scope = (
+                                    cur_token.len == 3
               ? (ExprOptScope)pline.data[cur_token.start.col + 1]
               : kExprOptScopeUnspecified);
-        } else {
-          cur_node->data.opt.ident = cur_token.data.opt.name;
-          cur_node->data.opt.ident_len = cur_token.data.opt.len;
-          cur_node->data.opt.scope = cur_token.data.opt.scope;
-        }
+      } else {
+        cur_node->data.opt.ident = cur_token.data.opt.name;
+        cur_node->data.opt.ident_len = cur_token.data.opt.len;
+        cur_node->data.opt.scope = cur_token.data.opt.scope;
+      }
+      *top_node_p = cur_node;
+      want_node = kENodeOperator;
+      viml_parser_highlight(pstate, cur_token.start, 1, HL(OptionSigil));
+      const size_t scope_shift = (
+                                  cur_token.data.opt.scope == kExprOptScopeUnspecified ? 0 : 2);
+      if (scope_shift) {
+        viml_parser_highlight(pstate, shifted_pos(cur_token.start, 1), 1,
+                              HL(OptionScope));
+        viml_parser_highlight(pstate, shifted_pos(cur_token.start, 2), 1,
+                              HL(OptionScopeDelimiter));
+      }
+      viml_parser_highlight(pstate, shifted_pos(cur_token.start, scope_shift + 1),
+                            cur_token.len - (scope_shift + 1), HL(OptionName));
+      break;
+    }
+    case kExprLexEnv:
+      if (want_node == kENodeOperator) {
+        OP_MISSING;
+      }
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeEnvironment);
+      cur_node->data.env.ident = pline.data + cur_token.start.col + 1;
+      cur_node->data.env.ident_len = cur_token.len - 1;
+      if (cur_node->data.env.ident_len == 0) {
+        ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                 _("E15: Environment variable name missing"));
+      }
+      *top_node_p = cur_node;
+      want_node = kENodeOperator;
+      viml_parser_highlight(pstate, cur_token.start, 1, HL(EnvironmentSigil));
+      viml_parser_highlight(pstate, shifted_pos(cur_token.start, 1),
+                            cur_token.len - 1, HL(EnvironmentName));
+      break;
+    case kExprLexNot:
+      if (want_node == kENodeOperator) {
+        OP_MISSING;
+      }
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeNot);
+      *top_node_p = cur_node;
+      kvi_push(ast_stack, &cur_node->children);
+      HL_CUR_TOKEN(Not);
+      break;
+    case kExprLexComparison:
+      ADD_VALUE_IF_MISSING(_("E15: Expected value, got comparison operator: %.*s"));
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeComparison);
+      if (cur_token.type == kExprLexInvalid) {
+        cur_node->data.cmp.ccs = kCCStrategyUseOption;
+        cur_node->data.cmp.type = kExprCmpEqual;
+        cur_node->data.cmp.inv = false;
+      } else {
+        cur_node->data.cmp.ccs = cur_token.data.cmp.ccs;
+        cur_node->data.cmp.type = cur_token.data.cmp.type;
+        cur_node->data.cmp.inv = cur_token.data.cmp.inv;
+      }
+      ADD_OP_NODE(cur_node);
+      if (cur_token.data.cmp.ccs != kCCStrategyUseOption) {
+        viml_parser_highlight(pstate, cur_token.start, cur_token.len - 1,
+                              HL(Comparison));
+        viml_parser_highlight(pstate, shifted_pos(cur_token.start, cur_token.len - 1), 1,
+                              HL(ComparisonModifier));
+      } else {
+        HL_CUR_TOKEN(Comparison);
+      }
+      want_node = kENodeValue;
+      break;
+    case kExprLexComma:
+      assert(!(want_node == kENodeValue && cur_pt == kEPTLambdaArguments));
+      if (want_node == kENodeValue) {
+        // Value level: comma appearing here is not valid.
+        // Note: in Vim string(,x) will give E116, this is not the case here.
+        ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Expected value, got comma: %.*s"));
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeMissing);
+        cur_node->len = 0;
         *top_node_p = cur_node;
         want_node = kENodeOperator;
-        viml_parser_highlight(pstate, cur_token.start, 1, HL(OptionSigil));
-        const size_t scope_shift = (
-            cur_token.data.opt.scope == kExprOptScopeUnspecified ? 0 : 2);
-        if (scope_shift) {
-          viml_parser_highlight(pstate, shifted_pos(cur_token.start, 1), 1,
-                                HL(OptionScope));
-          viml_parser_highlight(pstate, shifted_pos(cur_token.start, 2), 1,
-                                HL(OptionScopeDelimiter));
-        }
-        viml_parser_highlight(
-            pstate, shifted_pos(cur_token.start, scope_shift + 1),
-            cur_token.len - (scope_shift + 1), HL(OptionName));
-        break;
       }
-      case kExprLexEnv: {
-        if (want_node == kENodeOperator) {
-          OP_MISSING;
-        }
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeEnvironment);
-        cur_node->data.env.ident = pline.data + cur_token.start.col + 1;
-        cur_node->data.env.ident_len = cur_token.len - 1;
-        if (cur_node->data.env.ident_len == 0) {
+      if (cur_pt == kEPTLambdaArguments) {
+        assert(lambda_node != NULL);
+        assert(lambda_node->data.fig.type_guesses.allow_lambda);
+        SELECT_FIGURE_BRACE_TYPE(lambda_node, Lambda, Lambda);
+      }
+      if (kv_size(ast_stack) < 2) {
+        goto viml_pexpr_parse_invalid_comma;
+      }
+      for (size_t i = 1; i < kv_size(ast_stack); i++) {
+        ExprASTNode *const *const eastnode_p =
+          (ExprASTNode *const *)kv_Z(ast_stack, i);
+        const ExprASTNodeType eastnode_type = (*eastnode_p)->type;
+        const ExprOpLvl eastnode_lvl = node_lvl(**eastnode_p);
+        if (eastnode_type == kExprNodeLambda) {
+          assert(cur_pt == kEPTLambdaArguments
+                 && want_node == kENodeOperator);
+          break;
+        } else if (eastnode_type == kExprNodeDictLiteral
+                   || eastnode_type == kExprNodeListLiteral
+                   || eastnode_type == kExprNodeCall) {
+          break;
+        } else if (eastnode_type == kExprNodeComma
+                   || eastnode_type == kExprNodeColon
+                   || eastnode_lvl > kEOpLvlComma) {
+          // Do nothing
+        } else {
+viml_pexpr_parse_invalid_comma:
           ERROR_FROM_TOKEN_AND_MSG(cur_token,
-                                   _("E15: Environment variable name missing"));
+                                   _("E15: Comma outside of call, lambda or literal: %.*s"));
+          break;
+        }
+        if (i == kv_size(ast_stack) - 1) {
+          goto viml_pexpr_parse_invalid_comma;
         }
-        *top_node_p = cur_node;
-        want_node = kENodeOperator;
-        viml_parser_highlight(pstate, cur_token.start, 1, HL(EnvironmentSigil));
-        viml_parser_highlight(pstate, shifted_pos(cur_token.start, 1),
-                              cur_token.len - 1, HL(EnvironmentName));
-        break;
       }
-      case kExprLexNot: {
-        if (want_node == kENodeOperator) {
-          OP_MISSING;
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeComma);
+      ADD_OP_NODE(cur_node);
+      HL_CUR_TOKEN(Comma);
+      break;
+#define EXP_VAL_COLON "E15: Expected value, got colon: %.*s"
+    case kExprLexColon: {
+      bool is_ternary = false;
+      if (kv_size(ast_stack) < 2) {
+        goto viml_pexpr_parse_invalid_colon;
+      }
+      bool can_be_ternary = true;
+      bool is_subscript = false;
+      for (size_t i = 1; i < kv_size(ast_stack); i++) {
+        ExprASTNode *const *const eastnode_p =
+          (ExprASTNode *const *)kv_Z(ast_stack, i);
+        const ExprASTNodeType eastnode_type = (*eastnode_p)->type;
+        const ExprOpLvl eastnode_lvl = node_lvl(**eastnode_p);
+        STATIC_ASSERT(kEOpLvlTernary > kEOpLvlComma,
+                      "Unexpected operator priorities");
+        if (can_be_ternary && eastnode_type == kExprNodeTernaryValue
+            && !(*eastnode_p)->data.ter.got_colon) {
+          kv_drop(ast_stack, i);
+          (*eastnode_p)->start = cur_token.start;
+          (*eastnode_p)->len = cur_token.len;
+          if (prev_token.type == kExprLexSpacing) {
+            (*eastnode_p)->start = prev_token.start;
+            (*eastnode_p)->len += prev_token.len;
+          }
+          is_ternary = true;
+          (*eastnode_p)->data.ter.got_colon = true;
+          ADD_VALUE_IF_MISSING(_(EXP_VAL_COLON));
+          assert((*eastnode_p)->children != NULL);
+          assert((*eastnode_p)->children->next == NULL);
+          kvi_push(ast_stack, &(*eastnode_p)->children->next);
+          break;
+        } else if (eastnode_type == kExprNodeUnknownFigure) {
+          SELECT_FIGURE_BRACE_TYPE(*eastnode_p, DictLiteral, Dict);
+          break;
+        } else if (eastnode_type == kExprNodeDictLiteral) {
+          break;
+        } else if (eastnode_type == kExprNodeSubscript) {
+          is_subscript = true;
+          // can_be_ternary = false;
+          assert(!is_ternary);
+          break;
+        } else if (eastnode_type == kExprNodeColon) {
+          goto viml_pexpr_parse_invalid_colon;
+        } else if (eastnode_lvl >= kEOpLvlTernaryValue) {
+          // Do nothing
+        } else if (eastnode_lvl >= kEOpLvlComma) {
+          can_be_ternary = false;
+        } else {
+          goto viml_pexpr_parse_invalid_colon;
+        }
+        if (i == kv_size(ast_stack) - 1) {
+          goto viml_pexpr_parse_invalid_colon;
         }
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeNot);
-        *top_node_p = cur_node;
-        kvi_push(ast_stack, &cur_node->children);
-        HL_CUR_TOKEN(Not);
-        break;
       }
-      case kExprLexComparison: {
-        ADD_VALUE_IF_MISSING(
-            _("E15: Expected value, got comparison operator: %.*s"));
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeComparison);
-        if (cur_token.type == kExprLexInvalid) {
-          cur_node->data.cmp.ccs = kCCStrategyUseOption;
-          cur_node->data.cmp.type = kExprCmpEqual;
-          cur_node->data.cmp.inv = false;
+      if (is_subscript) {
+        assert(kv_size(ast_stack) > 1);
+        // Colon immediately following subscript start: it is empty subscript
+        // part like a[:2].
+        if (want_node == kENodeValue
+            && (*kv_Z(ast_stack, 1))->type == kExprNodeSubscript) {
+          NEW_NODE_WITH_CUR_POS(*top_node_p, kExprNodeMissing);
+          (*top_node_p)->len = 0;
+          want_node = kENodeOperator;
         } else {
-          cur_node->data.cmp.ccs = cur_token.data.cmp.ccs;
-          cur_node->data.cmp.type = cur_token.data.cmp.type;
-          cur_node->data.cmp.inv = cur_token.data.cmp.inv;
+          ADD_VALUE_IF_MISSING(_(EXP_VAL_COLON));
         }
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeColon);
         ADD_OP_NODE(cur_node);
-        if (cur_token.data.cmp.ccs != kCCStrategyUseOption) {
-          viml_parser_highlight(pstate, cur_token.start, cur_token.len - 1,
-                                HL(Comparison));
-          viml_parser_highlight(
-              pstate, shifted_pos(cur_token.start, cur_token.len - 1), 1,
-              HL(ComparisonModifier));
+        HL_CUR_TOKEN(SubscriptColon);
+      } else {
+        goto viml_pexpr_parse_valid_colon;
+viml_pexpr_parse_invalid_colon:
+        ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                 _("E15: Colon outside of dictionary or ternary operator: %.*s"));
+viml_pexpr_parse_valid_colon:
+        ADD_VALUE_IF_MISSING(_(EXP_VAL_COLON));
+        if (is_ternary) {
+          HL_CUR_TOKEN(TernaryColon);
         } else {
-          HL_CUR_TOKEN(Comparison);
+          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeColon);
+          ADD_OP_NODE(cur_node);
+          HL_CUR_TOKEN(Colon);
         }
-        want_node = kENodeValue;
-        break;
       }
-      case kExprLexComma: {
-        assert(!(want_node == kENodeValue && cur_pt == kEPTLambdaArguments));
-        if (want_node == kENodeValue) {
-          // Value level: comma appearing here is not valid.
-          // Note: in Vim string(,x) will give E116, this is not the case here.
-          ERROR_FROM_TOKEN_AND_MSG(
-              cur_token, _("E15: Expected value, got comma: %.*s"));
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeMissing);
+      want_node = kENodeValue;
+      break;
+    }
+#undef EXP_VAL_COLON
+    case kExprLexBracket:
+      if (cur_token.data.brc.closing) {
+        ExprASTNode **new_top_node_p = NULL;
+        // Always drop the topmost value:
+        //
+        // 1. When want_node != kENodeValue topmost item on stack is
+        //    a *finished* left operand, which may as well be "{@a}" which
+        //    needs not be finished again.
+        // 2. Otherwise it is pointing to NULL what nobody wants.
+        kv_drop(ast_stack, 1);
+        if (!kv_size(ast_stack)) {
+          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeListLiteral);
           cur_node->len = 0;
+          if (want_node != kENodeValue) {
+            cur_node->children = *top_node_p;
+          }
           *top_node_p = cur_node;
-          want_node = kENodeOperator;
-        }
-        if (cur_pt == kEPTLambdaArguments) {
-          assert(lambda_node != NULL);
-          assert(lambda_node->data.fig.type_guesses.allow_lambda);
-          SELECT_FIGURE_BRACE_TYPE(lambda_node, Lambda, Lambda);
+          goto viml_pexpr_parse_bracket_closing_error;
         }
-        if (kv_size(ast_stack) < 2) {
-          goto viml_pexpr_parse_invalid_comma;
+        if (want_node == kENodeValue) {
+          // It is OK to want value if
+          //
+          // 1. It is empty list literal, in which case top node will be
+          //    ListLiteral.
+          // 2. It is list literal with trailing comma, in which case top node
+          //    will be that comma.
+          // 3. It is subscript with colon, but without one of the values:
+          //    e.g. "a[:]", "a[1:]", top node will be colon in this case.
+          if ((*kv_last(ast_stack))->type != kExprNodeListLiteral
+              && (*kv_last(ast_stack))->type != kExprNodeComma
+              && (*kv_last(ast_stack))->type != kExprNodeColon) {
+            ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                     _("E15: Expected value, got closing bracket: %.*s"));
+          }
         }
-        for (size_t i = 1; i < kv_size(ast_stack); i++) {
-          ExprASTNode *const *const eastnode_p =
-              (ExprASTNode *const *)kv_Z(ast_stack, i);
-          const ExprASTNodeType eastnode_type = (*eastnode_p)->type;
-          const ExprOpLvl eastnode_lvl = node_lvl(**eastnode_p);
-          if (eastnode_type == kExprNodeLambda) {
-            assert(cur_pt == kEPTLambdaArguments
-                   && want_node == kENodeOperator);
-            break;
-          } else if (eastnode_type == kExprNodeDictLiteral
-                     || eastnode_type == kExprNodeListLiteral
-                     || eastnode_type == kExprNodeCall) {
-            break;
-          } else if (eastnode_type == kExprNodeComma
-                     || eastnode_type == kExprNodeColon
-                     || eastnode_lvl > kEOpLvlComma) {
-            // Do nothing
-          } else {
-viml_pexpr_parse_invalid_comma:
-            ERROR_FROM_TOKEN_AND_MSG(
-                cur_token,
-                _("E15: Comma outside of call, lambda or literal: %.*s"));
-            break;
+        do {
+          new_top_node_p = kv_pop(ast_stack);
+        } while (kv_size(ast_stack)
+                 && (new_top_node_p == NULL
+                     || ((*new_top_node_p)->type != kExprNodeListLiteral
+                         && (*new_top_node_p)->type != kExprNodeSubscript)));
+        ExprASTNode *new_top_node = *new_top_node_p;
+        switch (new_top_node->type) {
+        case kExprNodeListLiteral:
+          if (pt_is_assignment(cur_pt) && new_top_node->children == NULL) {
+            ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E475: Unable to assign to empty list: %.*s"));
           }
-          if (i == kv_size(ast_stack) - 1) {
-            goto viml_pexpr_parse_invalid_comma;
+          HL_CUR_TOKEN(List);
+          break;
+        case kExprNodeSubscript:
+          HL_CUR_TOKEN(SubscriptBracket);
+          break;
+        default:
+viml_pexpr_parse_bracket_closing_error:
+          assert(!kv_size(ast_stack));
+          ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Unexpected closing figure brace: %.*s"));
+          HL_CUR_TOKEN(List);
+          break;
+        }
+        kvi_push(ast_stack, new_top_node_p);
+        want_node = kENodeOperator;
+        if (kv_size(ast_stack) <= asgn_level) {
+          assert(kv_size(ast_stack) == asgn_level);
+          asgn_level = 0;
+          if (cur_pt == kEPTAssignment) {
+            assert(ast.err.msg);
+          } else if (cur_pt == kEPTExpr
+                     && kv_size(pt_stack) > 1
+                     && pt_is_assignment(kv_Z(pt_stack, 1))) {
+            kv_drop(pt_stack, 1);
           }
         }
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeComma);
-        ADD_OP_NODE(cur_node);
-        HL_CUR_TOKEN(Comma);
-        break;
-      }
-#define EXP_VAL_COLON "E15: Expected value, got colon: %.*s"
-      case kExprLexColon: {
-        bool is_ternary = false;
-        if (kv_size(ast_stack) < 2) {
-          goto viml_pexpr_parse_invalid_colon;
+        if (cur_pt == kEPTSingleAssignment && kv_size(ast_stack) == 1) {
+          kv_drop(pt_stack, 1);
         }
-        bool can_be_ternary = true;
-        bool is_subscript = false;
-        for (size_t i = 1; i < kv_size(ast_stack); i++) {
-          ExprASTNode *const *const eastnode_p =
-              (ExprASTNode *const *)kv_Z(ast_stack, i);
-          const ExprASTNodeType eastnode_type = (*eastnode_p)->type;
-          const ExprOpLvl eastnode_lvl = node_lvl(**eastnode_p);
-          STATIC_ASSERT(kEOpLvlTernary > kEOpLvlComma,
-                        "Unexpected operator priorities");
-          if (can_be_ternary && eastnode_type == kExprNodeTernaryValue
-              && !(*eastnode_p)->data.ter.got_colon) {
-            kv_drop(ast_stack, i);
-            (*eastnode_p)->start = cur_token.start;
-            (*eastnode_p)->len = cur_token.len;
-            if (prev_token.type == kExprLexSpacing) {
-              (*eastnode_p)->start = prev_token.start;
-              (*eastnode_p)->len += prev_token.len;
-            }
-            is_ternary = true;
-            (*eastnode_p)->data.ter.got_colon = true;
-            ADD_VALUE_IF_MISSING(_(EXP_VAL_COLON));
-            assert((*eastnode_p)->children != NULL);
-            assert((*eastnode_p)->children->next == NULL);
-            kvi_push(ast_stack, &(*eastnode_p)->children->next);
-            break;
-          } else if (eastnode_type == kExprNodeUnknownFigure) {
-            SELECT_FIGURE_BRACE_TYPE(*eastnode_p, DictLiteral, Dict);
-            break;
-          } else if (eastnode_type == kExprNodeDictLiteral) {
-            break;
-          } else if (eastnode_type == kExprNodeSubscript) {
-            is_subscript = true;
-            // can_be_ternary = false;
-            assert(!is_ternary);
-            break;
-          } else if (eastnode_type == kExprNodeColon) {
-            goto viml_pexpr_parse_invalid_colon;
-          } else if (eastnode_lvl >= kEOpLvlTernaryValue) {
-            // Do nothing
-          } else if (eastnode_lvl >= kEOpLvlComma) {
-            can_be_ternary = false;
-          } else {
-            goto viml_pexpr_parse_invalid_colon;
-          }
-          if (i == kv_size(ast_stack) - 1) {
-            goto viml_pexpr_parse_invalid_colon;
+      } else {
+        if (want_node == kENodeValue) {
+          // Value means list literal or list assignment.
+          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeListLiteral);
+          *top_node_p = cur_node;
+          kvi_push(ast_stack, &cur_node->children);
+          want_node = kENodeValue;
+          if (cur_pt == kEPTAssignment) {
+            // Additional assignment parse type allows to easily forbid nested
+            // lists.
+            kvi_push(pt_stack, kEPTSingleAssignment);
+          } else if (cur_pt == kEPTSingleAssignment) {
+            ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                     _("E475: Nested lists not allowed when assigning: %.*s"));
           }
-        }
-        if (is_subscript) {
-          assert(kv_size(ast_stack) > 1);
-          // Colon immediately following subscript start: it is empty subscript
-          // part like a[:2].
-          if (want_node == kENodeValue
-              && (*kv_Z(ast_stack, 1))->type == kExprNodeSubscript) {
-            NEW_NODE_WITH_CUR_POS(*top_node_p, kExprNodeMissing);
-            (*top_node_p)->len = 0;
-            want_node = kENodeOperator;
-          } else {
-            ADD_VALUE_IF_MISSING(_(EXP_VAL_COLON));
+          HL_CUR_TOKEN(List);
+        } else {
+          // Operator means subscript, also in assignment. But in assignment
+          // subscript may be pretty much any expression, so need to push
+          // kEPTExpr.
+          if (prev_token.type == kExprLexSpacing) {
+            OP_MISSING;
           }
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeColon);
+          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeSubscript);
           ADD_OP_NODE(cur_node);
-          HL_CUR_TOKEN(SubscriptColon);
-        } else {
-          goto viml_pexpr_parse_valid_colon;
-viml_pexpr_parse_invalid_colon:
-          ERROR_FROM_TOKEN_AND_MSG(
-              cur_token,
-              _("E15: Colon outside of dictionary or ternary operator: %.*s"));
-viml_pexpr_parse_valid_colon:
-          ADD_VALUE_IF_MISSING(_(EXP_VAL_COLON));
-          if (is_ternary) {
-            HL_CUR_TOKEN(TernaryColon);
-          } else {
-            NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeColon);
-            ADD_OP_NODE(cur_node);
-            HL_CUR_TOKEN(Colon);
+          HL_CUR_TOKEN(SubscriptBracket);
+          if (pt_is_assignment(cur_pt)) {
+            assert(want_node == kENodeValue);  // Subtract 1 for NULL at top.
+            asgn_level = kv_size(ast_stack) - 1;
+            kvi_push(pt_stack, kEPTExpr);
           }
         }
-        want_node = kENodeValue;
-        break;
       }
-#undef EXP_VAL_COLON
-      case kExprLexBracket: {
-        if (cur_token.data.brc.closing) {
-          ExprASTNode **new_top_node_p = NULL;
-          // Always drop the topmost value:
-          //
-          // 1. When want_node != kENodeValue topmost item on stack is
-          //    a *finished* left operand, which may as well be "{@a}" which
-          //    needs not be finished again.
-          // 2. Otherwise it is pointing to NULL what nobody wants.
-          kv_drop(ast_stack, 1);
-          if (!kv_size(ast_stack)) {
-            NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeListLiteral);
-            cur_node->len = 0;
-            if (want_node != kENodeValue) {
-              cur_node->children = *top_node_p;
-            }
-            *top_node_p = cur_node;
-            goto viml_pexpr_parse_bracket_closing_error;
-          }
-          if (want_node == kENodeValue) {
-            // It is OK to want value if
-            //
-            // 1. It is empty list literal, in which case top node will be
-            //    ListLiteral.
-            // 2. It is list literal with trailing comma, in which case top node
-            //    will be that comma.
-            // 3. It is subscript with colon, but without one of the values:
-            //    e.g. "a[:]", "a[1:]", top node will be colon in this case.
-            if ((*kv_last(ast_stack))->type != kExprNodeListLiteral
-                && (*kv_last(ast_stack))->type != kExprNodeComma
-                && (*kv_last(ast_stack))->type != kExprNodeColon) {
-              ERROR_FROM_TOKEN_AND_MSG(
-                  cur_token,
-                  _("E15: Expected value, got closing bracket: %.*s"));
-            }
+      break;
+    case kExprLexFigureBrace:
+      if (cur_token.data.brc.closing) {
+        ExprASTNode **new_top_node_p = NULL;
+        // Always drop the topmost value:
+        //
+        // 1. When want_node != kENodeValue topmost item on stack is
+        //    a *finished* left operand, which may as well be "{@a}" which
+        //    needs not be finished again.
+        // 2. Otherwise it is pointing to NULL what nobody wants.
+        kv_drop(ast_stack, 1);
+        if (!kv_size(ast_stack)) {
+          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeUnknownFigure);
+          cur_node->data.fig.type_guesses.allow_lambda = false;
+          cur_node->data.fig.type_guesses.allow_dict = false;
+          cur_node->data.fig.type_guesses.allow_ident = false;
+          cur_node->len = 0;
+          if (want_node != kENodeValue) {
+            cur_node->children = *top_node_p;
           }
-          do {
-            new_top_node_p = kv_pop(ast_stack);
-          } while (kv_size(ast_stack)
-                   && (new_top_node_p == NULL
-                       || ((*new_top_node_p)->type != kExprNodeListLiteral
-                           && (*new_top_node_p)->type != kExprNodeSubscript)));
-          ExprASTNode *new_top_node = *new_top_node_p;
-          switch (new_top_node->type) {
-            case kExprNodeListLiteral: {
-              if (pt_is_assignment(cur_pt) && new_top_node->children == NULL) {
-                ERROR_FROM_TOKEN_AND_MSG(
-                    cur_token, _("E475: Unable to assign to empty list: %.*s"));
-              }
-              HL_CUR_TOKEN(List);
-              break;
-            }
-            case kExprNodeSubscript: {
-              HL_CUR_TOKEN(SubscriptBracket);
-              break;
-            }
-            default: {
-viml_pexpr_parse_bracket_closing_error:
-              assert(!kv_size(ast_stack));
-              ERROR_FROM_TOKEN_AND_MSG(
-                  cur_token, _("E15: Unexpected closing figure brace: %.*s"));
-              HL_CUR_TOKEN(List);
-              break;
-            }
+          *top_node_p = cur_node;
+          new_top_node_p = top_node_p;
+          goto viml_pexpr_parse_figure_brace_closing_error;
+        }
+        if (want_node == kENodeValue) {
+          if ((*kv_last(ast_stack))->type != kExprNodeUnknownFigure
+              && (*kv_last(ast_stack))->type != kExprNodeComma) {
+            // kv_last being UnknownFigure may occur for empty dictionary
+            // literal, while Comma is expected in case of non-empty one.
+            ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                     _("E15: Expected value, got closing figure brace: %.*s"));
           }
-          kvi_push(ast_stack, new_top_node_p);
-          want_node = kENodeOperator;
-          if (kv_size(ast_stack) <= asgn_level) {
-            assert(kv_size(ast_stack) == asgn_level);
-            asgn_level = 0;
-            if (cur_pt == kEPTAssignment) {
-              assert(ast.err.msg);
-            } else if (cur_pt == kEPTExpr
-                       && kv_size(pt_stack) > 1
-                       && pt_is_assignment(kv_Z(pt_stack, 1))) {
-              kv_drop(pt_stack, 1);
+        }
+        do {
+          new_top_node_p = kv_pop(ast_stack);
+        } while (kv_size(ast_stack)
+                 && (new_top_node_p == NULL
+                     || ((*new_top_node_p)->type != kExprNodeUnknownFigure
+                         && (*new_top_node_p)->type != kExprNodeDictLiteral
+                         && ((*new_top_node_p)->type
+                             != kExprNodeCurlyBracesIdentifier)
+                         && (*new_top_node_p)->type != kExprNodeLambda)));
+        ExprASTNode *new_top_node = *new_top_node_p;
+        switch (new_top_node->type) {
+        case kExprNodeUnknownFigure:
+          if (new_top_node->children == NULL) {
+            // No children of curly braces node indicates empty dictionary.
+            assert(want_node == kENodeValue);
+            assert(new_top_node->data.fig.type_guesses.allow_dict);
+            SELECT_FIGURE_BRACE_TYPE(new_top_node, DictLiteral, Dict);
+            HL_CUR_TOKEN(Dict);
+          } else if (new_top_node->data.fig.type_guesses.allow_ident) {
+            SELECT_FIGURE_BRACE_TYPE(new_top_node, CurlyBracesIdentifier,
+                                     Curly);
+            HL_CUR_TOKEN(Curly);
+          } else {
+            // If by this time type of the node has not already been
+            // guessed, but it definitely is not a curly braces name then
+            // it is invalid for sure.
+            ERROR_FROM_NODE_AND_MSG(new_top_node,
+                                    _("E15: Don't know what figure brace means: %.*s"));
+            if (pstate->colors) {
+              // Will reset to NvimInvalidFigureBrace.
+              kv_A(*pstate->colors,
+                   new_top_node->data.fig.opening_hl_idx).group = (
+                                                                   HL(FigureBrace));
             }
+            HL_CUR_TOKEN(FigureBrace);
           }
-          if (cur_pt == kEPTSingleAssignment && kv_size(ast_stack) == 1) {
+          break;
+        case kExprNodeDictLiteral:
+          HL_CUR_TOKEN(Dict);
+          break;
+        case kExprNodeCurlyBracesIdentifier:
+          HL_CUR_TOKEN(Curly);
+          break;
+        case kExprNodeLambda:
+          HL_CUR_TOKEN(Lambda);
+          break;
+        default:
+viml_pexpr_parse_figure_brace_closing_error:
+          assert(!kv_size(ast_stack));
+          ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Unexpected closing figure brace: %.*s"));
+          HL_CUR_TOKEN(FigureBrace);
+          break;
+        }
+        kvi_push(ast_stack, new_top_node_p);
+        want_node = kENodeOperator;
+        if (kv_size(ast_stack) <= asgn_level) {
+          assert(kv_size(ast_stack) == asgn_level);
+          if (cur_pt == kEPTExpr
+              && kv_size(pt_stack) > 1
+              && pt_is_assignment(kv_Z(pt_stack, 1))) {
             kv_drop(pt_stack, 1);
-          }
-        } else {
-          if (want_node == kENodeValue) {
-            // Value means list literal or list assignment.
-            NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeListLiteral);
-            *top_node_p = cur_node;
-            kvi_push(ast_stack, &cur_node->children);
-            want_node = kENodeValue;
-            if (cur_pt == kEPTAssignment) {
-              // Additional assignment parse type allows to easily forbid nested
-              // lists.
-              kvi_push(pt_stack, kEPTSingleAssignment);
-            } else if (cur_pt == kEPTSingleAssignment) {
-              ERROR_FROM_TOKEN_AND_MSG(
-                  cur_token,
-                  _("E475: Nested lists not allowed when assigning: %.*s"));
-            }
-            HL_CUR_TOKEN(List);
-          } else {
-            // Operator means subscript, also in assignment. But in assignment
-            // subscript may be pretty much any expression, so need to push
-            // kEPTExpr.
-            if (prev_token.type == kExprLexSpacing) {
-              OP_MISSING;
-            }
-            NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeSubscript);
-            ADD_OP_NODE(cur_node);
-            HL_CUR_TOKEN(SubscriptBracket);
-            if (pt_is_assignment(cur_pt)) {
-              assert(want_node == kENodeValue);  // Subtract 1 for NULL at top.
-              asgn_level = kv_size(ast_stack) - 1;
-              kvi_push(pt_stack, kEPTExpr);
-            }
+            asgn_level = 0;
           }
         }
-        break;
-      }
-      case kExprLexFigureBrace: {
-        if (cur_token.data.brc.closing) {
-          ExprASTNode **new_top_node_p = NULL;
-          // Always drop the topmost value:
-          //
-          // 1. When want_node != kENodeValue topmost item on stack is
-          //    a *finished* left operand, which may as well be "{@a}" which
-          //    needs not be finished again.
-          // 2. Otherwise it is pointing to NULL what nobody wants.
-          kv_drop(ast_stack, 1);
-          if (!kv_size(ast_stack)) {
-            NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeUnknownFigure);
+      } else {
+        if (want_node == kENodeValue) {
+          HL_CUR_TOKEN(FigureBrace);
+          // Value: may be any of lambda, dictionary literal and curly braces
+          // name.
+
+          // Though if we are in an assignment this may only be a curly braces
+          // name.
+          if (pt_is_assignment(cur_pt)) {
+            NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeCurlyBracesIdentifier);
             cur_node->data.fig.type_guesses.allow_lambda = false;
             cur_node->data.fig.type_guesses.allow_dict = false;
-            cur_node->data.fig.type_guesses.allow_ident = false;
-            cur_node->len = 0;
-            if (want_node != kENodeValue) {
-              cur_node->children = *top_node_p;
-            }
-            *top_node_p = cur_node;
-            new_top_node_p = top_node_p;
-            goto viml_pexpr_parse_figure_brace_closing_error;
-          }
-          if (want_node == kENodeValue) {
-            if ((*kv_last(ast_stack))->type != kExprNodeUnknownFigure
-                && (*kv_last(ast_stack))->type != kExprNodeComma) {
-              // kv_last being UnknownFigure may occur for empty dictionary
-              // literal, while Comma is expected in case of non-empty one.
-              ERROR_FROM_TOKEN_AND_MSG(
-                  cur_token,
-                  _("E15: Expected value, got closing figure brace: %.*s"));
-            }
-          }
-          do {
-            new_top_node_p = kv_pop(ast_stack);
-          } while (kv_size(ast_stack)
-                   && (new_top_node_p == NULL
-                       || ((*new_top_node_p)->type != kExprNodeUnknownFigure
-                           && (*new_top_node_p)->type != kExprNodeDictLiteral
-                           && ((*new_top_node_p)->type
-                               != kExprNodeCurlyBracesIdentifier)
-                           && (*new_top_node_p)->type != kExprNodeLambda)));
-          ExprASTNode *new_top_node = *new_top_node_p;
-          switch (new_top_node->type) {
-            case kExprNodeUnknownFigure: {
-              if (new_top_node->children == NULL) {
-                // No children of curly braces node indicates empty dictionary.
-                assert(want_node == kENodeValue);
-                assert(new_top_node->data.fig.type_guesses.allow_dict);
-                SELECT_FIGURE_BRACE_TYPE(new_top_node, DictLiteral, Dict);
-                HL_CUR_TOKEN(Dict);
-              } else if (new_top_node->data.fig.type_guesses.allow_ident) {
-                SELECT_FIGURE_BRACE_TYPE(new_top_node, CurlyBracesIdentifier,
-                                         Curly);
-                HL_CUR_TOKEN(Curly);
-              } else {
-                // If by this time type of the node has not already been
-                // guessed, but it definitely is not a curly braces name then
-                // it is invalid for sure.
-                ERROR_FROM_NODE_AND_MSG(
-                    new_top_node,
-                    _("E15: Don't know what figure brace means: %.*s"));
-                if (pstate->colors) {
-                  // Will reset to NvimInvalidFigureBrace.
-                  kv_A(*pstate->colors,
-                       new_top_node->data.fig.opening_hl_idx).group = (
-                           HL(FigureBrace));
-                }
-                HL_CUR_TOKEN(FigureBrace);
-              }
-              break;
-            }
-            case kExprNodeDictLiteral: {
-              HL_CUR_TOKEN(Dict);
-              break;
-            }
-            case kExprNodeCurlyBracesIdentifier: {
-              HL_CUR_TOKEN(Curly);
-              break;
-            }
-            case kExprNodeLambda: {
-              HL_CUR_TOKEN(Lambda);
-              break;
-            }
-            default: {
-viml_pexpr_parse_figure_brace_closing_error:
-              assert(!kv_size(ast_stack));
-              ERROR_FROM_TOKEN_AND_MSG(
-                  cur_token, _("E15: Unexpected closing figure brace: %.*s"));
-              HL_CUR_TOKEN(FigureBrace);
-              break;
-            }
+            cur_node->data.fig.type_guesses.allow_ident = true;
+            kvi_push(pt_stack, kEPTExpr);
+          } else {
+            NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeUnknownFigure);
+            cur_node->data.fig.type_guesses.allow_lambda = true;
+            cur_node->data.fig.type_guesses.allow_dict = true;
+            cur_node->data.fig.type_guesses.allow_ident = true;
           }
-          kvi_push(ast_stack, new_top_node_p);
-          want_node = kENodeOperator;
-          if (kv_size(ast_stack) <= asgn_level) {
-            assert(kv_size(ast_stack) == asgn_level);
-            if (cur_pt == kEPTExpr
-                && kv_size(pt_stack) > 1
-                && pt_is_assignment(kv_Z(pt_stack, 1))) {
-              kv_drop(pt_stack, 1);
-              asgn_level = 0;
-            }
+          if (pstate->colors) {
+            cur_node->data.fig.opening_hl_idx = kv_size(*pstate->colors) - 1;
           }
+          *top_node_p = cur_node;
+          kvi_push(ast_stack, &cur_node->children);
+          kvi_push(pt_stack, kEPTLambdaArguments);
+          lambda_node = cur_node;
         } else {
-          if (want_node == kENodeValue) {
-            HL_CUR_TOKEN(FigureBrace);
-            // Value: may be any of lambda, dictionary literal and curly braces
-            // name.
-
-            // Though if we are in an assignment this may only be a curly braces
-            // name.
+          ADD_IDENT(do {
+            NEW_NODE_WITH_CUR_POS(cur_node,
+                                  kExprNodeCurlyBracesIdentifier);
+            cur_node->data.fig.opening_hl_idx = kv_size(*pstate->colors);
+            cur_node->data.fig.type_guesses.allow_lambda = false;
+            cur_node->data.fig.type_guesses.allow_dict = false;
+            cur_node->data.fig.type_guesses.allow_ident = true;
+            kvi_push(ast_stack, &cur_node->children);
             if (pt_is_assignment(cur_pt)) {
-              NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeCurlyBracesIdentifier);
-              cur_node->data.fig.type_guesses.allow_lambda = false;
-              cur_node->data.fig.type_guesses.allow_dict = false;
-              cur_node->data.fig.type_guesses.allow_ident = true;
               kvi_push(pt_stack, kEPTExpr);
-            } else {
-              NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeUnknownFigure);
-              cur_node->data.fig.type_guesses.allow_lambda = true;
-              cur_node->data.fig.type_guesses.allow_dict = true;
-              cur_node->data.fig.type_guesses.allow_ident = true;
-            }
-            if (pstate->colors) {
-              cur_node->data.fig.opening_hl_idx = kv_size(*pstate->colors) - 1;
             }
-            *top_node_p = cur_node;
-            kvi_push(ast_stack, &cur_node->children);
-            kvi_push(pt_stack, kEPTLambdaArguments);
-            lambda_node = cur_node;
-          } else {
-            ADD_IDENT(
-                do {
-                  NEW_NODE_WITH_CUR_POS(cur_node,
-                                        kExprNodeCurlyBracesIdentifier);
-                  cur_node->data.fig.opening_hl_idx = kv_size(*pstate->colors);
-                  cur_node->data.fig.type_guesses.allow_lambda = false;
-                  cur_node->data.fig.type_guesses.allow_dict = false;
-                  cur_node->data.fig.type_guesses.allow_ident = true;
-                  kvi_push(ast_stack, &cur_node->children);
-                  if (pt_is_assignment(cur_pt)) {
-                    kvi_push(pt_stack, kEPTExpr);
-                  }
-                  want_node = kENodeValue;
-                } while (0),
-                Curly);
-          }
-          if (pt_is_assignment(cur_pt)
-              && !pt_is_assignment(kv_last(pt_stack))) {
-            assert(want_node == kENodeValue);  // Subtract 1 for NULL at top.
-            asgn_level = kv_size(ast_stack) - 1;
-          }
+            want_node = kENodeValue;
+          } while (0),
+                    Curly);
+        }
+        if (pt_is_assignment(cur_pt)
+            && !pt_is_assignment(kv_last(pt_stack))) {
+          assert(want_node == kENodeValue);  // Subtract 1 for NULL at top.
+          asgn_level = kv_size(ast_stack) - 1;
         }
-        break;
       }
-      case kExprLexArrow: {
-        if (cur_pt == kEPTLambdaArguments) {
-          kv_drop(pt_stack, 1);
-          assert(kv_size(pt_stack));
-          if (want_node == kENodeValue) {
-            // Wanting value means trailing comma and NULL at the top of the
-            // stack.
-            kv_drop(ast_stack, 1);
-          }
-          assert(kv_size(ast_stack) >= 1);
-          while ((*kv_last(ast_stack))->type != kExprNodeLambda
-                 && (*kv_last(ast_stack))->type != kExprNodeUnknownFigure) {
-            kv_drop(ast_stack, 1);
-          }
-          assert((*kv_last(ast_stack)) == lambda_node);
-          SELECT_FIGURE_BRACE_TYPE(lambda_node, Lambda, Lambda);
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeArrow);
-          if (lambda_node->children == NULL) {
-            assert(want_node == kENodeValue);
-            lambda_node->children = cur_node;
-            kvi_push(ast_stack, &lambda_node->children);
-          } else {
-            assert(lambda_node->children->next == NULL);
-            lambda_node->children->next = cur_node;
-            kvi_push(ast_stack, &lambda_node->children->next);
-          }
-          kvi_push(ast_stack, &cur_node->children);
-          lambda_node = NULL;
+      break;
+    case kExprLexArrow:
+      if (cur_pt == kEPTLambdaArguments) {
+        kv_drop(pt_stack, 1);
+        assert(kv_size(pt_stack));
+        if (want_node == kENodeValue) {
+          // Wanting value means trailing comma and NULL at the top of the
+          // stack.
+          kv_drop(ast_stack, 1);
+        }
+        assert(kv_size(ast_stack) >= 1);
+        while ((*kv_last(ast_stack))->type != kExprNodeLambda
+               && (*kv_last(ast_stack))->type != kExprNodeUnknownFigure) {
+          kv_drop(ast_stack, 1);
+        }
+        assert((*kv_last(ast_stack)) == lambda_node);
+        SELECT_FIGURE_BRACE_TYPE(lambda_node, Lambda, Lambda);
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeArrow);
+        if (lambda_node->children == NULL) {
+          assert(want_node == kENodeValue);
+          lambda_node->children = cur_node;
+          kvi_push(ast_stack, &lambda_node->children);
         } else {
-          // Only first branch is valid.
-          ADD_VALUE_IF_MISSING(_("E15: Unexpected arrow: %.*s"));
-          ERROR_FROM_TOKEN_AND_MSG(
-              cur_token, _("E15: Arrow outside of lambda: %.*s"));
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeArrow);
-          ADD_OP_NODE(cur_node);
+          assert(lambda_node->children->next == NULL);
+          lambda_node->children->next = cur_node;
+          kvi_push(ast_stack, &lambda_node->children->next);
         }
-        want_node = kENodeValue;
-        HL_CUR_TOKEN(Arrow);
-        break;
+        kvi_push(ast_stack, &cur_node->children);
+        lambda_node = NULL;
+      } else {
+        // Only first branch is valid.
+        ADD_VALUE_IF_MISSING(_("E15: Unexpected arrow: %.*s"));
+        ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Arrow outside of lambda: %.*s"));
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeArrow);
+        ADD_OP_NODE(cur_node);
       }
-      case kExprLexPlainIdentifier: {
-        const ExprVarScope scope = (cur_token.type == kExprLexInvalid
+      want_node = kENodeValue;
+      HL_CUR_TOKEN(Arrow);
+      break;
+    case kExprLexPlainIdentifier: {
+      const ExprVarScope scope = (cur_token.type == kExprLexInvalid
                                     ? kExprVarScopeMissing
                                     : cur_token.data.var.scope);
-        if (want_node == kENodeValue) {
-          want_node = kENodeOperator;
-          NEW_NODE_WITH_CUR_POS(cur_node,
-                                (node_is_key
+      if (want_node == kENodeValue) {
+        want_node = kENodeOperator;
+        NEW_NODE_WITH_CUR_POS(cur_node,
+                              (node_is_key
                                  ? kExprNodePlainKey
                                  : kExprNodePlainIdentifier));
-          cur_node->data.var.scope = scope;
-          const size_t scope_shift = (scope == kExprVarScopeMissing ? 0 : 2);
-          cur_node->data.var.ident = (pline.data + cur_token.start.col
-                                      + scope_shift);
-          cur_node->data.var.ident_len = cur_token.len - scope_shift;
-          *top_node_p = cur_node;
-          if (scope_shift) {
-            assert(!node_is_key);
-            viml_parser_highlight(pstate, cur_token.start, 1,
-                                  HL(IdentifierScope));
-            viml_parser_highlight(pstate, shifted_pos(cur_token.start, 1), 1,
-                                  HL(IdentifierScopeDelimiter));
-          }
-          viml_parser_highlight(pstate, shifted_pos(cur_token.start,
-                                                    scope_shift),
-                                cur_token.len - scope_shift,
-                                (node_is_key
+        cur_node->data.var.scope = scope;
+        const size_t scope_shift = (scope == kExprVarScopeMissing ? 0 : 2);
+        cur_node->data.var.ident = (pline.data + cur_token.start.col
+                                    + scope_shift);
+        cur_node->data.var.ident_len = cur_token.len - scope_shift;
+        *top_node_p = cur_node;
+        if (scope_shift) {
+          assert(!node_is_key);
+          viml_parser_highlight(pstate, cur_token.start, 1,
+                                HL(IdentifierScope));
+          viml_parser_highlight(pstate, shifted_pos(cur_token.start, 1), 1,
+                                HL(IdentifierScopeDelimiter));
+        }
+        viml_parser_highlight(pstate, shifted_pos(cur_token.start,
+                                                  scope_shift),
+                              cur_token.len - scope_shift,
+                              (node_is_key
                                  ? HL(IdentifierKey)
                                  : HL(IdentifierName)));
+      } else {
+        if (scope == kExprVarScopeMissing) {
+          ADD_IDENT(do {
+              NEW_NODE_WITH_CUR_POS(cur_node, kExprNodePlainIdentifier);
+              cur_node->data.var.scope = scope;
+              cur_node->data.var.ident = pline.data + cur_token.start.col;
+              cur_node->data.var.ident_len = cur_token.len;
+              want_node = kENodeOperator;
+            } while (0),
+                    IdentifierName);
         } else {
-          if (scope == kExprVarScopeMissing) {
-            ADD_IDENT(
-                do {
-                  NEW_NODE_WITH_CUR_POS(cur_node, kExprNodePlainIdentifier);
-                  cur_node->data.var.scope = scope;
-                  cur_node->data.var.ident = pline.data + cur_token.start.col;
-                  cur_node->data.var.ident_len = cur_token.len;
-                  want_node = kENodeOperator;
-                } while (0),
-                IdentifierName);
-          } else {
-            OP_MISSING;
-          }
-        }
-        break;
-      }
-      case kExprLexNumber: {
-        if (want_node != kENodeValue) {
           OP_MISSING;
         }
-        if (node_is_key) {
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodePlainKey);
-          cur_node->data.var.ident = pline.data + cur_token.start.col;
-          cur_node->data.var.ident_len = cur_token.len;
-          HL_CUR_TOKEN(IdentifierKey);
-        } else if (cur_token.data.num.is_float) {
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeFloat);
-          cur_node->data.flt.value = cur_token.data.num.val.floating;
-          HL_CUR_TOKEN(Float);
-        } else {
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeInteger);
-          cur_node->data.num.value = cur_token.data.num.val.integer;
-          const uint8_t prefix_length = base_to_prefix_length[
-              cur_token.data.num.base];
-          viml_parser_highlight(pstate, cur_token.start, prefix_length,
-                                HL(NumberPrefix));
-          viml_parser_highlight(
-              pstate, shifted_pos(cur_token.start, prefix_length),
-              cur_token.len - prefix_length, HL(Number));
-        }
-        want_node = kENodeOperator;
-        *top_node_p = cur_node;
-        break;
       }
-      case kExprLexDot: {
-        ADD_VALUE_IF_MISSING(_("E15: Unexpected dot: %.*s"));
-        if (prev_token.type == kExprLexSpacing) {
-          if (cur_pt == kEPTAssignment) {
-            ERROR_FROM_TOKEN_AND_MSG(
-                cur_token, _("E15: Cannot concatenate in assignments: %.*s"));
-          }
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeConcat);
-          HL_CUR_TOKEN(Concat);
-        } else {
-          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeConcatOrSubscript);
-          HL_CUR_TOKEN(ConcatOrSubscript);
+      break;
+    }
+    case kExprLexNumber:
+      if (want_node != kENodeValue) {
+        OP_MISSING;
+      }
+      if (node_is_key) {
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodePlainKey);
+        cur_node->data.var.ident = pline.data + cur_token.start.col;
+        cur_node->data.var.ident_len = cur_token.len;
+        HL_CUR_TOKEN(IdentifierKey);
+      } else if (cur_token.data.num.is_float) {
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeFloat);
+        cur_node->data.flt.value = cur_token.data.num.val.floating;
+        HL_CUR_TOKEN(Float);
+      } else {
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeInteger);
+        cur_node->data.num.value = cur_token.data.num.val.integer;
+        const uint8_t prefix_length = base_to_prefix_length[
+                                                            cur_token.data.num.base];
+        viml_parser_highlight(pstate, cur_token.start, prefix_length,
+                              HL(NumberPrefix));
+        viml_parser_highlight(pstate, shifted_pos(cur_token.start, prefix_length),
+                              cur_token.len - prefix_length, HL(Number));
+      }
+      want_node = kENodeOperator;
+      *top_node_p = cur_node;
+      break;
+    case kExprLexDot:
+      ADD_VALUE_IF_MISSING(_("E15: Unexpected dot: %.*s"));
+      if (prev_token.type == kExprLexSpacing) {
+        if (cur_pt == kEPTAssignment) {
+          ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Cannot concatenate in assignments: %.*s"));
         }
-        ADD_OP_NODE(cur_node);
-        break;
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeConcat);
+        HL_CUR_TOKEN(Concat);
+      } else {
+        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeConcatOrSubscript);
+        HL_CUR_TOKEN(ConcatOrSubscript);
       }
-      case kExprLexParenthesis: {
-        if (cur_token.data.brc.closing) {
-          if (want_node == kENodeValue) {
-            if (kv_size(ast_stack) > 1) {
-              const ExprASTNode *const prev_top_node = *kv_Z(ast_stack, 1);
-              if (prev_top_node->type == kExprNodeCall) {
-                // Function call without arguments, this is not an error.
-                // But further code does not expect NULL nodes.
-                kv_drop(ast_stack, 1);
-                goto viml_pexpr_parse_no_paren_closing_error;
-              }
+      ADD_OP_NODE(cur_node);
+      break;
+    case kExprLexParenthesis:
+      if (cur_token.data.brc.closing) {
+        if (want_node == kENodeValue) {
+          if (kv_size(ast_stack) > 1) {
+            const ExprASTNode *const prev_top_node = *kv_Z(ast_stack, 1);
+            if (prev_top_node->type == kExprNodeCall) {
+              // Function call without arguments, this is not an error.
+              // But further code does not expect NULL nodes.
+              kv_drop(ast_stack, 1);
+              goto viml_pexpr_parse_no_paren_closing_error;
             }
-            ERROR_FROM_TOKEN_AND_MSG(
-                cur_token, _("E15: Expected value, got parenthesis: %.*s"));
-            NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeMissing);
-            cur_node->len = 0;
-            *top_node_p = cur_node;
-          } else {
-            // Always drop the topmost value: when want_node != kENodeValue
-            // topmost item on stack is a *finished* left operand, which may as
-            // well be "(@a)" which needs not be finished again.
-            kv_drop(ast_stack, 1);
           }
+          ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Expected value, got parenthesis: %.*s"));
+          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeMissing);
+          cur_node->len = 0;
+          *top_node_p = cur_node;
+        } else {
+          // Always drop the topmost value: when want_node != kENodeValue
+          // topmost item on stack is a *finished* left operand, which may as
+          // well be "(@a)" which needs not be finished again.
+          kv_drop(ast_stack, 1);
+        }
 viml_pexpr_parse_no_paren_closing_error: {}
-          ExprASTNode **new_top_node_p = NULL;
-          while (kv_size(ast_stack)
-                 && (new_top_node_p == NULL
-                     || ((*new_top_node_p)->type != kExprNodeNested
-                         && (*new_top_node_p)->type != kExprNodeCall))) {
-            new_top_node_p = kv_pop(ast_stack);
-          }
-          if (new_top_node_p != NULL
-              && ((*new_top_node_p)->type == kExprNodeNested
-                  || (*new_top_node_p)->type == kExprNodeCall)) {
-            if ((*new_top_node_p)->type == kExprNodeNested) {
-              HL_CUR_TOKEN(NestingParenthesis);
-            } else {
-              HL_CUR_TOKEN(CallingParenthesis);
-            }
-          } else {
-            // “Always drop the topmost value” branch has got rid of the single
-            // value stack had, so there is nothing known to enclose. Correct
-            // this.
-            if (new_top_node_p == NULL) {
-              new_top_node_p = top_node_p;
-            }
-            ERROR_FROM_TOKEN_AND_MSG(
-                cur_token, _("E15: Unexpected closing parenthesis: %.*s"));
+        ExprASTNode **new_top_node_p = NULL;
+        while (kv_size(ast_stack)
+               && (new_top_node_p == NULL
+                   || ((*new_top_node_p)->type != kExprNodeNested
+                       && (*new_top_node_p)->type != kExprNodeCall))) {
+          new_top_node_p = kv_pop(ast_stack);
+        }
+        if (new_top_node_p != NULL
+            && ((*new_top_node_p)->type == kExprNodeNested
+                || (*new_top_node_p)->type == kExprNodeCall)) {
+          if ((*new_top_node_p)->type == kExprNodeNested) {
             HL_CUR_TOKEN(NestingParenthesis);
-            cur_node = NEW_NODE(kExprNodeNested);
-            cur_node->start = cur_token.start;
-            cur_node->len = 0;
-            // Unexpected closing parenthesis, assume that it was wanted to
-            // enclose everything in ().
-            cur_node->children = *new_top_node_p;
-            *new_top_node_p = cur_node;
-            assert(cur_node->next == NULL);
+          } else {
+            HL_CUR_TOKEN(CallingParenthesis);
           }
-          kvi_push(ast_stack, new_top_node_p);
-          want_node = kENodeOperator;
         } else {
-          switch (want_node) {
-            case kENodeValue: {
-              NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeNested);
-              *top_node_p = cur_node;
-              kvi_push(ast_stack, &cur_node->children);
-              HL_CUR_TOKEN(NestingParenthesis);
-              break;
-            }
-            case kENodeOperator: {
-              if (prev_token.type == kExprLexSpacing) {
-                // For some reason "function (args)" is a function call, but
-                // "(funcref) (args)" is not. AFAIR this somehow involves
-                // compatibility and Bram was commenting that this is
-                // intentionally inconsistent and he is not very happy with the
-                // situation himself.
-                if ((*top_node_p)->type != kExprNodePlainIdentifier
-                    && (*top_node_p)->type != kExprNodeComplexIdentifier
-                    && (*top_node_p)->type != kExprNodeCurlyBracesIdentifier) {
-                  OP_MISSING;
-                }
-              }
-              NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeCall);
-              ADD_OP_NODE(cur_node);
-              HL_CUR_TOKEN(CallingParenthesis);
-              break;
+          // “Always drop the topmost value” branch has got rid of the single
+          // value stack had, so there is nothing known to enclose. Correct
+          // this.
+          if (new_top_node_p == NULL) {
+            new_top_node_p = top_node_p;
+          }
+          ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Unexpected closing parenthesis: %.*s"));
+          HL_CUR_TOKEN(NestingParenthesis);
+          cur_node = NEW_NODE(kExprNodeNested);
+          cur_node->start = cur_token.start;
+          cur_node->len = 0;
+          // Unexpected closing parenthesis, assume that it was wanted to
+          // enclose everything in ().
+          cur_node->children = *new_top_node_p;
+          *new_top_node_p = cur_node;
+          assert(cur_node->next == NULL);
+        }
+        kvi_push(ast_stack, new_top_node_p);
+        want_node = kENodeOperator;
+      } else {
+        switch (want_node) {
+        case kENodeValue:
+          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeNested);
+          *top_node_p = cur_node;
+          kvi_push(ast_stack, &cur_node->children);
+          HL_CUR_TOKEN(NestingParenthesis);
+          break;
+        case kENodeOperator:
+          if (prev_token.type == kExprLexSpacing) {
+            // For some reason "function (args)" is a function call, but
+            // "(funcref) (args)" is not. AFAIR this somehow involves
+            // compatibility and Bram was commenting that this is
+            // intentionally inconsistent and he is not very happy with the
+            // situation himself.
+            if ((*top_node_p)->type != kExprNodePlainIdentifier
+                && (*top_node_p)->type != kExprNodeComplexIdentifier
+                && (*top_node_p)->type != kExprNodeCurlyBracesIdentifier) {
+              OP_MISSING;
             }
           }
-          want_node = kENodeValue;
+          NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeCall);
+          ADD_OP_NODE(cur_node);
+          HL_CUR_TOKEN(CallingParenthesis);
+          break;
         }
-        break;
-      }
-      case kExprLexQuestion: {
-        ADD_VALUE_IF_MISSING(_("E15: Expected value, got question mark: %.*s"));
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeTernary);
-        ADD_OP_NODE(cur_node);
-        HL_CUR_TOKEN(Ternary);
-        ExprASTNode *ter_val_node;
-        NEW_NODE_WITH_CUR_POS(ter_val_node, kExprNodeTernaryValue);
-        ter_val_node->data.ter.got_colon = false;
-        assert(cur_node->children != NULL);
-        assert(cur_node->children->next == NULL);
-        assert(kv_last(ast_stack) == &cur_node->children->next);
-        *kv_last(ast_stack) = ter_val_node;
-        kvi_push(ast_stack, &ter_val_node->children);
-        break;
+        want_node = kENodeValue;
       }
-      case kExprLexDoubleQuotedString:
-      case kExprLexSingleQuotedString: {
-        const bool is_double = (tok_type == kExprLexDoubleQuotedString);
-        if (!cur_token.data.str.closed) {
-          // It is weird, but Vim has two identical errors messages with
-          // different error numbers: "E114: Missing quote" and
-          // "E115: Missing quote".
-          ERROR_FROM_TOKEN_AND_MSG(
-              cur_token, (is_double
+      break;
+    case kExprLexQuestion: {
+      ADD_VALUE_IF_MISSING(_("E15: Expected value, got question mark: %.*s"));
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeTernary);
+      ADD_OP_NODE(cur_node);
+      HL_CUR_TOKEN(Ternary);
+      ExprASTNode *ter_val_node;
+      NEW_NODE_WITH_CUR_POS(ter_val_node, kExprNodeTernaryValue);
+      ter_val_node->data.ter.got_colon = false;
+      assert(cur_node->children != NULL);
+      assert(cur_node->children->next == NULL);
+      assert(kv_last(ast_stack) == &cur_node->children->next);
+      *kv_last(ast_stack) = ter_val_node;
+      kvi_push(ast_stack, &ter_val_node->children);
+      break;
+    }
+    case kExprLexDoubleQuotedString:
+    case kExprLexSingleQuotedString: {
+      const bool is_double = (tok_type == kExprLexDoubleQuotedString);
+      if (!cur_token.data.str.closed) {
+        // It is weird, but Vim has two identical errors messages with
+        // different error numbers: "E114: Missing quote" and
+        // "E115: Missing quote".
+        ERROR_FROM_TOKEN_AND_MSG(cur_token, (is_double
                           ? _("E114: Missing double quote: %.*s")
                           : _("E115: Missing single quote: %.*s")));
-        }
-        if (want_node == kENodeOperator) {
-          OP_MISSING;
-        }
-        NEW_NODE_WITH_CUR_POS(
-            cur_node, (is_double
+      }
+      if (want_node == kENodeOperator) {
+        OP_MISSING;
+      }
+      NEW_NODE_WITH_CUR_POS(cur_node, (is_double
                        ? kExprNodeDoubleQuotedString
                        : kExprNodeSingleQuotedString));
-        *top_node_p = cur_node;
-        parse_quoted_string(pstate, cur_node, cur_token, ast_stack, is_invalid);
-        want_node = kENodeOperator;
-        break;
+      *top_node_p = cur_node;
+      parse_quoted_string(pstate, cur_node, cur_token, ast_stack, is_invalid);
+      want_node = kENodeOperator;
+      break;
+    }
+    case kExprLexAssignment:
+      if (cur_pt == kEPTAssignment) {
+        kv_drop(pt_stack, 1);
+      } else if (cur_pt == kEPTSingleAssignment) {
+        kv_drop(pt_stack, 2);
+        ERROR_FROM_TOKEN_AND_MSG(cur_token,
+                                 _("E475: Expected closing bracket to end list assignment "
+                                   "lvalue: %.*s"));
+      } else {
+        ERROR_FROM_TOKEN_AND_MSG(cur_token, _("E15: Misplaced assignment: %.*s"));
       }
-      case kExprLexAssignment: {
-        if (cur_pt == kEPTAssignment) {
-          kv_drop(pt_stack, 1);
-        } else if (cur_pt == kEPTSingleAssignment) {
-          kv_drop(pt_stack, 2);
-          ERROR_FROM_TOKEN_AND_MSG(
-              cur_token,
-              _("E475: Expected closing bracket to end list assignment "
-                "lvalue: %.*s"));
-        } else {
-          ERROR_FROM_TOKEN_AND_MSG(
-              cur_token, _("E15: Misplaced assignment: %.*s"));
-        }
-        assert(kv_size(pt_stack));
-        assert(kv_last(pt_stack) == kEPTExpr);
-        ADD_VALUE_IF_MISSING(_("E15: Unexpected assignment: %.*s"));
-        NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeAssignment);
-        cur_node->data.ass.type = cur_token.data.ass.type;
-        switch (cur_token.data.ass.type) {
+      assert(kv_size(pt_stack));
+      assert(kv_last(pt_stack) == kEPTExpr);
+      ADD_VALUE_IF_MISSING(_("E15: Unexpected assignment: %.*s"));
+      NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeAssignment);
+      cur_node->data.ass.type = cur_token.data.ass.type;
+      switch (cur_token.data.ass.type) {
 #define HL_ASGN(asgn, hl) \
-          case kExprAsgn##asgn: { HL_CUR_TOKEN(hl); break; }
-          HL_ASGN(Plain, PlainAssignment)
-          HL_ASGN(Add, AssignmentWithAddition)
-          HL_ASGN(Subtract, AssignmentWithSubtraction)
-          HL_ASGN(Concat, AssignmentWithConcatenation)
+case kExprAsgn##asgn: { HL_CUR_TOKEN(hl); break; }
+        HL_ASGN(Plain, PlainAssignment)
+        HL_ASGN(Add, AssignmentWithAddition)
+        HL_ASGN(Subtract, AssignmentWithSubtraction)
+        HL_ASGN(Concat, AssignmentWithConcatenation)
 #undef HL_ASGN
-        }
-        ADD_OP_NODE(cur_node);
-        break;
       }
+      ADD_OP_NODE(cur_node);
+      break;
     }
 viml_pexpr_parse_cycle_end:
     prev_token = cur_token;
@@ -2972,115 +2970,96 @@ viml_pexpr_parse_end:
       assert(cur_node != NULL);
       // TODO(ZyX-I): Rehighlight as invalid?
       switch (cur_node->type) {
-        case kExprNodeOpMissing:
-        case kExprNodeMissing: {
-          // Error should’ve been already reported.
-          break;
-        }
-        case kExprNodeCall: {
-          east_set_error(
-              pstate, &ast.err,
-              _("E116: Missing closing parenthesis for function call: %.*s"),
-              cur_node->start);
-          break;
-        }
-        case kExprNodeNested: {
-          east_set_error(
-              pstate, &ast.err,
-              _("E110: Missing closing parenthesis for nested expression"
-                ": %.*s"),
-              cur_node->start);
-          break;
-        }
-        case kExprNodeListLiteral: {
-          // For whatever reason "[1" yields "E696: Missing comma in list" error
-          // in Vim while "[1," yields E697.
-          east_set_error(
-              pstate, &ast.err,
-              _("E697: Missing end of List ']': %.*s"),
-              cur_node->start);
-          break;
-        }
-        case kExprNodeDictLiteral: {
-          // Same problem like with list literal with E722 (missing comma) vs
-          // E723, but additionally just "{" yields only E15.
-          east_set_error(
-              pstate, &ast.err,
-              _("E723: Missing end of Dictionary '}': %.*s"),
-              cur_node->start);
-          break;
-        }
-        case kExprNodeUnknownFigure: {
-          east_set_error(
-              pstate, &ast.err,
-              _("E15: Missing closing figure brace: %.*s"),
-              cur_node->start);
-          break;
-        }
-        case kExprNodeLambda: {
-          east_set_error(
-              pstate, &ast.err,
-              _("E15: Missing closing figure brace for lambda: %.*s"),
-              cur_node->start);
-          break;
-        }
-        case kExprNodeCurlyBracesIdentifier: {
-          // Until trailing "}" it is impossible to distinguish curly braces
-          // identifier and dictionary, so it must not appear in the stack like
-          // this.
-          abort();
-        }
-        case kExprNodeInteger:
-        case kExprNodeFloat:
-        case kExprNodeSingleQuotedString:
-        case kExprNodeDoubleQuotedString:
-        case kExprNodeOption:
-        case kExprNodeEnvironment:
-        case kExprNodeRegister:
-        case kExprNodePlainIdentifier:
-        case kExprNodePlainKey: {
-          // These are plain values and not containers, for them it should only
-          // be possible to show up in the topmost stack element, but it was
-          // unconditionally popped at the start.
-          abort();
-        }
-        case kExprNodeComma:
-        case kExprNodeColon:
-        case kExprNodeArrow: {
-          // It is actually only valid inside something else, but everything
-          // where one of the above is valid requires to be closed and thus is
-          // to be caught later.
-          break;
-        }
-        case kExprNodeSubscript:
-        case kExprNodeConcatOrSubscript:
-        case kExprNodeComplexIdentifier:
-        case kExprNodeAssignment:
-        case kExprNodeMod:
-        case kExprNodeDivision:
-        case kExprNodeMultiplication:
-        case kExprNodeNot:
-        case kExprNodeAnd:
-        case kExprNodeOr:
-        case kExprNodeConcat:
-        case kExprNodeComparison:
-        case kExprNodeUnaryMinus:
-        case kExprNodeUnaryPlus:
-        case kExprNodeBinaryMinus:
-        case kExprNodeTernary:
-        case kExprNodeBinaryPlus: {
-          // It is OK to see these in the stack.
-          break;
-        }
-        case kExprNodeTernaryValue: {
-          if (!cur_node->data.ter.got_colon) {
-            // Actually Vim throws E109 in more cases.
-            east_set_error(
-                pstate, &ast.err, _("E109: Missing ':' after '?': %.*s"),
-                cur_node->start);
-          }
-          break;
+      case kExprNodeOpMissing:
+      case kExprNodeMissing:
+        // Error should’ve been already reported.
+        break;
+      case kExprNodeCall:
+        east_set_error(pstate, &ast.err,
+                       _("E116: Missing closing parenthesis for function call: %.*s"),
+                       cur_node->start);
+        break;
+      case kExprNodeNested:
+        east_set_error(pstate, &ast.err,
+                       _("E110: Missing closing parenthesis for nested expression"
+                         ": %.*s"),
+                       cur_node->start);
+        break;
+      case kExprNodeListLiteral:
+        // For whatever reason "[1" yields "E696: Missing comma in list" error
+        // in Vim while "[1," yields E697.
+        east_set_error(pstate, &ast.err,
+                       _("E697: Missing end of List ']': %.*s"),
+                       cur_node->start);
+        break;
+      case kExprNodeDictLiteral:
+        // Same problem like with list literal with E722 (missing comma) vs
+        // E723, but additionally just "{" yields only E15.
+        east_set_error(pstate, &ast.err,
+                       _("E723: Missing end of Dictionary '}': %.*s"),
+                       cur_node->start);
+        break;
+      case kExprNodeUnknownFigure:
+        east_set_error(pstate, &ast.err,
+                       _("E15: Missing closing figure brace: %.*s"),
+                       cur_node->start);
+        break;
+      case kExprNodeLambda:
+        east_set_error(pstate, &ast.err,
+                       _("E15: Missing closing figure brace for lambda: %.*s"),
+                       cur_node->start);
+        break;
+      case kExprNodeCurlyBracesIdentifier:
+        // Until trailing "}" it is impossible to distinguish curly braces
+        // identifier and dictionary, so it must not appear in the stack like
+        // this.
+        abort();
+      case kExprNodeInteger:
+      case kExprNodeFloat:
+      case kExprNodeSingleQuotedString:
+      case kExprNodeDoubleQuotedString:
+      case kExprNodeOption:
+      case kExprNodeEnvironment:
+      case kExprNodeRegister:
+      case kExprNodePlainIdentifier:
+      case kExprNodePlainKey:
+        // These are plain values and not containers, for them it should only
+        // be possible to show up in the topmost stack element, but it was
+        // unconditionally popped at the start.
+        abort();
+      case kExprNodeComma:
+      case kExprNodeColon:
+      case kExprNodeArrow:
+        // It is actually only valid inside something else, but everything
+        // where one of the above is valid requires to be closed and thus is
+        // to be caught later.
+        break;
+      case kExprNodeSubscript:
+      case kExprNodeConcatOrSubscript:
+      case kExprNodeComplexIdentifier:
+      case kExprNodeAssignment:
+      case kExprNodeMod:
+      case kExprNodeDivision:
+      case kExprNodeMultiplication:
+      case kExprNodeNot:
+      case kExprNodeAnd:
+      case kExprNodeOr:
+      case kExprNodeConcat:
+      case kExprNodeComparison:
+      case kExprNodeUnaryMinus:
+      case kExprNodeUnaryPlus:
+      case kExprNodeBinaryMinus:
+      case kExprNodeTernary:
+      case kExprNodeBinaryPlus:
+        // It is OK to see these in the stack.
+        break;
+      case kExprNodeTernaryValue:
+        if (!cur_node->data.ter.got_colon) {
+          // Actually Vim throws E109 in more cases.
+          east_set_error(pstate, &ast.err, _("E109: Missing ':' after '?': %.*s"),
+                         cur_node->start);
         }
+        break;
       }
     }
   }