Parser: corpus parse rate 69% -> 81%, and stop --tests from sticking

Grammar: 'using,except(x)' modifiers, '#ifx' with block branches, unions with
parameters, multi-value initializers, mixed 'name:, lvalue = call()' targets,
'push_context' with no explicit context, 'operator []=', '#foreign lib "symbol"',
keyword-named arguments such as 'remove={...}', and '#insert (options) body'.
Directive flags now require adjacency: without it, in
'(callback: (*GUID) #c_call, lpContext: *void)' the flag swallowed ', lpContext'.

procModifier is now just directiveExpr — one rule for directives in both
positions, so fixes apply everywhere.

jaitest: a '--tests' filter persisted through Gradle's configuration cache, so a
later unfiltered ./jaitest silently re-ran only that class and printed OK.
Unfiltered runs now disable the configuration cache.

MIN_CLEAN_FILES ratchets the corpus gate at 575/714.

src/main/gen/dev/hgh/jai/parser/JaiParser.java

@@ -101,12 +101,13 @@ public class JaiParser implements PsiParser, LightPsiParser {
   }
 
   /* ********************************************************** */
-  // '---' | expr
+  // '---' | namedArgument | expr
   public static boolean argument(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "argument")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_, level_, _NONE_, ARGUMENT, "<argument>");
     result_ = consumeToken(builder_, TRIPLE_MINUS);
+    if (!result_) result_ = namedArgument(builder_, level_ + 1);
     if (!result_) result_ = expr(builder_, level_ + 1, -1);
     exit_section_(builder_, level_, marker_, result_, false, null);
     return result_;
@@ -157,6 +158,40 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return result_;
   }
 
+  /* ********************************************************** */
+  // <<exprNoAssign>> (',' <<exprNoAssign>>)*
+  static boolean assignTargets_(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "assignTargets_")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = exprNoAssign(builder_, level_ + 1);
+    result_ = result_ && assignTargets__1(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // (',' <<exprNoAssign>>)*
+  private static boolean assignTargets__1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "assignTargets__1")) return false;
+    while (true) {
+      int pos_ = current_position_(builder_);
+      if (!assignTargets__1_0(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "assignTargets__1", pos_)) break;
+    }
+    return true;
+  }
+
+  // ',' <<exprNoAssign>>
+  private static boolean assignTargets__1_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "assignTargets__1_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, COMMA);
+    result_ = result_ && exprNoAssign(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
   /* ********************************************************** */
   // '`' (IDENT | 'defer' | 'return' | 'push_context' | 'operator')
   public static boolean backtickExpr(PsiBuilder builder_, int level_) {
@@ -326,12 +361,12 @@ public class JaiParser implements PsiParser, LightPsiParser {
   }
 
   /* ********************************************************** */
-  // procModifier | 'using'
+  // procModifier | usingModifier_
   static boolean declModifier_(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "declModifier_")) return false;
     boolean result_;
     result_ = procModifier(builder_, level_ + 1);
-    if (!result_) result_ = consumeToken(builder_, KW_USING);
+    if (!result_) result_ = usingModifier_(builder_, level_ + 1);
     return result_;
   }
 
@@ -391,9 +426,9 @@ public class JaiParser implements PsiParser, LightPsiParser {
   }
 
   /* ********************************************************** */
-  // ':' [<<exprNoAssign>>] procModifier* [('=' | ':') initializer]
-  //                     | ':=' initializer
-  //                     | '::' initializer
+  // ':' [<<exprNoAssign>>] procModifier* [',' assignTargets_] [('=' | ':') initializerList_]
+  //                     | ':=' initializerList_
+  //                     | '::' initializerList_
   static boolean declTail_(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "declTail_")) return false;
     boolean result_;
@@ -405,7 +440,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return result_;
   }
 
-  // ':' [<<exprNoAssign>>] procModifier* [('=' | ':') initializer]
+  // ':' [<<exprNoAssign>>] procModifier* [',' assignTargets_] [('=' | ':') initializerList_]
   private static boolean declTail__0(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "declTail__0")) return false;
     boolean result_;
@@ -414,6 +449,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
     result_ = result_ && declTail__0_1(builder_, level_ + 1);
     result_ = result_ && declTail__0_2(builder_, level_ + 1);
     result_ = result_ && declTail__0_3(builder_, level_ + 1);
+    result_ = result_ && declTail__0_4(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
@@ -436,51 +472,69 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return true;
   }
 
-  // [('=' | ':') initializer]
+  // [',' assignTargets_]
   private static boolean declTail__0_3(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "declTail__0_3")) return false;
     declTail__0_3_0(builder_, level_ + 1);
     return true;
   }
 
-  // ('=' | ':') initializer
+  // ',' assignTargets_
   private static boolean declTail__0_3_0(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "declTail__0_3_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = declTail__0_3_0_0(builder_, level_ + 1);
-    result_ = result_ && initializer(builder_, level_ + 1);
+    result_ = consumeToken(builder_, COMMA);
+    result_ = result_ && assignTargets_(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // [('=' | ':') initializerList_]
+  private static boolean declTail__0_4(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "declTail__0_4")) return false;
+    declTail__0_4_0(builder_, level_ + 1);
+    return true;
+  }
+
+  // ('=' | ':') initializerList_
+  private static boolean declTail__0_4_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "declTail__0_4_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = declTail__0_4_0_0(builder_, level_ + 1);
+    result_ = result_ && initializerList_(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
   // '=' | ':'
-  private static boolean declTail__0_3_0_0(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "declTail__0_3_0_0")) return false;
+  private static boolean declTail__0_4_0_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "declTail__0_4_0_0")) return false;
     boolean result_;
     result_ = consumeToken(builder_, EQ);
     if (!result_) result_ = consumeToken(builder_, COLON);
     return result_;
   }
 
-  // ':=' initializer
+  // ':=' initializerList_
   private static boolean declTail__1(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "declTail__1")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
     result_ = consumeToken(builder_, COLON_EQ);
-    result_ = result_ && initializer(builder_, level_ + 1);
+    result_ = result_ && initializerList_(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
-  // '::' initializer
+  // '::' initializerList_
   private static boolean declTail__2(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "declTail__2")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
     result_ = consumeToken(builder_, COLON_COLON);
-    result_ = result_ && initializer(builder_, level_ + 1);
+    result_ = result_ && initializerList_(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
@@ -534,6 +588,9 @@ public class JaiParser implements PsiParser, LightPsiParser {
 
   /* ********************************************************** */
   // <<dir "#asm">> directiveFlag_* <<opaqueBlock>>
+  //                 | <<dir "#foreign">> directiveFlag_* [<<exprNoAssign>>] [STRING]
+  //                 | <<dir "#elsewhere">> directiveFlag_* [<<exprNoAssign>>] [STRING]
+  //                 | <<dir "#insert">> directiveFlag_* ['(' [argList] ')'] [block | expr]
   //                 | <<dir "#assert">> expr [expr]
   //                 | <<dir "#module_parameters">> '(' [paramList] ')' ['(' [paramList] ')'] [block]
   //                 | <<dirWithBlock>> directiveFlag_* block
@@ -549,6 +606,9 @@ public class JaiParser implements PsiParser, LightPsiParser {
     if (!result_) result_ = directiveExpr_3(builder_, level_ + 1);
     if (!result_) result_ = directiveExpr_4(builder_, level_ + 1);
     if (!result_) result_ = directiveExpr_5(builder_, level_ + 1);
+    if (!result_) result_ = directiveExpr_6(builder_, level_ + 1);
+    if (!result_) result_ = directiveExpr_7(builder_, level_ + 1);
+    if (!result_) result_ = directiveExpr_8(builder_, level_ + 1);
     exit_section_(builder_, level_, marker_, result_, false, null);
     return result_;
   }
@@ -576,88 +636,91 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return true;
   }
 
-  // <<dir "#assert">> expr [expr]
+  // <<dir "#foreign">> directiveFlag_* [<<exprNoAssign>>] [STRING]
   private static boolean directiveExpr_1(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "directiveExpr_1")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = dir(builder_, level_ + 1, "#assert");
-    result_ = result_ && expr(builder_, level_ + 1, -1);
+    result_ = dir(builder_, level_ + 1, "#foreign");
+    result_ = result_ && directiveExpr_1_1(builder_, level_ + 1);
     result_ = result_ && directiveExpr_1_2(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_1_3(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
-  // [expr]
-  private static boolean directiveExpr_1_2(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveExpr_1_2")) return false;
-    expr(builder_, level_ + 1, -1);
+  // directiveFlag_*
+  private static boolean directiveExpr_1_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_1_1")) return false;
+    while (true) {
+      int pos_ = current_position_(builder_);
+      if (!directiveFlag_(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "directiveExpr_1_1", pos_)) break;
+    }
     return true;
   }
 
-  // <<dir "#module_parameters">> '(' [paramList] ')' ['(' [paramList] ')'] [block]
+  // [<<exprNoAssign>>]
+  private static boolean directiveExpr_1_2(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_1_2")) return false;
+    exprNoAssign(builder_, level_ + 1);
+    return true;
+  }
+
+  // [STRING]
+  private static boolean directiveExpr_1_3(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_1_3")) return false;
+    consumeToken(builder_, STRING);
+    return true;
+  }
+
+  // <<dir "#elsewhere">> directiveFlag_* [<<exprNoAssign>>] [STRING]
   private static boolean directiveExpr_2(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "directiveExpr_2")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = dir(builder_, level_ + 1, "#module_parameters");
-    result_ = result_ && consumeToken(builder_, LPAREN);
+    result_ = dir(builder_, level_ + 1, "#elsewhere");
+    result_ = result_ && directiveExpr_2_1(builder_, level_ + 1);
     result_ = result_ && directiveExpr_2_2(builder_, level_ + 1);
-    result_ = result_ && consumeToken(builder_, RPAREN);
-    result_ = result_ && directiveExpr_2_4(builder_, level_ + 1);
-    result_ = result_ && directiveExpr_2_5(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_2_3(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
-  // [paramList]
+  // directiveFlag_*
+  private static boolean directiveExpr_2_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_2_1")) return false;
+    while (true) {
+      int pos_ = current_position_(builder_);
+      if (!directiveFlag_(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "directiveExpr_2_1", pos_)) break;
+    }
+    return true;
+  }
+
+  // [<<exprNoAssign>>]
   private static boolean directiveExpr_2_2(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "directiveExpr_2_2")) return false;
-    paramList(builder_, level_ + 1);
+    exprNoAssign(builder_, level_ + 1);
     return true;
   }
 
-  // ['(' [paramList] ')']
-  private static boolean directiveExpr_2_4(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveExpr_2_4")) return false;
-    directiveExpr_2_4_0(builder_, level_ + 1);
+  // [STRING]
+  private static boolean directiveExpr_2_3(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_2_3")) return false;
+    consumeToken(builder_, STRING);
     return true;
   }
 
-  // '(' [paramList] ')'
-  private static boolean directiveExpr_2_4_0(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveExpr_2_4_0")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_);
-    result_ = consumeToken(builder_, LPAREN);
-    result_ = result_ && directiveExpr_2_4_0_1(builder_, level_ + 1);
-    result_ = result_ && consumeToken(builder_, RPAREN);
-    exit_section_(builder_, marker_, null, result_);
-    return result_;
-  }
-
-  // [paramList]
-  private static boolean directiveExpr_2_4_0_1(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveExpr_2_4_0_1")) return false;
-    paramList(builder_, level_ + 1);
-    return true;
-  }
-
-  // [block]
-  private static boolean directiveExpr_2_5(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveExpr_2_5")) return false;
-    block(builder_, level_ + 1);
-    return true;
-  }
-
-  // <<dirWithBlock>> directiveFlag_* block
+  // <<dir "#insert">> directiveFlag_* ['(' [argList] ')'] [block | expr]
   private static boolean directiveExpr_3(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "directiveExpr_3")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = dirWithBlock(builder_, level_ + 1);
+    result_ = dir(builder_, level_ + 1, "#insert");
     result_ = result_ && directiveExpr_3_1(builder_, level_ + 1);
-    result_ = result_ && block(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_3_2(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_3_3(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
@@ -673,29 +736,60 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return true;
   }
 
-  // <<dirWithOperand>> directiveFlag_* [expr]
-  private static boolean directiveExpr_4(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveExpr_4")) return false;
+  // ['(' [argList] ')']
+  private static boolean directiveExpr_3_2(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_3_2")) return false;
+    directiveExpr_3_2_0(builder_, level_ + 1);
+    return true;
+  }
+
+  // '(' [argList] ')'
+  private static boolean directiveExpr_3_2_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_3_2_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = dirWithOperand(builder_, level_ + 1);
-    result_ = result_ && directiveExpr_4_1(builder_, level_ + 1);
-    result_ = result_ && directiveExpr_4_2(builder_, level_ + 1);
+    result_ = consumeToken(builder_, LPAREN);
+    result_ = result_ && directiveExpr_3_2_0_1(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, RPAREN);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
-  // directiveFlag_*
-  private static boolean directiveExpr_4_1(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveExpr_4_1")) return false;
-    while (true) {
-      int pos_ = current_position_(builder_);
-      if (!directiveFlag_(builder_, level_ + 1)) break;
-      if (!empty_element_parsed_guard_(builder_, "directiveExpr_4_1", pos_)) break;
-    }
+  // [argList]
+  private static boolean directiveExpr_3_2_0_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_3_2_0_1")) return false;
+    argList(builder_, level_ + 1);
     return true;
   }
 
+  // [block | expr]
+  private static boolean directiveExpr_3_3(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_3_3")) return false;
+    directiveExpr_3_3_0(builder_, level_ + 1);
+    return true;
+  }
+
+  // block | expr
+  private static boolean directiveExpr_3_3_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_3_3_0")) return false;
+    boolean result_;
+    result_ = block(builder_, level_ + 1);
+    if (!result_) result_ = expr(builder_, level_ + 1, -1);
+    return result_;
+  }
+
+  // <<dir "#assert">> expr [expr]
+  private static boolean directiveExpr_4(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_4")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = dir(builder_, level_ + 1, "#assert");
+    result_ = result_ && expr(builder_, level_ + 1, -1);
+    result_ = result_ && directiveExpr_4_2(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
   // [expr]
   private static boolean directiveExpr_4_2(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "directiveExpr_4_2")) return false;
@@ -703,38 +797,140 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return true;
   }
 
-  // <<dirPlain>> directiveFlag_*
+  // <<dir "#module_parameters">> '(' [paramList] ')' ['(' [paramList] ')'] [block]
   private static boolean directiveExpr_5(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "directiveExpr_5")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = dirPlain(builder_, level_ + 1);
-    result_ = result_ && directiveExpr_5_1(builder_, level_ + 1);
+    result_ = dir(builder_, level_ + 1, "#module_parameters");
+    result_ = result_ && consumeToken(builder_, LPAREN);
+    result_ = result_ && directiveExpr_5_2(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, RPAREN);
+    result_ = result_ && directiveExpr_5_4(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_5_5(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // [paramList]
+  private static boolean directiveExpr_5_2(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_5_2")) return false;
+    paramList(builder_, level_ + 1);
+    return true;
+  }
+
+  // ['(' [paramList] ')']
+  private static boolean directiveExpr_5_4(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_5_4")) return false;
+    directiveExpr_5_4_0(builder_, level_ + 1);
+    return true;
+  }
+
+  // '(' [paramList] ')'
+  private static boolean directiveExpr_5_4_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_5_4_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, LPAREN);
+    result_ = result_ && directiveExpr_5_4_0_1(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, RPAREN);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // [paramList]
+  private static boolean directiveExpr_5_4_0_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_5_4_0_1")) return false;
+    paramList(builder_, level_ + 1);
+    return true;
+  }
+
+  // [block]
+  private static boolean directiveExpr_5_5(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_5_5")) return false;
+    block(builder_, level_ + 1);
+    return true;
+  }
+
+  // <<dirWithBlock>> directiveFlag_* block
+  private static boolean directiveExpr_6(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_6")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = dirWithBlock(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_6_1(builder_, level_ + 1);
+    result_ = result_ && block(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
   // directiveFlag_*
-  private static boolean directiveExpr_5_1(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveExpr_5_1")) return false;
+  private static boolean directiveExpr_6_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_6_1")) return false;
     while (true) {
       int pos_ = current_position_(builder_);
       if (!directiveFlag_(builder_, level_ + 1)) break;
-      if (!empty_element_parsed_guard_(builder_, "directiveExpr_5_1", pos_)) break;
+      if (!empty_element_parsed_guard_(builder_, "directiveExpr_6_1", pos_)) break;
+    }
+    return true;
+  }
+
+  // <<dirWithOperand>> directiveFlag_* [expr]
+  private static boolean directiveExpr_7(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_7")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = dirWithOperand(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_7_1(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_7_2(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // directiveFlag_*
+  private static boolean directiveExpr_7_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_7_1")) return false;
+    while (true) {
+      int pos_ = current_position_(builder_);
+      if (!directiveFlag_(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "directiveExpr_7_1", pos_)) break;
+    }
+    return true;
+  }
+
+  // [expr]
+  private static boolean directiveExpr_7_2(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_7_2")) return false;
+    expr(builder_, level_ + 1, -1);
+    return true;
+  }
+
+  // <<dirPlain>> directiveFlag_*
+  private static boolean directiveExpr_8(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_8")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = dirPlain(builder_, level_ + 1);
+    result_ = result_ && directiveExpr_8_1(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // directiveFlag_*
+  private static boolean directiveExpr_8_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "directiveExpr_8_1")) return false;
+    while (true) {
+      int pos_ = current_position_(builder_);
+      if (!directiveFlag_(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "directiveExpr_8_1", pos_)) break;
     }
     return true;
   }
 
   /* ********************************************************** */
-  // ',' IDENT
+  // <<directiveFlag>>
   static boolean directiveFlag_(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "directiveFlag_")) return false;
-    if (!nextTokenIs(builder_, COMMA)) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_);
-    result_ = consumeTokens(builder_, 0, COMMA, IDENT);
-    exit_section_(builder_, marker_, null, result_);
-    return result_;
+    return directiveFlag(builder_, level_ + 1);
   }
 
   /* ********************************************************** */
@@ -1059,6 +1255,28 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return true;
   }
 
+  /* ********************************************************** */
+  // block | expr
+  static boolean ifxBranch_(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "ifxBranch_")) return false;
+    boolean result_;
+    result_ = block(builder_, level_ + 1);
+    if (!result_) result_ = expr(builder_, level_ + 1, -1);
+    return result_;
+  }
+
+  /* ********************************************************** */
+  // 'ifx' | <<dir "#ifx">>
+  static boolean ifxKeyword_(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "ifxKeyword_")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, KW_IFX);
+    if (!result_) result_ = dir(builder_, level_ + 1, "#ifx");
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
   /* ********************************************************** */
   // '---' | expr
   public static boolean initializer(PsiBuilder builder_, int level_) {
@@ -1071,6 +1289,40 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return result_;
   }
 
+  /* ********************************************************** */
+  // initializer (',' initializer)*
+  static boolean initializerList_(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "initializerList_")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = initializer(builder_, level_ + 1);
+    result_ = result_ && initializerList__1(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // (',' initializer)*
+  private static boolean initializerList__1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "initializerList__1")) return false;
+    while (true) {
+      int pos_ = current_position_(builder_);
+      if (!initializerList__1_0(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "initializerList__1", pos_)) break;
+    }
+    return true;
+  }
+
+  // ',' initializer
+  private static boolean initializerList__1_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "initializerList__1_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, COMMA);
+    result_ = result_ && initializer(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
   /* ********************************************************** */
   // 'interface' [expr]
   public static boolean interfaceExpr(PsiBuilder builder_, int level_) {
@@ -1168,6 +1420,29 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return result_;
   }
 
+  /* ********************************************************** */
+  // <<isNamedArgumentAhead>> memberName '=' (block | expr)
+  public static boolean namedArgument(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "namedArgument")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_, level_, _NONE_, NAMED_ARGUMENT, "<named argument>");
+    result_ = isNamedArgumentAhead(builder_, level_ + 1);
+    result_ = result_ && memberName(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, EQ);
+    result_ = result_ && namedArgument_3(builder_, level_ + 1);
+    exit_section_(builder_, level_, marker_, result_, false, null);
+    return result_;
+  }
+
+  // block | expr
+  private static boolean namedArgument_3(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "namedArgument_3")) return false;
+    boolean result_;
+    result_ = block(builder_, level_ + 1);
+    if (!result_) result_ = expr(builder_, level_ + 1, -1);
+    return result_;
+  }
+
   /* ********************************************************** */
   // NOTE+
   public static boolean noteStatement(PsiBuilder builder_, int level_) {
@@ -1204,7 +1479,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
   /* ********************************************************** */
   // '+' | '-' | '*' | '/' | '%' | '==' | '!=' | '<' | '>' | '<=' | '>='
   //                  | '&' | '|' | '^' | '~' | '<<' | '>>' | '<<<' | '>>>'
-  //                  | '[' ']' | '[' ']' '='
+  //                  | '[' ']' '=' | '[' ']'
   public static boolean operatorSymbol(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "operatorSymbol")) return false;
     boolean result_;
@@ -1228,8 +1503,8 @@ public class JaiParser implements PsiParser, LightPsiParser {
     if (!result_) result_ = consumeToken(builder_, SHR);
     if (!result_) result_ = consumeToken(builder_, ROL);
     if (!result_) result_ = consumeToken(builder_, ROR);
-    if (!result_) result_ = parseTokens(builder_, 0, LBRACKET, RBRACKET);
     if (!result_) result_ = parseTokens(builder_, 0, LBRACKET, RBRACKET, EQ);
+    if (!result_) result_ = parseTokens(builder_, 0, LBRACKET, RBRACKET);
     exit_section_(builder_, level_, marker_, result_, false, null);
     return result_;
   }
@@ -1648,97 +1923,18 @@ public class JaiParser implements PsiParser, LightPsiParser {
   }
 
   /* ********************************************************** */
-  // <<dirWithBlock>> directiveFlag_* block
-  //                | <<dirWithOperand>> directiveFlag_* [expr]
-  //                | <<dirPlain>> directiveFlag_*
+  // directiveExpr
   public static boolean procModifier(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "procModifier")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_, level_, _NONE_, PROC_MODIFIER, "<proc modifier>");
-    result_ = procModifier_0(builder_, level_ + 1);
-    if (!result_) result_ = procModifier_1(builder_, level_ + 1);
-    if (!result_) result_ = procModifier_2(builder_, level_ + 1);
+    result_ = directiveExpr(builder_, level_ + 1);
     exit_section_(builder_, level_, marker_, result_, false, null);
     return result_;
   }
 
-  // <<dirWithBlock>> directiveFlag_* block
-  private static boolean procModifier_0(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "procModifier_0")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_);
-    result_ = dirWithBlock(builder_, level_ + 1);
-    result_ = result_ && procModifier_0_1(builder_, level_ + 1);
-    result_ = result_ && block(builder_, level_ + 1);
-    exit_section_(builder_, marker_, null, result_);
-    return result_;
-  }
-
-  // directiveFlag_*
-  private static boolean procModifier_0_1(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "procModifier_0_1")) return false;
-    while (true) {
-      int pos_ = current_position_(builder_);
-      if (!directiveFlag_(builder_, level_ + 1)) break;
-      if (!empty_element_parsed_guard_(builder_, "procModifier_0_1", pos_)) break;
-    }
-    return true;
-  }
-
-  // <<dirWithOperand>> directiveFlag_* [expr]
-  private static boolean procModifier_1(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "procModifier_1")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_);
-    result_ = dirWithOperand(builder_, level_ + 1);
-    result_ = result_ && procModifier_1_1(builder_, level_ + 1);
-    result_ = result_ && procModifier_1_2(builder_, level_ + 1);
-    exit_section_(builder_, marker_, null, result_);
-    return result_;
-  }
-
-  // directiveFlag_*
-  private static boolean procModifier_1_1(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "procModifier_1_1")) return false;
-    while (true) {
-      int pos_ = current_position_(builder_);
-      if (!directiveFlag_(builder_, level_ + 1)) break;
-      if (!empty_element_parsed_guard_(builder_, "procModifier_1_1", pos_)) break;
-    }
-    return true;
-  }
-
-  // [expr]
-  private static boolean procModifier_1_2(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "procModifier_1_2")) return false;
-    expr(builder_, level_ + 1, -1);
-    return true;
-  }
-
-  // <<dirPlain>> directiveFlag_*
-  private static boolean procModifier_2(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "procModifier_2")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_);
-    result_ = dirPlain(builder_, level_ + 1);
-    result_ = result_ && procModifier_2_1(builder_, level_ + 1);
-    exit_section_(builder_, marker_, null, result_);
-    return result_;
-  }
-
-  // directiveFlag_*
-  private static boolean procModifier_2_1(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "procModifier_2_1")) return false;
-    while (true) {
-      int pos_ = current_position_(builder_);
-      if (!directiveFlag_(builder_, level_ + 1)) break;
-      if (!empty_element_parsed_guard_(builder_, "procModifier_2_1", pos_)) break;
-    }
-    return true;
-  }
-
   /* ********************************************************** */
-  // ['`'] 'push_context' expr block
+  // ['`'] 'push_context' [expr] block
   public static boolean pushContextStatement(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "pushContextStatement")) return false;
     if (!nextTokenIs(builder_, "<push context statement>", BACKTICK, KW_PUSH_CONTEXT)) return false;
@@ -1746,7 +1942,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
     Marker marker_ = enter_section_(builder_, level_, _NONE_, PUSH_CONTEXT_STATEMENT, "<push context statement>");
     result_ = pushContextStatement_0(builder_, level_ + 1);
     result_ = result_ && consumeToken(builder_, KW_PUSH_CONTEXT);
-    result_ = result_ && expr(builder_, level_ + 1, -1);
+    result_ = result_ && pushContextStatement_2(builder_, level_ + 1);
     result_ = result_ && block(builder_, level_ + 1);
     exit_section_(builder_, level_, marker_, result_, false, null);
     return result_;
@@ -1759,6 +1955,13 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return true;
   }
 
+  // [expr]
+  private static boolean pushContextStatement_2(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "pushContextStatement_2")) return false;
+    expr(builder_, level_ + 1, -1);
+    return true;
+  }
+
   /* ********************************************************** */
   // IDENT
   public static boolean refExpr(PsiBuilder builder_, int level_) {
@@ -2228,7 +2431,7 @@ public class JaiParser implements PsiParser, LightPsiParser {
   }
 
   /* ********************************************************** */
-  // 'union' structModifier_* block
+  // 'union' ['(' [paramList] ')'] structModifier_* block
   public static boolean unionExpr(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "unionExpr")) return false;
     if (!nextTokenIs(builder_, KW_UNION)) return false;
@@ -2236,22 +2439,106 @@ public class JaiParser implements PsiParser, LightPsiParser {
     Marker marker_ = enter_section_(builder_);
     result_ = consumeToken(builder_, KW_UNION);
     result_ = result_ && unionExpr_1(builder_, level_ + 1);
+    result_ = result_ && unionExpr_2(builder_, level_ + 1);
     result_ = result_ && block(builder_, level_ + 1);
     exit_section_(builder_, marker_, UNION_EXPR, result_);
     return result_;
   }
 
-  // structModifier_*
+  // ['(' [paramList] ')']
   private static boolean unionExpr_1(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "unionExpr_1")) return false;
+    unionExpr_1_0(builder_, level_ + 1);
+    return true;
+  }
+
+  // '(' [paramList] ')'
+  private static boolean unionExpr_1_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "unionExpr_1_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, LPAREN);
+    result_ = result_ && unionExpr_1_0_1(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, RPAREN);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // [paramList]
+  private static boolean unionExpr_1_0_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "unionExpr_1_0_1")) return false;
+    paramList(builder_, level_ + 1);
+    return true;
+  }
+
+  // structModifier_*
+  private static boolean unionExpr_2(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "unionExpr_2")) return false;
     while (true) {
       int pos_ = current_position_(builder_);
       if (!structModifier_(builder_, level_ + 1)) break;
-      if (!empty_element_parsed_guard_(builder_, "unionExpr_1", pos_)) break;
+      if (!empty_element_parsed_guard_(builder_, "unionExpr_2", pos_)) break;
     }
     return true;
   }
 
+  /* ********************************************************** */
+  // 'using' [directiveFlag_ ['(' [argList] ')']]
+  static boolean usingModifier_(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "usingModifier_")) return false;
+    if (!nextTokenIs(builder_, KW_USING)) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, KW_USING);
+    result_ = result_ && usingModifier__1(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // [directiveFlag_ ['(' [argList] ')']]
+  private static boolean usingModifier__1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "usingModifier__1")) return false;
+    usingModifier__1_0(builder_, level_ + 1);
+    return true;
+  }
+
+  // directiveFlag_ ['(' [argList] ')']
+  private static boolean usingModifier__1_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "usingModifier__1_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = directiveFlag_(builder_, level_ + 1);
+    result_ = result_ && usingModifier__1_0_1(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // ['(' [argList] ')']
+  private static boolean usingModifier__1_0_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "usingModifier__1_0_1")) return false;
+    usingModifier__1_0_1_0(builder_, level_ + 1);
+    return true;
+  }
+
+  // '(' [argList] ')'
+  private static boolean usingModifier__1_0_1_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "usingModifier__1_0_1_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, LPAREN);
+    result_ = result_ && usingModifier__1_0_1_0_1(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, RPAREN);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // [argList]
+  private static boolean usingModifier__1_0_1_0_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "usingModifier__1_0_1_0_1")) return false;
+    argList(builder_, level_ + 1);
+    return true;
+  }
+
   /* ********************************************************** */
   // 'using' [',' expr] expr semi
   public static boolean usingStatement(PsiBuilder builder_, int level_) {
@@ -2643,18 +2930,17 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return result_;
   }
 
-  // 'ifx' expr ['then'] [expr] ['else' expr]
+  // ifxKeyword_ expr ['then'] [ifxBranch_] ['else' ifxBranch_]
   public static boolean ifxExpr(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "ifxExpr")) return false;
-    if (!nextTokenIsSmart(builder_, KW_IFX)) return false;
     boolean result_;
-    Marker marker_ = enter_section_(builder_);
-    result_ = consumeTokenSmart(builder_, KW_IFX);
+    Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, IFX_EXPR, "<ifx expr>");
+    result_ = ifxKeyword_(builder_, level_ + 1);
     result_ = result_ && expr(builder_, level_ + 1, -1);
     result_ = result_ && ifxExpr_2(builder_, level_ + 1);
     result_ = result_ && ifxExpr_3(builder_, level_ + 1);
     result_ = result_ && ifxExpr_4(builder_, level_ + 1);
-    exit_section_(builder_, marker_, IFX_EXPR, result_);
+    exit_section_(builder_, level_, marker_, result_, false, null);
     return result_;
   }
 
@@ -2665,27 +2951,27 @@ public class JaiParser implements PsiParser, LightPsiParser {
     return true;
   }
 
-  // [expr]
+  // [ifxBranch_]
   private static boolean ifxExpr_3(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "ifxExpr_3")) return false;
-    expr(builder_, level_ + 1, -1);
+    ifxBranch_(builder_, level_ + 1);
     return true;
   }
 
-  // ['else' expr]
+  // ['else' ifxBranch_]
   private static boolean ifxExpr_4(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "ifxExpr_4")) return false;
     ifxExpr_4_0(builder_, level_ + 1);
     return true;
   }
 
-  // 'else' expr
+  // 'else' ifxBranch_
   private static boolean ifxExpr_4_0(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "ifxExpr_4_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
     result_ = consumeTokenSmart(builder_, KW_ELSE);
-    result_ = result_ && expr(builder_, level_ + 1, -1);
+    result_ = result_ && ifxBranch_(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }

src/main/gen/dev/hgh/jai/psi/JaiArgument.java

@@ -10,4 +10,7 @@ public interface JaiArgument extends PsiElement {
   @Nullable
   JaiExpr getExpr();
 
+  @Nullable
+  JaiNamedArgument getNamedArgument();
+
 }

src/main/gen/dev/hgh/jai/psi/JaiDeclaration.java

@@ -7,11 +7,14 @@ import com.intellij.psi.PsiElement;
 
 public interface JaiDeclaration extends PsiElement {
 
+  @NotNull
+  List<JaiArgument> getArgumentList();
+
   @NotNull
   JaiDeclNames getDeclNames();
 
-  @Nullable
-  JaiInitializer getInitializer();
+  @NotNull
+  List<JaiInitializer> getInitializerList();
 
   @NotNull
   List<JaiProcModifier> getProcModifierList();

src/main/gen/dev/hgh/jai/psi/JaiDirectiveExpr.java

@@ -7,11 +7,14 @@ import com.intellij.psi.PsiElement;
 
 public interface JaiDirectiveExpr extends JaiExpr {
 
+  @NotNull
+  List<JaiArgument> getArgumentList();
+
   @Nullable
   JaiBlock getBlock();
 
-  @NotNull
-  List<JaiExpr> getExprList();
+  @Nullable
+  JaiExpr getExpr();
 
   @NotNull
   List<JaiParameter> getParameterList();

src/main/gen/dev/hgh/jai/psi/JaiIfxExpr.java

@@ -7,6 +7,9 @@ import com.intellij.psi.PsiElement;
 
 public interface JaiIfxExpr extends JaiExpr {
 
+  @NotNull
+  List<JaiBlock> getBlockList();
+
   @NotNull
   List<JaiExpr> getExprList();
 

src/main/gen/dev/hgh/jai/psi/JaiNamedArgument.java

@@ -0,0 +1,19 @@
+// This is a generated file. Not intended for manual editing.
+package dev.hgh.jai.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface JaiNamedArgument extends PsiElement {
+
+  @Nullable
+  JaiBlock getBlock();
+
+  @Nullable
+  JaiExpr getExpr();
+
+  @NotNull
+  JaiMemberName getMemberName();
+
+}

src/main/gen/dev/hgh/jai/psi/JaiProcModifier.java

@@ -7,10 +7,7 @@ import com.intellij.psi.PsiElement;
 
 public interface JaiProcModifier extends PsiElement {
 
-  @Nullable
-  JaiBlock getBlock();
-
-  @Nullable
-  JaiExpr getExpr();
+  @NotNull
+  JaiDirectiveExpr getDirectiveExpr();
 
 }

src/main/gen/dev/hgh/jai/psi/JaiPushContextStatement.java

@@ -10,7 +10,7 @@ public interface JaiPushContextStatement extends PsiElement {
   @NotNull
   JaiBlock getBlock();
 
-  @NotNull
+  @Nullable
   JaiExpr getExpr();
 
 }

src/main/gen/dev/hgh/jai/psi/JaiTypes.java

@@ -53,6 +53,7 @@ public interface JaiTypes {
   IElementType MEMBER_EXPR = new JaiElementType("MEMBER_EXPR");
   IElementType MEMBER_NAME = new JaiElementType("MEMBER_NAME");
   IElementType MUL_EXPR = new JaiElementType("MUL_EXPR");
+  IElementType NAMED_ARGUMENT = new JaiElementType("NAMED_ARGUMENT");
   IElementType NOTE_STATEMENT = new JaiElementType("NOTE_STATEMENT");
   IElementType OPERATOR_DECLARATION = new JaiElementType("OPERATOR_DECLARATION");
   IElementType OPERATOR_SYMBOL = new JaiElementType("OPERATOR_SYMBOL");
@@ -327,6 +328,9 @@ public interface JaiTypes {
       else if (type == MUL_EXPR) {
         return new JaiMulExprImpl(node);
       }
+      else if (type == NAMED_ARGUMENT) {
+        return new JaiNamedArgumentImpl(node);
+      }
       else if (type == NOTE_STATEMENT) {
         return new JaiNoteStatementImpl(node);
       }

src/main/gen/dev/hgh/jai/psi/JaiUnionExpr.java

@@ -10,6 +10,9 @@ public interface JaiUnionExpr extends JaiExpr {
   @NotNull
   JaiBlock getBlock();
 
+  @NotNull
+  List<JaiParameter> getParameterList();
+
   @NotNull
   List<JaiProcModifier> getProcModifierList();
 

src/main/gen/dev/hgh/jai/psi/JaiVisitor.java

@@ -183,6 +183,10 @@ public class JaiVisitor extends PsiElementVisitor {
     visitExpr(o);
   }
 
+  public void visitNamedArgument(@NotNull JaiNamedArgument o) {
+    visitPsiElement(o);
+  }
+
   public void visitNoteStatement(@NotNull JaiNoteStatement o) {
     visitPsiElement(o);
   }

src/main/gen/dev/hgh/jai/psi/impl/JaiArgumentImpl.java

@@ -33,4 +33,10 @@ public class JaiArgumentImpl extends ASTWrapperPsiElement implements JaiArgument
     return findChildByClass(JaiExpr.class);
   }
 
+  @Override
+  @Nullable
+  public JaiNamedArgument getNamedArgument() {
+    return findChildByClass(JaiNamedArgument.class);
+  }
+
 }

src/main/gen/dev/hgh/jai/psi/impl/JaiDeclarationImpl.java

@@ -27,6 +27,12 @@ public class JaiDeclarationImpl extends ASTWrapperPsiElement implements JaiDecla
     else super.accept(visitor);
   }
 
+  @Override
+  @NotNull
+  public List<JaiArgument> getArgumentList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiArgument.class);
+  }
+
   @Override
   @NotNull
   public JaiDeclNames getDeclNames() {
@@ -34,9 +40,9 @@ public class JaiDeclarationImpl extends ASTWrapperPsiElement implements JaiDecla
   }
 
   @Override
-  @Nullable
-  public JaiInitializer getInitializer() {
-    return findChildByClass(JaiInitializer.class);
+  @NotNull
+  public List<JaiInitializer> getInitializerList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiInitializer.class);
   }
 
   @Override

src/main/gen/dev/hgh/jai/psi/impl/JaiDirectiveExprImpl.java

@@ -27,6 +27,12 @@ public class JaiDirectiveExprImpl extends JaiExprImpl implements JaiDirectiveExp
     else super.accept(visitor);
   }
 
+  @Override
+  @NotNull
+  public List<JaiArgument> getArgumentList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiArgument.class);
+  }
+
   @Override
   @Nullable
   public JaiBlock getBlock() {
@@ -34,9 +40,9 @@ public class JaiDirectiveExprImpl extends JaiExprImpl implements JaiDirectiveExp
   }
 
   @Override
-  @NotNull
-  public List<JaiExpr> getExprList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiExpr.class);
+  @Nullable
+  public JaiExpr getExpr() {
+    return findChildByClass(JaiExpr.class);
   }
 
   @Override

src/main/gen/dev/hgh/jai/psi/impl/JaiIfxExprImpl.java

@@ -27,6 +27,12 @@ public class JaiIfxExprImpl extends JaiExprImpl implements JaiIfxExpr {
     else super.accept(visitor);
   }
 
+  @Override
+  @NotNull
+  public List<JaiBlock> getBlockList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiBlock.class);
+  }
+
   @Override
   @NotNull
   public List<JaiExpr> getExprList() {

src/main/gen/dev/hgh/jai/psi/impl/JaiNamedArgumentImpl.java

@@ -0,0 +1,48 @@
+// This is a generated file. Not intended for manual editing.
+package dev.hgh.jai.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static dev.hgh.jai.psi.JaiTypes.*;
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import dev.hgh.jai.psi.*;
+
+public class JaiNamedArgumentImpl extends ASTWrapperPsiElement implements JaiNamedArgument {
+
+  public JaiNamedArgumentImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  public void accept(@NotNull JaiVisitor visitor) {
+    visitor.visitNamedArgument(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof JaiVisitor) accept((JaiVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+  @Override
+  @Nullable
+  public JaiBlock getBlock() {
+    return findChildByClass(JaiBlock.class);
+  }
+
+  @Override
+  @Nullable
+  public JaiExpr getExpr() {
+    return findChildByClass(JaiExpr.class);
+  }
+
+  @Override
+  @NotNull
+  public JaiMemberName getMemberName() {
+    return findNotNullChildByClass(JaiMemberName.class);
+  }
+
+}

src/main/gen/dev/hgh/jai/psi/impl/JaiProcModifierImpl.java

@@ -28,15 +28,9 @@ public class JaiProcModifierImpl extends ASTWrapperPsiElement implements JaiProc
   }
 
   @Override
-  @Nullable
-  public JaiBlock getBlock() {
-    return findChildByClass(JaiBlock.class);
-  }
-
-  @Override
-  @Nullable
-  public JaiExpr getExpr() {
-    return findChildByClass(JaiExpr.class);
+  @NotNull
+  public JaiDirectiveExpr getDirectiveExpr() {
+    return findNotNullChildByClass(JaiDirectiveExpr.class);
   }
 
 }

src/main/gen/dev/hgh/jai/psi/impl/JaiPushContextStatementImpl.java

@@ -34,9 +34,9 @@ public class JaiPushContextStatementImpl extends ASTWrapperPsiElement implements
   }
 
   @Override
-  @NotNull
+  @Nullable
   public JaiExpr getExpr() {
-    return findNotNullChildByClass(JaiExpr.class);
+    return findChildByClass(JaiExpr.class);
   }
 
 }

src/main/gen/dev/hgh/jai/psi/impl/JaiUnionExprImpl.java

@@ -33,6 +33,12 @@ public class JaiUnionExprImpl extends JaiExprImpl implements JaiUnionExpr {
     return findNotNullChildByClass(JaiBlock.class);
   }
 
+  @Override
+  @NotNull
+  public List<JaiParameter> getParameterList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, JaiParameter.class);
+  }
+
   @Override
   @NotNull
   public List<JaiProcModifier> getProcModifierList() {