I can manage infinite recursion when building concept

tests/core/test_SheerkaEvaluateConcept.py

@@ -1,12 +1,17 @@
+from dataclasses import dataclass
+
 import pytest
 from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, ParserResultConcept
 from core.concept import Concept, DoNotResolve, ConceptParts, InfiniteRecursionResolved, CB, NotInit, \
-    concept_part_value
+    concept_part_value, DEFINITION_TYPE_DEF
 from core.sheerka.services.SheerkaEvaluateConcept import SheerkaEvaluateConcept
 from core.sheerka.services.SheerkaMemory import SheerkaMemory
-from parsers.PythonParser import PythonNode
+from parsers.BaseParser import BaseParser
+from parsers.PythonParser import PythonNode, PythonParser
 
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+from tests.evaluators.EvaluatorTestsUtils import pr_ret_val, python_ret_val
+
 
 
 class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
@@ -709,7 +714,7 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
         assert sheerka.isinstance(evaluated, BuiltinConcepts.CHICKEN_AND_EGG)
         assert evaluated.body == {foo, bar, baz, qux}
 
-    def test_i_can_detect_auto_recursion(self):
+    def test_i_can_detect_infinite_recursion(self):
         sheerka, context, foo = self.init_concepts(
             Concept("foo", body="foo"),
             eval_body=True
@@ -863,11 +868,11 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
         service.initialize_concept_asts(context, concept)
         assert service.compute_metadata_to_eval(context, concept) == ["#where#"]
 
-        concept = Concept("foo", where="where a").def_var("a")
+        concept = Concept("foo", where="a").def_var("a")
         service.initialize_concept_asts(context, concept)
         assert service.compute_metadata_to_eval(context, concept) == ["variables", "#where#"]
 
-        concept = Concept("foo", where="where self")
+        concept = Concept("foo", where="self")
         service.initialize_concept_asts(context, concept)
         assert service.compute_metadata_to_eval(context, concept) == ["#body#", "#where#"]
 
@@ -925,6 +930,53 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
         res = sheerka.evaluate_concept(context, foo, eval_body=True)
         assert res.body == "Print return values"
 
+    def test_i_can_manage_python_concept_infinite_recursion_when_initializing_ast(self):
+        sheerka, context, foo = self.init_concepts(Concept("a + b", body="a + b").def_var("a").def_var("b"))
+        evaluator = SheerkaEvaluateConcept(sheerka)
+
+        evaluator.initialize_concept_asts(context, foo)
+        res = foo.get_compiled()["#body#"]
+
+        assert len(res) == 1
+        assert sheerka.isinstance(res[0], BuiltinConcepts.RETURN_VALUE)
+        assert res[0].who == BaseParser.get_name(PythonParser.NAME)
+
+        # TODO validate that a rule is created
+
+    def test_can_detect_recursive_definition_with_exact_concept(self):
+        sheerka, context, foo = self.init_concepts("foo")
+        evaluator = SheerkaEvaluateConcept(sheerka)
+
+        # 'def concept foo as foo'
+        return_values = [pr_ret_val(foo, parser="ExactConcept"), python_ret_val("foo")]
+
+        res = evaluator.get_recursive_definitions(foo, return_values)
+
+        assert list(res) == [BaseParser.get_name("ExactConcept")]
+
+    def test_i_can_detect_when_no_recursive_definition(self):
+        sheerka, context, foo, bar = self.init_concepts("foo", "bar")
+        evaluator = SheerkaEvaluateConcept(sheerka)
+
+        # 'def concept foo as bar'
+        return_values = [pr_ret_val(bar, parser="ExactConcept"), python_ret_val("foo")]
+
+        res = evaluator.get_recursive_definitions(foo, return_values)
+
+        assert list(res) == []
+
+    def test_i_can_detect_when_no_recursive_definition2(self):
+        sheerka, context, q = self.init_concepts(
+            Concept("q", definition="q ?", definition_type=DEFINITION_TYPE_DEF).def_var("q"))
+        evaluator = SheerkaEvaluateConcept(sheerka)
+
+        # i dunno how to construct the return value
+        return_values = [pr_ret_val(q, parser="ExactConcept")]
+
+        res = evaluator.get_recursive_definitions(q, return_values)
+
+        assert list(res) == []
+
     # I cannot implement value cache for now
     # def test_values_when_no_variables_are_computed_only_once(self):
     #     sheerka, context, foo = self.init_concepts(Concept("foo", body="10"))