I can manage infinite recursion when building concept

src/core/sheerka/services/SheerkaEvaluateConcept.py

@@ -9,6 +9,7 @@ from core.sheerka.services.SheerkaExecute import ParserInput
 from core.sheerka.services.sheerka_service import BaseService
 from core.tokenizer import Tokenizer
 from core.utils import unstr_concept
+from parsers.BaseNodeParser import ConceptNode
 from parsers.ExpressionParser import ExpressionParser, TrueifyVisitor
 
 CONCEPT_EVALUATION_STEPS = [
@@ -17,6 +18,11 @@ CONCEPT_EVALUATION_STEPS = [
     BuiltinConcepts.AFTER_EVALUATION]
 
 
+@dataclass
+class ChickenAndEggException(Exception):
+    error: Concept
+
+
 @dataclass
 class WhereClauseDef:
     concept: Concept  # concept on which the where clause is applied
@@ -148,6 +154,27 @@ class SheerkaEvaluateConcept(BaseService):
         else:
             return None
 
+    def get_recursive_definitions(self, concept, return_values):
+        """
+        Returns the name of the parsers that will resolve to a recursive evaluation
+        :param concept:
+        :param return_values:
+        :return:
+        """
+        if concept.name in concept.variables():
+            # There is a variable with the same name as the concept
+            # During evaluation, inner variables take precedence other concepts
+            # So there won't be any cyclic reference, the variable will be picked
+            return
+        for parser in [r.body for r in return_values if
+                       r.status and self.sheerka.isinstance(r.body, BuiltinConcepts.PARSER_RESULT)]:
+            parsed = parser.body if isinstance(parser.body, list) else [parser.body]
+            for parsed_item in parsed:
+                if isinstance(parsed_item, Concept) and parsed_item.id == concept.id:
+                    yield parser.parser
+                elif isinstance(parsed_item, ConceptNode) and parsed_item.concept.id == concept.id:
+                    yield parser.parser
+
     def apply_where_clause(self, context, where_clause_def, return_values):
         """
         Apply intermediate where clause when evaluating concept variables
@@ -225,14 +252,57 @@ class SheerkaEvaluateConcept(BaseService):
         """
 
         def is_only_successful(r):
+            """
+
+            :param r: return_value
+            :return:
+            """
             return context.sheerka.isinstance(r, BuiltinConcepts.RETURN_VALUE) and \
                    context.sheerka.isinstance(r.body, BuiltinConcepts.ONLY_SUCCESSFUL)
 
         def parse_token_concept(s):
+            """
+
+            :param s: source
+            :return:
+            """
             if s.startswith("c:") and (identifier := unstr_concept(s)) != (None, None):
                 return self.sheerka.fast_resolve(identifier)
             return None
 
+        def get_return_value(current_context, c, s, p):
+            """
+
+            :param current_context:
+            :param c: concept
+            :param s: source
+            :param p: part of the concept being parsed
+            :return:
+            """
+            while True:
+                return_value = parse_unrecognized(current_context,
+                                                  s,
+                                                  parsers="all",
+                                                  prop=p,
+                                                  filter_func=only_successful)
+
+                if not return_value.status:
+                    if current_context.preprocess:
+                        raise ChickenAndEggException(self.sheerka.new(BuiltinConcepts.CHICKEN_AND_EGG, body={c}))
+                    else:
+                        raise Exception(f"Failed to build '{s}'. But it doesn't seems to be recursion")
+
+                return_value = return_value.body.body if is_only_successful(return_value) else [return_value]
+                recursive_parsers = list(self.get_recursive_definitions(c, return_value))
+
+                if len(recursive_parsers) == 0:
+                    return return_value
+
+                desc = f"Removing parsers {recursive_parsers}"
+                current_context = current_context.push(context.action, context.action_context, desc=desc)
+                for recursive_parser in recursive_parsers:
+                    current_context.add_preprocess(recursive_parser.name, enabled=False)
+
         for part_key in AllConceptParts:
             if part_key in concept.get_compiled():
                 continue
@@ -253,12 +323,7 @@ class SheerkaEvaluateConcept(BaseService):
                     concept.get_compiled()[part_key] = concept_found
                 else:
                     # ...or a list of ReturnValueConcept to resolve
-                    res = parse_unrecognized(context,
-                                             source,
-                                             parsers="all",
-                                             prop=part_key,
-                                             filter_func=only_successful)
-                    concept.get_compiled()[part_key] = res.body.body if is_only_successful(res) else res
+                    concept.get_compiled()[part_key] = get_return_value(context, concept, source, part_key)
 
         for var_name, default_value in concept.get_metadata().variables:
             if var_name in concept.get_compiled():
@@ -279,12 +344,7 @@ class SheerkaEvaluateConcept(BaseService):
                     concept.get_compiled()[var_name] = concept_found
                 else:
                     # ...or a list of ReturnValueConcept to resolve
-                    res = parse_unrecognized(context,
-                                             default_value,
-                                             parsers="all",
-                                             prop=var_name,
-                                             filter_func=only_successful)
-                    concept.get_compiled()[var_name] = res.body.body if is_only_successful(res) else res
+                    concept.get_compiled()[var_name] = get_return_value(context, concept, default_value, var_name)
 
         # Updates the cache of concepts when possible
         # This piece of code is not used, a the compile part is removed by sheerka.new_from_template()
@@ -469,7 +529,10 @@ class SheerkaEvaluateConcept(BaseService):
             if context.sheerka.isa(concept, context.sheerka.new(BuiltinConcepts.AUTO_EVAL)):
                 sub_context.protected_hints.add(BuiltinConcepts.EVAL_BODY_REQUESTED)
 
-            self.initialize_concept_asts(sub_context, concept)
+            try:
+                self.initialize_concept_asts(sub_context, concept)
+            except ChickenAndEggException as ex:
+                return ex.error
 
             # to make sure of the order, it don't use ConceptParts.get_parts()
             # variables must be evaluated first, body must be evaluated before where
@@ -525,7 +588,8 @@ class SheerkaEvaluateConcept(BaseService):
                     # validate PRE and WHERE condition
                     if part_key in (ConceptParts.PRE, ConceptParts.WHERE) and not self.sheerka.objvalue(resolved):
                         return self.sheerka.new(BuiltinConcepts.CONDITION_FAILED,
-                                                body=getattr(concept.get_metadata(), concept_part_value(metadata_to_eval)),
+                                                body=getattr(concept.get_metadata(),
+                                                             concept_part_value(metadata_to_eval)),
                                                 concept=concept,
                                                 prop=part_key)