RGH: fix meta rule cardinality merge

Author: gregsh

src/org/intellij/grammar/generator/RuleGraphHelper.java

@@ -443,7 +443,8 @@ else if (isPrivateOrNoType(metaRule)) {
               if (idx > -1 && idx < arguments.size()) {
                 Map<PsiElement, Cardinality> argMap = collectMembers(rule, arguments.get(idx), visited);
                 for (PsiElement element : argMap.keySet()) {
-                  result.put(element, cardinality.and(argMap.get(element)));
+                  Cardinality existing = ObjectUtils.notNull(result.get(element), NONE);
+                  result.put(element, existing.or(cardinality.and(argMap.get(element))));
                 }
               }
             }

testData/generator/ExternalRules.bnf

@@ -4,12 +4,16 @@
   parserUtilClass="org.intellij.grammar.parser.GeneratedParserUtilBase"
   tokens=[
     perc='%'
+    paren1='('
+    paren2=')'
+    comma=','
     perc_re='regexp:\%'
   ]
 }
 
 // external parsing
 root ::= <<listOf statement>>
+external ref ::= parseRef
 external unique_list_of ::= uniqueListOf
 external unique_list_of_params ::= uniqueListOf <<p1>> "1+1" <<p2>> '1+1'
 external empty_external ::=
@@ -47,6 +51,10 @@ private multi_level ::= <<meta_multi_level one>>
 private meta_seq_of_lists_opt ::= (<<list_of_lists one (one | two)>>)?
 private meta_multi_level_no_closure ::= <<comma_list <<comma_list <<comma_list some>>>>>>
 
+private meta comma_paren_list ::= '(' <<param>> (',' <<param>>) * ')' {pin=1}
+public_paren_list ::= <<comma_paren_list (ref | '(' one ')')>>
+public_paren_list2 ::= {elementType=public_paren_list}
+
 // mixed
 private meta meta_mixed ::= <<listOf "1+2" '1+2' <<param>>>>
 private meta_mixed_simple ::= <<meta_mixed statement>>
@@ -82,6 +90,7 @@ private one_list_par ::= <<listOf (one)>>
 private meta second_class_meta ::= <<bmp>>
 private main_class_meta_usage_from_second ::= <<comma_list <<main_class_meta some>>>>
 private third_class_meta_usage_from_second ::= <<comma_list <<third_class_meta some>>>>
+extra_root ::= {extraRoot=true}
 
 ;{
   parserClass="ExternalRules3"

testData/generator/ExternalRules.expected.java

@@ -29,11 +29,22 @@ public void parseLight(IElementType root_, PsiBuilder builder_) {
       result_ = parse_root_(root_, builder_, 0);
     }
     else {
-      result_ = false;
+      result_ = parse_extra_roots_(root_, builder_, 0);
     }
     exit_section_(builder_, 0, marker_, root_, result_, true, TRUE_CONDITION);
   }
 
+  static boolean parse_extra_roots_(IElementType root_, PsiBuilder builder_, int level_) {
+    boolean result_;
+    if (root_ == EXTRA_ROOT) {
+      result_ = ExternalRules2.extra_root(builder_, level_ + 1);
+    }
+    else {
+      result_ = false;
+    }
+    return result_;
+  }
+
   protected boolean parse_root_(IElementType root_, PsiBuilder builder_, int level_) {
     return root(builder_, level_ + 1);
   }
@@ -96,7 +107,7 @@ private static boolean comma_list_1_0(PsiBuilder builder_, int level_, Parser pa
     if (!recursion_guard_(builder_, level_, "comma_list_1_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = consumeToken(builder_, ",");
+    result_ = consumeToken(builder_, COMMA);
     result_ = result_ && param.parse(builder_, level_);
     exit_section_(builder_, marker_, null, result_);
     return result_;
@@ -143,15 +154,54 @@ private static boolean comma_list_pinned_2_0(PsiBuilder builder_, int level_, Pa
   // ',' <<param>>
   public static boolean comma_list_tail(PsiBuilder builder_, int level_, Parser param) {
     if (!recursion_guard_(builder_, level_, "comma_list_tail")) return false;
+    if (!nextTokenIs(builder_, COMMA)) return false;
     boolean result_, pinned_;
     Marker marker_ = enter_section_(builder_, level_, _NONE_, COMMA_LIST_TAIL, null);
-    result_ = consumeToken(builder_, ",");
+    result_ = consumeToken(builder_, COMMA);
     pinned_ = result_; // pin = 1
     result_ = result_ && param.parse(builder_, level_);
     exit_section_(builder_, level_, marker_, result_, pinned_, null);
     return result_ || pinned_;
   }
 
+  /* ********************************************************** */
+  // '(' <<param>> (',' <<param>>) * ')'
+  static boolean comma_paren_list(PsiBuilder builder_, int level_, Parser param) {
+    if (!recursion_guard_(builder_, level_, "comma_paren_list")) return false;
+    if (!nextTokenIs(builder_, PAREN1)) return false;
+    boolean result_, pinned_;
+    Marker marker_ = enter_section_(builder_, level_, _NONE_);
+    result_ = consumeToken(builder_, PAREN1);
+    pinned_ = result_; // pin = 1
+    result_ = result_ && report_error_(builder_, param.parse(builder_, level_));
+    result_ = pinned_ && report_error_(builder_, comma_paren_list_2(builder_, level_ + 1, param)) && result_;
+    result_ = pinned_ && consumeToken(builder_, PAREN2) && result_;
+    exit_section_(builder_, level_, marker_, result_, pinned_, null);
+    return result_ || pinned_;
+  }
+
+  // (',' <<param>>) *
+  private static boolean comma_paren_list_2(PsiBuilder builder_, int level_, Parser param) {
+    if (!recursion_guard_(builder_, level_, "comma_paren_list_2")) return false;
+    while (true) {
+      int pos_ = current_position_(builder_);
+      if (!comma_paren_list_2_0(builder_, level_ + 1, param)) break;
+      if (!empty_element_parsed_guard_(builder_, "comma_paren_list_2", pos_)) break;
+    }
+    return true;
+  }
+
+  // ',' <<param>>
+  private static boolean comma_paren_list_2_0(PsiBuilder builder_, int level_, Parser param) {
+    if (!recursion_guard_(builder_, level_, "comma_paren_list_2_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, COMMA);
+    result_ = result_ && param.parse(builder_, level_);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
   /* ********************************************************** */
   // empty_external
   static boolean empty_external_usage(PsiBuilder builder_, int level_) {
@@ -180,9 +230,9 @@ private static boolean item_recover_0(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "item_recover_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = consumeToken(builder_, ",");
+    result_ = consumeToken(builder_, COMMA);
     if (!result_) result_ = consumeToken(builder_, ";");
-    if (!result_) result_ = consumeToken(builder_, ")");
+    if (!result_) result_ = consumeToken(builder_, PAREN2);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
@@ -633,6 +683,48 @@ static boolean perc_re_list2(PsiBuilder builder_, int level_) {
     return listOf(builder_, level_ + 1, perc_re_list2_0_0_parser_);
   }
 
+  /* ********************************************************** */
+  // <<comma_paren_list (ref | '(' one ')')>>
+  public static boolean public_paren_list(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "public_paren_list")) return false;
+    if (!nextTokenIs(builder_, PAREN1)) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = comma_paren_list(builder_, level_ + 1, public_paren_list_0_0_parser_);
+    exit_section_(builder_, marker_, PUBLIC_PAREN_LIST, result_);
+    return result_;
+  }
+
+  // ref | '(' one ')'
+  private static boolean public_paren_list_0_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "public_paren_list_0_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = parseRef(builder_, level_ + 1);
+    if (!result_) result_ = public_paren_list_0_0_1(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // '(' one ')'
+  private static boolean public_paren_list_0_0_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "public_paren_list_0_0_1")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, PAREN1);
+    result_ = result_ && one(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, PAREN2);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  /* ********************************************************** */
+  public static boolean public_paren_list2(PsiBuilder builder_, int level_) {
+    Marker marker_ = enter_section_(builder_);
+    exit_section_(builder_, marker_, PUBLIC_PAREN_LIST, true);
+    return true;
+  }
+
   /* ********************************************************** */
   // <<param>>
   static boolean recoverable_item(PsiBuilder builder_, int level_, Parser param) {
@@ -799,6 +891,11 @@ public boolean parse(PsiBuilder builder_, int level_) {
     }
   };
   static final Parser perc_re_list2_0_0_parser_ = PERC_RE_parser_;
+  static final Parser public_paren_list_0_0_parser_ = new Parser() {
+    public boolean parse(PsiBuilder builder_, int level_) {
+      return public_paren_list_0_0(builder_, level_ + 1);
+    }
+  };
   static final Parser statement_parser_ = new Parser() {
     public boolean parse(PsiBuilder builder_, int level_) {
       return statement(builder_, level_ + 1);
@@ -828,6 +925,13 @@ public boolean parse(PsiBuilder builder_, int level_) {
 @SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"})
 public class ExternalRules2 {
 
+  /* ********************************************************** */
+  public static boolean extra_root(PsiBuilder builder_, int level_) {
+    Marker marker_ = enter_section_(builder_);
+    exit_section_(builder_, marker_, EXTRA_ROOT, true);
+    return true;
+  }
+
   /* ********************************************************** */
   // <<comma_list <<main_class_meta some>>>>
   static boolean main_class_meta_usage_from_second(PsiBuilder builder_, int level_) {