Working on #98 : Persist attribute value when global_truth is set to true

tests/BaseTest.py

@@ -6,6 +6,7 @@ from core.concept import Concept, DEFINITION_TYPE_BNF, DEFINITION_TYPE_DEF, free
 from core.rule import Rule, ACTION_TYPE_PRINT, ACTION_TYPE_EXEC
 from core.sheerka.ExecutionContext import ExecutionContext
 from core.sheerka.Sheerka import Sheerka
+from core.sheerka.services.SheerkaConceptManager import SheerkaConceptManager
 from core.sheerka.services.SheerkaRuleManager import SheerkaRuleManager
 from parsers.BnfDefinitionParser import BnfDefinitionParser
 from parsers.BnfNodeParser import StrMatch
@@ -47,6 +48,7 @@ class InitTestHelper:
                         raise Exception(f"Error in bnf definition '{c.get_metadata().definition}'",
                                         self.sheerka.get_errors(self.context, res))
 
+            self._update_concept_parameters(c)
             if create_new:
                 self.sheerka.create_new_concept(self.context, c)
             else:
@@ -99,6 +101,12 @@ class InitTestHelper:
 
         return self
 
+    def _update_concept_parameters(self, concept):
+        if concept.get_metadata().parameters:
+            return
+
+        SheerkaConceptManager.recompute_concept_parameters(self.context, concept)
+
 
 class BaseTest:
     def get_sheerka(self, **kwargs) -> Sheerka:

tests/core/test_SheerkaConceptManager.py

@@ -4,7 +4,7 @@ from cache.CacheManager import ConceptNotFound
 from core.builtin_concepts import BuiltinConcepts
 from core.builtin_helpers import ensure_bnf
 from core.concept import PROPERTIES_TO_SERIALIZE, Concept, DEFINITION_TYPE_DEF, get_concept_attrs, \
-    DEFINITION_TYPE_BNF
+    DEFINITION_TYPE_BNF, ConceptParts
 from core.global_symbols import NotInit, NotFound, SyaAssociativity, CONCEPT_COMPARISON_CONTEXT
 from core.sheerka.services.SheerkaConceptManager import SheerkaConceptManager, NoModificationFound, ForbiddenAttribute, \
     UnknownAttribute, CannotRemoveMeta, ValueNotFound, ConceptIsReferenced, NoFirstTokenError
@@ -494,13 +494,13 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         to_add = {"meta": {"name": "b bar c d"},
                   "variables": {"c": None, "d": None}}
 
-        to_remove = {"variables": ["a"]}
-
-        res = sheerka.modify_concept(context, foo, to_add, to_remove)
+        res = sheerka.modify_concept(context, foo, to_add)
         new_concept = res.body.body
 
         assert res.status
-        assert new_concept.key == "__var__0 bar __var__1 __var__2"
+        assert new_concept.key == "__var__1 bar __var__2 __var__3"
+        assert new_concept.get_metadata().parameters == ["b", "c", "d"]
+        assert new_concept.get_metadata().variables == [("a", None), ("b", None), ("c", None), ("d", None)]
 
     def test_key_is_modified_when_modifying_the_definition(self):
         sheerka, context, foo = self.init_concepts(
@@ -790,13 +790,101 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         prop = Concept("property")
         bar = Concept("bar")
 
-        res = sheerka.set_attr(foo, prop, bar)
+        res = sheerka.set_attr(context, foo, prop, bar)
         assert res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
 
         assert sheerka.get_attr(foo, prop) == bar
 
-    def test_i_setting_twice_the_same_property_creates_a_list(self):
+    def test_i_can_get_and_set_attribute_when_global_truth_is_set(self):
+        sheerka, context, foo, adjective, color, red, brightness, dark = self.init_test(cache_only=False).with_concepts(
+            "foo",
+            "adjective",
+            "color",
+            "red",
+            "brightness",
+            "dark",
+            create_new=True).unpack()
+        service = sheerka.services[SheerkaConceptManager.NAME]
+        global_truth_context = self.get_context(sheerka, global_truth=True)
+
+        color_instance = sheerka.new("color", body=sheerka.new("red"))
+        sheerka.set_attr(context, color_instance, brightness, sheerka.new("dark"))
+        sheerka.set_isa(context, color_instance, sheerka.new(adjective))
+
+        adjective_instance = sheerka.new("adjective")
+        adjective_instance.set_value(ConceptParts.BODY, color_instance)
+
+        foo_instance = sheerka.new("foo")
+        res = sheerka.set_attr(global_truth_context, foo_instance, sheerka.new("adjective"), adjective_instance)
+        assert res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.NEW_CONCEPT)
+
+        # foo.adjective is modified
+        resolved_adjective = sheerka.get_attr(foo_instance, sheerka.new("adjective"))
+        assert sheerka.isinstance(resolved_adjective, "adjective")
+        resolved_color = resolved_adjective.body
+        assert sheerka.isinstance(resolved_color, "color")
+        assert sheerka.isa(resolved_color, adjective)
+        assert sheerka.get_attr(resolved_color, brightness) == dark
+        assert resolved_color.body == red
+
+        # foo default variable value is modified
+        adjective_from_default_var = foo_instance.get_metadata().variables[0][1]
+        assert sheerka.isinstance(adjective_from_default_var, "adjective")
+        color_from_default_var = resolved_adjective.body
+        assert sheerka.isinstance(color_from_default_var, "color")
+        assert sheerka.isa(color_from_default_var, adjective)
+        assert sheerka.get_attr(color_from_default_var, brightness) == dark
+        assert color_from_default_var.body == red
+
+        # new instance are update
+        new_instance = sheerka.new("foo")
+        resolved_adjective = sheerka.get_attr(new_instance, sheerka.new("adjective"))
+        assert sheerka.isinstance(resolved_adjective, "adjective")
+        resolved_color = resolved_adjective.body
+        assert sheerka.isinstance(resolved_color, "color")
+        assert sheerka.isa(resolved_color, adjective)
+        assert sheerka.get_attr(resolved_color, brightness) == dark
+        assert resolved_color.body == red
+        # No need to check the default variable value since the attribute is updated
+
+        # make sure it's persisted in DB
+        sheerka.om.commit(context)
+        from_db = sheerka.om.current_sdp().get(service.CONCEPTS_BY_ID_ENTRY, foo.id)
+        # concepts values are never persisted in DB.
+        # only check the default value of the variable
+        adjective_from_default_var = from_db.get_metadata().variables[0][1]
+        assert sheerka.isinstance(adjective_from_default_var, "adjective")
+        color_from_default_var = resolved_adjective.body
+        assert sheerka.isinstance(color_from_default_var, "color")
+        assert sheerka.isa(color_from_default_var, adjective)
+        assert sheerka.get_attr(color_from_default_var, brightness) == dark
+        assert color_from_default_var.body == red
+
+        # check that we can access the values
+        assert foo_instance.values() == {'c:adjective|1002:': adjective_instance}
+        assert new_instance.values() == {'c:adjective|1002:': adjective_instance}
+        assert from_db.values() == {'c:adjective|1002:': NotInit}
+        assert foo.values() == {'c:adjective|1002:': NotInit}
+
+    def test_i_can_set_attr_twice_is_the_second_time_global_truth_is_true(self):
+        sheerka, context, foo, prop, value = self.init_test(cache_only=False).with_concepts(
+            "foo",
+            "prop",
+            "value",
+            create_new=True).unpack()
+        global_truth_context = self.get_context(sheerka, global_truth=True)
+
+        foo_instance = sheerka.new("foo")
+        sheerka.set_attr(context, foo_instance, prop, value)
+
+        sheerka.set_attr(global_truth_context, foo_instance, prop, value)
+
+        new_instance = sheerka.new("foo")
+        assert sheerka.get_attr(new_instance, prop) == value
+
+    def test_setting_twice_the_same_property_creates_a_list(self):
         sheerka, context = self.init_concepts()
         foo = Concept("foo")
         prop = Concept("property")
@@ -804,22 +892,22 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         baz = Concept("baz")
         qux = Concept("qux")
 
-        res = sheerka.set_attr(foo, prop, bar)
+        res = sheerka.set_attr(context, foo, prop, bar)
         assert res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
         assert sheerka.get_attr(foo, prop) == bar
 
-        res = sheerka.set_attr(foo, prop, bar)  # again, same value as no effect
+        res = sheerka.set_attr(context, foo, prop, bar)  # again, same value as no effect
         assert res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
         assert sheerka.get_attr(foo, prop) == bar
 
-        res = sheerka.set_attr(foo, prop, baz)
+        res = sheerka.set_attr(context, foo, prop, baz)
         assert res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
         assert sheerka.get_attr(foo, prop) == [bar, baz]
 
-        res = sheerka.set_attr(foo, prop, qux)
+        res = sheerka.set_attr(context, foo, prop, qux)
         assert res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
         assert sheerka.get_attr(foo, prop) == [bar, baz, qux]
@@ -1241,7 +1329,7 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         prop = Concept("property")
         bar = Concept("bar")
 
-        sheerka.set_attr(foo, prop, bar)
+        sheerka.set_attr(context, foo, prop, bar)
         assert sheerka.smart_get_attr(foo, prop) == bar
 
     def test_i_can_smart_get_attr_when_simple_isa(self):
@@ -1256,7 +1344,7 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         color_instance = sheerka.new(color, body=red)
         adjective_instance = sheerka.new(adjective, body=color_instance)
         table_instance = sheerka.new(table)
-        sheerka.set_attr(table_instance, adjective, adjective_instance)
+        sheerka.set_attr(context, table_instance, adjective, adjective_instance)
 
         assert sheerka.smart_get_attr(table_instance, color) == color_instance
         assert sheerka.objvalue(sheerka.smart_get_attr(table_instance, color)) == red
@@ -1276,7 +1364,7 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         color_instance = sheerka.new(color, body=reddish_instance)
         adjective_instance = sheerka.new(adjective, body=color_instance)
         table_instance = sheerka.new(table)
-        sheerka.set_attr(table_instance, adjective, adjective_instance)
+        sheerka.set_attr(context, table_instance, adjective, adjective_instance)
 
         assert sheerka.smart_get_attr(table_instance, reddish_instance) == reddish_instance
         assert sheerka.objvalue(sheerka.smart_get_attr(table_instance, color)) == red
@@ -1296,12 +1384,12 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         # add red color
         red_color_instance = sheerka.new(color, body=red)
         red_adjective_instance = sheerka.new(adjective, body=red_color_instance)
-        sheerka.set_attr(table_instance, adjective, red_adjective_instance)
+        sheerka.set_attr(context, table_instance, adjective, red_adjective_instance)
 
         # add blue color
         blue_color_instance = sheerka.new(color, body=blue)
         blue_adjective_instance = sheerka.new(adjective, body=blue_color_instance)
-        sheerka.set_attr(table_instance, adjective, blue_adjective_instance)
+        sheerka.set_attr(context, table_instance, adjective, blue_adjective_instance)
 
         res = sheerka.smart_get_attr(table_instance, color)
         assert res == [red_color_instance, blue_color_instance]
@@ -1317,7 +1405,7 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
 
         color_instance = sheerka.new(color, body=red)
         table_instance = sheerka.new(table)
-        sheerka.set_attr(table_instance, color, color_instance)
+        sheerka.set_attr(context, table_instance, color, color_instance)
 
         assert sheerka.smart_get_attr(table_instance, adjective) == color_instance
 
@@ -1336,9 +1424,9 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
 
         table_instance = sheerka.new(table)
         color_instance = sheerka.new(color, body=red)
-        sheerka.set_attr(table_instance, color, color_instance)
+        sheerka.set_attr(context, table_instance, color, color_instance)
         size_instance = sheerka.new(size, body=large)
-        sheerka.set_attr(table_instance, size, size_instance)
+        sheerka.set_attr(context, table_instance, size, size_instance)
 
         assert sheerka.smart_get_attr(table_instance, adjective) == [color_instance, size_instance]
 
@@ -1355,8 +1443,8 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         color_instance = sheerka.new(color, body=red)
         adjective_instance = sheerka.new(adjective, body=color_instance)
         table_instance = sheerka.new(table)
-        sheerka.set_attr(table_instance, adjective, adjective_instance)
-        sheerka.set_attr(table_instance, color, blue)  # set direct color value
+        sheerka.set_attr(context, table_instance, adjective, adjective_instance)
+        sheerka.set_attr(context, table_instance, color, blue)  # set direct color value
 
         assert sheerka.smart_get_attr(table_instance, color) == blue
 
@@ -1372,8 +1460,8 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
 
         color_instance = sheerka.new(color, body=red)
         table_instance = sheerka.new(table)
-        sheerka.set_attr(table_instance, color, color_instance)
-        sheerka.set_attr(table_instance, adjective, blue)  # set direct color value
+        sheerka.set_attr(context, table_instance, color, color_instance)
+        sheerka.set_attr(context, table_instance, adjective, blue)  # set direct color value
 
         assert sheerka.smart_get_attr(table_instance, adjective) == blue
 
@@ -1397,7 +1485,7 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         color_instance = sheerka.new(color, body=red)
         adjective_instance = sheerka.new(adjective, body=color_instance)
         table_instance = sheerka.new(table)
-        sheerka.set_attr(table_instance, adjective, adjective_instance)
+        sheerka.set_attr(context, table_instance, adjective, adjective_instance)
 
         res = sheerka.smart_get_attr(table_instance, color)
         assert sheerka.isinstance(res, BuiltinConcepts.NOT_FOUND)
@@ -1417,7 +1505,7 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
         table_instance = sheerka.new(table)
         color_instance = sheerka.new(color, body=red)
         adjective_instance = sheerka.new(adjective, body=color_instance)
-        sheerka.set_attr(table_instance, adjective, adjective_instance)
+        sheerka.set_attr(context, table_instance, adjective, adjective_instance)
 
         res = sheerka.smart_get_attr(table_instance, size)
         assert sheerka.isinstance(res, BuiltinConcepts.NOT_FOUND)

tests/core/test_SheerkaDebugManager.py

@@ -533,7 +533,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
     def test_i_can_inspect_object_with_concept(self):
         sheerka, context, foo = self.init_concepts("foo")
         foo.values()  # freeze known attributes
-        sheerka.set_attr(foo, "new_var", "var_value")
+        sheerka.set_attr(context, foo, "new_var", "var_value")
 
         dummy = DummyObj(foo, "value")
         res = sheerka.inspect(context, dummy)
@@ -542,7 +542,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
     def test_i_can_inspect_object_with_concept_when_as_bag(self):
         sheerka, context, foo = self.init_concepts("foo")
         foo.values()  # freeze known attributes
-        sheerka.set_attr(foo, "new_var", "var_value")
+        sheerka.set_attr(context, foo, "new_var", "var_value")
 
         dummy = DummyObj(foo, "value")
         res = sheerka.inspect(context, dummy, as_bag=True)
@@ -557,7 +557,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
     def test_i_can_inspect_object_with_concept_when_values(self):
         sheerka, context, foo = self.init_concepts("foo")
         foo.values()  # freeze known attributes
-        sheerka.set_attr(foo, "new_var", "var_value")
+        sheerka.set_attr(context, foo, "new_var", "var_value")
 
         dummy = DummyObj(foo, "value")
         res = sheerka.inspect(context, dummy, values=True)
@@ -629,7 +629,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
     def test_i_can_inspect_when_a_property_does_not_exist(self):
         sheerka, context, foo = self.init_concepts("foo")
         foo.values()  # freeze known attributes
-        sheerka.set_attr(foo, "new_var", "var_value")
+        sheerka.set_attr(context, foo, "new_var", "var_value")
 
         dummy = DummyObj(foo, "value")
         res = sheerka.inspect(context, dummy, "#type#", "fake", "a", "b")
@@ -641,7 +641,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
     def test_i_can_inspect_when_properties_are_specified_several_times(self):
         sheerka, context, foo = self.init_concepts("foo")
         foo.values()  # freeze known attributes
-        sheerka.set_attr(foo, "new_var", "var_value")
+        sheerka.set_attr(context, foo, "new_var", "var_value")
 
         dummy = DummyObj(foo, "value")
         res = sheerka.inspect(context, dummy, "#type#", "a", "b", "a")

tests/core/test_SheerkaEvaluateConcept.py

@@ -314,7 +314,7 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
 
     def test_i_can_evaluate_when_variable_asts_is_a_list(self):
         sheerka = self.get_sheerka()
-        foo = Concept("foo", body="1")
+        foo = Concept("foo", body="1").init_key()
 
         concept = Concept("to_eval").def_var("prop")
         concept.get_compiled()["prop"] = [foo, DoNotResolve("1")]
@@ -467,14 +467,6 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
         evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
         assert sheerka.isinstance(evaluated, BuiltinConcepts.CONCEPT_EVAL_ERROR)
 
-    def test_key_is_initialized_by_evaluation(self):
-        sheerka = self.get_sheerka()
-
-        concept = Concept("foo")
-        evaluated = sheerka.evaluate_concept(self.get_context(sheerka, True), concept)
-
-        assert evaluated.key == concept.init_key().key
-
     @pytest.mark.parametrize("where_clause, expected, expected_prop, expected_body", [
         ("True", True, None, NotInit),
         ("False", False, ConceptParts.WHERE, NotInit),

tests/core/test_SheerkaMemory.py

@@ -253,7 +253,7 @@ class TestSheerkaMemory(TestUsingMemoryBasedSheerka):
         instantiated_foo = sheerka.new(foo, x="value1")
         instantiated_one = ensure_evaluated(context, sheerka.new(inner_value))
         instantiated_value = sheerka.new(value, x=instantiated_one)
-        sheerka.set_attr(instantiated_foo, prop, instantiated_value)
+        sheerka.set_attr(context, instantiated_foo, prop, instantiated_value)
 
         sheerka.add_to_memory(context, "foo", instantiated_foo)
         sheerka.om.commit(context)

tests/core/test_concept.py

@@ -64,10 +64,10 @@ def test_i_can_serialize():
     :return:
     """
     concept = Concept(
-        name="concept_name",
+        name="concept_name a",
         is_builtin=True,
         is_unique=True,
-        key="concept_key",
+        key=None,
         body="definition of the body",
         where="definition of the where",
         pre="definition of the pre",
@@ -78,6 +78,8 @@ def test_i_can_serialize():
         desc="this this the desc",
         id="123456"
     ).def_var("a", "10").def_var("b", None)
+    concept.get_metadata().parameters = ["a"]
+    concept.init_key()
 
     to_dict = concept.to_dict()
     assert to_dict == {
@@ -88,14 +90,15 @@ def test_i_can_serialize():
         'id': '123456',
         'is_builtin': True,
         'is_unique': True,
-        'key': 'concept_key',
-        'name': 'concept_name',
+        'key': 'concept_name __var__0',
+        'name': 'concept_name a',
         'post': 'definition of the post',
         'pre': 'definition of the pre',
         'ret': "concept to return",
         'props': {},
         'variables': [('a', "10"), ('b', None)],
-        'where': 'definition of the where'
+        'where': 'definition of the where',
+        'parameters': ['a'],
     }
 
 
@@ -302,3 +305,33 @@ def test_i_can_manage_instance_attributes():
     assert foo.values() == {"x": "value for x", "y": "value for y"}
     assert foo.get_all_attributes() == ["x", "y"]
     assert ALL_ATTRIBUTES == {"foo_id": ["x"]}
+
+
+def test_i_can_init_key_and_compute_parameters():
+    concept = Concept("foo x").def_var("x").init_key()
+    assert concept.key == "foo __var__0"
+
+    concept = Concept("foo").def_var("x").init_key()
+    assert concept.key == "foo"
+
+    concept = Concept("foo a b").def_var("a").def_var("b").init_key()
+    assert concept.key == "foo __var__0 __var__1"
+
+    concept = Concept("foo a b").def_var("b").def_var("a").init_key()
+    assert concept.key == "foo __var__1 __var__0"
+
+    concept = Concept("foo a b").def_var("a").init_key()
+    assert concept.key == "foo __var__0 b"
+
+    concept = Concept("foo a b").def_var("b").init_key()
+    assert concept.key == "foo a __var__0"
+
+    concept = Concept("foo a").def_var("a").def_var("b").init_key()
+    assert concept.key == "foo __var__0"
+
+    concept = Concept("foo b").def_var("a").def_var("b").init_key()
+    assert concept.key == "foo __var__1"
+
+    concept = Concept("plus", definition_type=DEFINITION_TYPE_DEF, definition="a plus b").def_var("a").def_var("b")
+    concept.init_key()
+    assert concept.key == "__var__0 plus __var__1"

tests/evaluators/test_ConceptEvaluator.py

@@ -38,7 +38,6 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
         assert result.value.get_value(ConceptParts.POST) == 4
         assert result.value.get_value("a") == 5
         assert result.value.get_value("b") == 6
-        assert result.value.key == "foo"
         assert result.parents == [item]
 
     def test_body_is_returned_when_defined_and_requested(self):

tests/evaluators/test_DefConceptEvaluator.py

@@ -7,7 +7,7 @@ from core.concept import VARIABLE_PREFIX, Concept, DEFINITION_TYPE_BNF, DEFINITI
 from core.sheerka.services.SheerkaConceptManager import NoFirstTokenError
 from core.sheerka.services.SheerkaExecute import ParserInput
 from core.tokenizer import Tokenizer
-from evaluators.DefConceptEvaluator import DefConceptEvaluator, PossibleVariable, CertainVariable
+from evaluators.DefConceptEvaluator import DefConceptEvaluator, PossibleVariable, CertainVariable, ParameterVariable
 from parsers.BaseParser import BaseParser
 from parsers.BnfDefinitionParser import BnfDefinitionParser
 from parsers.BnfNodeParser import Sequence, StrMatch, ZeroOrMore, ConceptExpression, VariableExpression
@@ -200,7 +200,7 @@ class TestDefConceptEvaluator(TestUsingMemoryBasedSheerka):
         def_ret_val = DefConceptParser().parse(context, ParserInput(text))
         concept_definition = def_ret_val.value.body.definition
 
-        expected = [CertainVariable("unit"), CertainVariable("one"), CertainVariable("two")]
+        expected = [ParameterVariable("unit", True), CertainVariable("one"), CertainVariable("two")]
         assert DefConceptEvaluator.get_variables(context, concept_definition, []) == expected
 
     def test_i_can_recognize_variables_when_referencing_other_concepts(self):
@@ -326,6 +326,84 @@ class TestDefConceptEvaluator(TestUsingMemoryBasedSheerka):
         assert evaluated.body.body.key == "foo2 __var__0"
         assert evaluated.body.body.get_metadata().variables == [("x", None)]
 
+    def test_i_can_eval_when_bnf_with_implicit_variables_from_named_ordered_choice(self):
+        sheerka, context, one, two = self.init_concepts("one", "two", create_new=True)
+        text = "def concept plus from bnf (one|two)=n1 'plus' (one|two)=n2 as n1 + n2"
+        def_ret_val = DefConceptParser().parse(context, ParserInput(text))
+        evaluated = DefConceptEvaluator().eval(context, def_ret_val)
+
+        assert evaluated.status
+        assert context.sheerka.isinstance(evaluated.body, BuiltinConcepts.NEW_CONCEPT)
+
+        created_concept = evaluated.body.body
+        assert created_concept.get_metadata().name == "plus"
+        assert created_concept.get_metadata().key == "plus"
+        assert created_concept.get_metadata().definition == "(one|two)=n1 'plus' (one|two)=n2"
+        assert created_concept.get_metadata().definition_type == "bnf"
+        assert created_concept.get_metadata().variables == [('n1', None), ('one', None), ('two', None), ('n2', None)]
+        assert created_concept.get_metadata().parameters == ['n1', 'n2']
+
+    def test_i_can_eval_when_bnf_with_implicit_variables_from_unamed_ordered_choice(self):
+        sheerka, context, one, two, three = self.init_concepts("one", "two", "three", create_new=True)
+        text = "def concept choice from bnf (one|two) 'or' (two|three) 'or' (two|three)=c3"
+        def_ret_val = DefConceptParser().parse(context, ParserInput(text))
+        evaluated = DefConceptEvaluator().eval(context, def_ret_val)
+
+        assert evaluated.status
+        assert context.sheerka.isinstance(evaluated.body, BuiltinConcepts.NEW_CONCEPT)
+
+        created_concept = evaluated.body.body
+        assert created_concept.get_metadata().name == "choice"
+        assert created_concept.get_metadata().key == "choice"
+        assert created_concept.get_metadata().definition == "(one|two) 'or' (two|three) 'or' (two|three)=c3"
+        assert created_concept.get_metadata().definition_type == "bnf"
+        assert created_concept.get_metadata().variables == [('one', None), ('two', None), ('three', None), ('c3', None)]
+        assert created_concept.get_metadata().parameters == ['__OrderedChoice__1', '__OrderedChoice__2', "c3"]
+
+    def test_i_can_eval_when_bnf_with_implicit_variables_from_unordered_choice(self):
+        # as it's not possible to directly defined UnorderedChoice, we test isa concept
+        sheerka, context, one, two, number = self.init_concepts("one", "two", "number", create_new=True)
+        global_truth_context = self.get_context(global_truth=True)
+        sheerka.set_isa(global_truth_context, one, number)
+        sheerka.set_isa(global_truth_context, two, number)
+
+        text = "def concept plus from bnf number=n1 'plus' number=n2 as n1 + n2"
+        def_ret_val = DefConceptParser().parse(context, ParserInput(text))
+        evaluated = DefConceptEvaluator().eval(context, def_ret_val)
+
+        assert evaluated.status
+        assert context.sheerka.isinstance(evaluated.body, BuiltinConcepts.NEW_CONCEPT)
+
+        created_concept = evaluated.body.body
+        assert created_concept.get_metadata().name == "plus"
+        assert created_concept.get_metadata().key == "plus"
+        assert created_concept.get_metadata().definition == "number=n1 'plus' number=n2"
+        assert created_concept.get_metadata().definition_type == "bnf"
+        assert created_concept.get_metadata().variables == [('n1', None), ('n2', None)]
+        assert created_concept.get_metadata().parameters == ['n1', 'n2']
+
+    def test_i_can_eval_when_bnf_with_implicit_variables_from_unamed_unordered_choice(self):
+        # as it's not possible to directly defined UnorderedChoice, we test isa concept
+        sheerka, context, one, two, number = self.init_concepts("one", "two", "number", create_new=True)
+        global_truth_context = self.get_context(global_truth=True)
+        sheerka.set_isa(global_truth_context, one, number)
+        sheerka.set_isa(global_truth_context, two, number)
+
+        text = "def concept plus from bnf number 'plus' number as number[0] + number[1]"
+        def_ret_val = DefConceptParser().parse(context, ParserInput(text))
+        evaluated = DefConceptEvaluator().eval(context, def_ret_val)
+
+        assert evaluated.status
+        assert context.sheerka.isinstance(evaluated.body, BuiltinConcepts.NEW_CONCEPT)
+
+        created_concept = evaluated.body.body
+        assert created_concept.get_metadata().name == "plus"
+        assert created_concept.get_metadata().key == "plus"
+        assert created_concept.get_metadata().definition == "number 'plus' number"
+        assert created_concept.get_metadata().definition_type == "bnf"
+        assert created_concept.get_metadata().variables == [('number', None)]
+        assert created_concept.get_metadata().parameters == ['number']
+
     def test_i_can_eval_when_bnf_concept_with_regex(self):
         context = self.get_context()
         def_ret_val = DefConceptParser().parse(context, ParserInput("def concept hello a from bnf r'[a-z]+'=a 'hello'"))
@@ -339,6 +417,8 @@ class TestDefConceptEvaluator(TestUsingMemoryBasedSheerka):
         assert created_concept.get_metadata().key == "hello __var__0"
         assert created_concept.get_metadata().definition == "r'[a-z]+'=a 'hello'"
         assert created_concept.get_metadata().definition_type == "bnf"
+        assert created_concept.get_metadata().variables == [('a', None)]
+        assert created_concept.get_metadata().parameters == ['a']
 
     def test_i_can_eval_when_bnf_concept_with_variable(self):
         context = self.get_context()
@@ -355,6 +435,8 @@ class TestDefConceptEvaluator(TestUsingMemoryBasedSheerka):
         assert created_concept.get_metadata().definition_type == "bnf"
         assert created_concept.get_metadata().variables == [("x", None)]
         assert created_concept._bnf == Sequence(StrMatch("hello"), VariableExpression("x"))
+        assert created_concept.get_metadata().variables == [('x', None)]
+        assert created_concept.get_metadata().parameters == ['x']
 
     def test_i_can_eval_when_auto_eval_is_true(self):
         sheerka, context = self.init_test().unpack()

tests/non_reg/test_sheerka_non_reg.py

@@ -94,6 +94,7 @@ as:
         expected.get_metadata().id = "1001"
         expected.get_metadata().desc = None
         expected.get_metadata().variables = [("a", None), ("b", None)]
+        expected.get_metadata().parameters = ["a", "b"]
         expected.init_key()
 
         sheerka = self.get_sheerka(cache_only=False)
@@ -134,6 +135,7 @@ as:
         res = sheerka.evaluate_user_input("def concept a xx b as a plus b")
         expected = Concept(name="a xx b", body="a plus b").def_var("a").def_var("b").init_key()
         expected.get_metadata().id = "1001"
+        expected.get_metadata().parameters = ["a", "b"]
 
         assert len(res) == 1
         assert res[0].status
@@ -1392,17 +1394,32 @@ as:
             "set_isa(color, adjective)",
             "def concept what is the x of y pre is_question() as smart_get_attr(y, x)",
             "def concept qualify x from bnf adjective x as set_attr(x, c:adjective:, adjective) ret x",
-            "eval a red short",
         ]
         sheerka = self.init_scenario(init, global_truth=True)
 
+        res = sheerka.evaluate_user_input("eval a red short")
         res = sheerka.evaluate_user_input("what is the color of the short ?")
         assert len(res) == 1
         assert res[0].status
         assert res[0].value == "red"
 
-        res = sheerka.evaluate_user_input("eval a blue short")
+        sheerka.evaluate_user_input("eval a blue short")
         res = sheerka.evaluate_user_input("what is the color of the short ?")
         assert len(res) == 1
         assert res[0].status
         assert res[0].value == "blue"
+
+    def test_i_can_access_a_concept_after_a_global_set_attr(self):
+        init = [
+            "def concept foo",
+            "def concept color",
+            "def concept red",
+            "global_truth(set_attr(foo, color, red))"
+        ]
+        
+        sheerka = self.init_scenario(init)
+        res = sheerka.evaluate_user_input("inspect(foo)")
+
+        assert len(res) == 1
+        assert res[0].status
+

tests/non_reg/test_sheerka_non_reg_out.py

@@ -32,7 +32,7 @@ name      : foo
 key       : foo
 definition: None
 type      : None
-hash      : 16f7fbb8bc509b8c652edaf3d0c0457d15a37f0a862fbe03fa357b0c77249c46
+hash      : 632c9ac7f3a08777918aeee4bb53712caedc634a863ae39a641f69055ae2e238
 body      : 1
 where     : None
 pre       : None
@@ -45,7 +45,7 @@ name      : foo
 key       : foo
 definition: None
 type      : None
-hash      : 7036cd5ffa9294d2e1dc9bf9c9bbe2783ace5cf7f423bfce9b28c8d33c0d1d0c
+hash      : 23a1a8bc5966982471aa19b8452e22d414a55d704431866e198570913d47fd7d
 body      : 2
 where     : None
 pre       : None
@@ -71,7 +71,7 @@ name      : foo
 key       : foo
 definition: None
 type      : None
-hash      : 16f7fbb8bc509b8c652edaf3d0c0457d15a37f0a862fbe03fa357b0c77249c46
+hash      : 632c9ac7f3a08777918aeee4bb53712caedc634a863ae39a641f69055ae2e238
 body      : 1
 where     : None
 pre       : None
@@ -84,7 +84,7 @@ name      : foo
 key       : foo
 definition: None
 type      : None
-hash      : e8dd1af1b6bc0eca0fb4a87a6fabb16655caa4b7a6ea9dbbd1f887757e6caf89
+hash      : 60e442c59940a2616a3783d2e34f428f4a5ae456a88539bba9a5e87cf77060a6
 body      : 2 
 where     : True
 pre       : None

tests/parsers/test_SequenceNodeParser.py

@@ -5,7 +5,7 @@ from core.concept import Concept, DEFINITION_TYPE_DEF
 from core.sheerka.services.SheerkaExecute import ParserInput
 from parsers.SequenceNodeParser import SequenceNodeParser
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
-from tests.parsers.parsers_utils import compute_expected_array, CN, CNC, SCN, get_test_obj, compare_with_test_object, \
+from tests.parsers.parsers_utils import compute_expected_array, CN, SCN, get_test_obj, compare_with_test_object, \
     UTN
 
 
@@ -275,6 +275,26 @@ class TestSequenceNodeParser(TestUsingMemoryBasedSheerka):
         assert concept_found.get_hints().is_evaluated
         assert not concept_found.get_hints().is_instance
 
+    def test_i_can_parse_when_variable_is_not_a_parameter(self):
+        concepts_map = {
+            "foo": Concept("foo").def_var("a"),  # 'a' is not a parameter (but a property like its color for ex)
+        }
+
+        text, expected = "foo", ["foo"]
+        sheerka, context, parser = self.init_parser(concepts_map, create_new=True, use_sheerka=True)
+        res = parser.parse(context, ParserInput(text))
+        wrapper = res.body
+        lexer_nodes = res.body.body
+
+        assert res.status
+
+        expected_array = compute_expected_array(concepts_map, text, expected)
+        assert sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
+        compare_with_test_object(lexer_nodes, expected_array)
+        assert not lexer_nodes[0].concept.get_hints().is_evaluated
+        assert lexer_nodes[0].concept.get_hints().use_copy
+        assert lexer_nodes[0].concept.get_hints().is_instance
+
     @pytest.mark.parametrize("text", [
         "foo",
         f"foo one",

tests/parsers/test_SyaNodeParser.py

@@ -1114,6 +1114,33 @@ class TestSyaNodeParser(TestUsingMemoryBasedSheerka):
         # check metadata
         assert expected_concept.get_metadata().variables == [("a", "twenty one")]
 
+    def test_i_can_parse_when_all_variables_are_not_parameters(self):
+        my_map = {
+            "foo": Concept("foo a").def_var("a", "'default_a'").def_var("b", "'default_b'"),  # 'b' is not a parameter
+            "bar": Concept("bar b").def_var("a", "'default_a'").def_var("b", "'default_b'"),  # 'a' is not a parameter
+            "baz": Concept("baz")
+        }
+        sheerka, context, parser = self.init_parser(my_map)
+
+        text = "foo baz"
+        res = parser.parse(context, ParserInput(text))
+        assert res.status
+        assert len(res.body.body) == 1
+
+        expected_concept = res.body.body[0].concept
+        assert sheerka.isinstance(expected_concept.get_compiled()["a"], "baz")
+        assert "b" not in expected_concept.get_compiled()
+        assert expected_concept.get_metadata().variables == [("a", "baz"), ("b", "'default_b'")]
+
+        text = "bar baz"
+        res = parser.parse(context, ParserInput(text))
+        assert res.status
+        assert len(res.body.body) == 1
+        expected_concept = res.body.body[0].concept
+        assert sheerka.isinstance(expected_concept.get_compiled()["b"], "baz")
+        assert "a" not in expected_concept.get_compiled()
+        assert expected_concept.get_metadata().variables == [("a", "'default_a'"), ("b", "baz")]
+
     def test_i_can_parse_sequences(self):
         sheerka, context, parser = self.init_parser()
 
@@ -1335,6 +1362,19 @@ class TestSyaNodeParser(TestUsingMemoryBasedSheerka):
         assert not res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.IS_EMPTY)
 
+    def test_i_cannot_parse_concept_when_variable_is_not_a_parameter(self):
+        my_map = {
+            "foo": Concept("foo").def_var("a")  # 'a' is not a parameter (but a property like its color for ex)
+        }
+        sheerka, context, parser = self.init_parser(my_map)
+
+        text = "foo"
+        res = parser.parse(context, ParserInput(text))
+
+        assert not res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
+        assert res.body.body == text
+
     @pytest.mark.parametrize("expression, expected", [
         ("function(", ([], "function(")),
         ("before the function(", (["before the "], "function(")),