We can now use concept sets in BNF definitions

parsers/ConceptLexerParser.py

@@ -269,8 +269,12 @@ class ConceptExpression(ParsingExpression):
         if isinstance(self.concept, Concept):
             return self.concept.name == other.concept.name
 
+        # when it's only the name of the concept
         return self.concept == other.concept
 
+    def __hash__(self):
+        return hash((self.concept, self.rule_name))
+
     @staticmethod
     def get_parsing_expression_from_name(name):
         tokens = Tokenizer(name)
@@ -302,6 +306,29 @@ class ConceptExpression(ParsingExpression):
         return NonTerminalNode(self, node.start, node.end, parser.tokens[node.start: node.end + 1], [node])
 
 
+class ConceptGroupExpression(ConceptExpression):
+    def _parse(self, parser):
+        to_match = parser.get_concept(self.concept) if isinstance(self.concept, str) else self.concept
+        if parser.sheerka.isinstance(to_match, BuiltinConcepts.UNKNOWN_CONCEPT):
+            return None
+
+        self.concept = to_match  # Memoize
+
+        if to_match not in parser.concepts_grammars:
+            concepts_in_group = parser.sheerka.get_set_elements(self.concept)
+            nodes = [ConceptExpression(c, rule_name=c.name) for c in concepts_in_group]
+            expr = OrderedChoice(nodes)
+            expr.nodes = nodes
+            node = expr.parse(parser)
+        else:
+            node = parser.concepts_grammars[to_match].parse(parser)
+
+        if node is None:
+            return None
+
+        return NonTerminalNode(self, node.start, node.end, parser.tokens[node.start: node.end + 1], [node])
+
+
 class Sequence(ParsingExpression):
     """
     Will match sequence of parser expressions in exact order they are defined.
@@ -667,7 +694,10 @@ class ConceptLexerParser(BaseParser):
         # A copy must be created
         def inner_get_model(expression):
             if isinstance(expression, Concept):
-                ret = ConceptExpression(expression, rule_name=expression.name)
+                if self.sheerka.isagroup(expression):
+                    ret = ConceptGroupExpression(expression, rule_name=expression.name)
+                else:
+                    ret = ConceptExpression(expression, rule_name=expression.name)
                 concepts_to_resolve.add(expression)
             elif isinstance(expression, ConceptExpression):
                 if expression.rule_name is None or expression.rule_name == "":