zcbor.py: Disambiguate list labels from map keys

Treat 'foo: bar' as a label in list context even if 'foo' is a known type, while keeping map behavior unchanged.

Adds regression coverage in both the Python test suite and the corner case CDDL fixtures.

Signed-off-by: Jon Ringle <jringle@gridpoint.com>

Author: ringlej

tests/cases/corner_cases.cddl

@@ -372,3 +372,17 @@ OptList = [
 	optlist_int: int,
 	?optlist: [uint],
 ]
+
+collision_foo = 2
+
+CollisionList = [
+	collision_foo: uint,
+]
+
+CollisionMap = {
+	collision_foo: uint,
+}
+
+CollisionTypedKeyMap = {
+	collision_foo => uint,
+}

tests/scripts/test_zcbor.py

@@ -764,6 +764,37 @@ def test_intmax2(self):
         self.assertEqual(decoded.UINT_64, 18446744073709551615)
 
 
+class TestLabelKeyContext(TestCase):
+    def test_list_label_does_not_become_key_when_type_exists(self):
+        cddl_str = """
+foo = 2
+
+my_list = [
+  foo: uint
+]
+"""
+        cddl_res = zcbor.DataTranslator.from_cddl(cddl_str, 16)
+        cddl = cddl_res.my_types["my_list"]
+        self.assertEqual("LIST", cddl.type)
+        child = cddl.value[0]
+        self.assertEqual("foo", child.label)
+        self.assertIsNone(child.key)
+
+    def test_map_member_still_uses_key_when_type_exists(self):
+        cddl_str = """
+foo = 2
+
+my_map = {
+  foo: uint
+}
+"""
+        cddl_res = zcbor.DataTranslator.from_cddl(cddl_str, 16)
+        cddl = cddl_res.my_types["my_map"]
+        self.assertEqual("MAP", cddl.type)
+        child = cddl.value[0]
+        self.assertIsNotNone(child.key)
+
+
 class TestInvalidIdentifiers(TestCase):
     def test_invalid_identifiers0(self):
         cddl_res = zcbor.DataTranslator.from_cddl(

zcbor/zcbor.py

@@ -215,7 +215,7 @@ class CddlParser:
     - For "GROUP" and "UNION" types, there is no separate data item for the instance.
     """
     def __init__(self, default_max_qty, my_types, my_control_groups, base_name=None,
-                 short_names=False, base_stem=''):
+                 short_names=False, base_stem='', in_map=False):
         self.id_prefix = "temp_" + str(counter())
         self.id_num = None  # Unique ID number. Only populated if needed.
         # The value of the data item. Has different meaning for different
@@ -263,6 +263,7 @@ def __init__(self, default_max_qty, my_types, my_control_groups, base_name=None,
         # Stem which can be used when generating an id.
         self.base_stem = base_stem.replace("-", "_")
         self.short_names = short_names
+        self.in_map = in_map
 
         if type(self) not in type(self).cddl_regexes:
             self.cddl_regexes_init()
@@ -438,7 +439,7 @@ def init_kwargs(self):
         """Return the kwargs that should be used to initialize a new instance of this class."""
         return {
             "my_types": self.my_types, "my_control_groups": self.my_control_groups,
-            "short_names": self.short_names}
+            "short_names": self.short_names, "in_map": self.in_map}
 
     def set_id_prefix(self, id_prefix=''):
         self.id_prefix = id_prefix
@@ -708,7 +709,7 @@ def set_key_or_label(self, key_or_label):
         map. This code uses a slightly different method for choosing between label and key.
         If the string is recognized as a type, it is treated as a key. For use during CDDL parsing.
         """
-        if key_or_label in self.my_types:
+        if self.in_map and key_or_label in self.my_types:
             self.set_key(self.parse(key_or_label)[0])
             assert self.key.type == "OTHER", "This should only be able to produce an OTHER key."
             if self.label is None:
@@ -785,13 +786,13 @@ def cddl_regexes_init(self):
         range_types = [
             (r'(?P<bracket>\[(?P<item>(?>[^[\]]+|(?&bracket))*)\])',
              lambda m_self, list_str: m_self.type_and_value(
-                 "LIST", lambda: m_self.parse(list_str))),
+                 "LIST", lambda: m_self.parse(list_str, in_map=False))),
             (r'(?P<paren>\((?P<item>(?>[^\(\)]+|(?&paren))*)\))',
              lambda m_self, group_str: m_self.type_and_value(
-                 "GROUP", lambda: m_self.parse(group_str))),
+                 "GROUP", lambda: m_self.parse(group_str, in_map=m_self.in_map))),
             (r'(?P<curly>{(?P<item>(?>[^{}]+|(?&curly))*)})',
              lambda m_self, map_str: m_self.type_and_value(
-                 "MAP", lambda: m_self.parse(map_str))),
+                 "MAP", lambda: m_self.parse(map_str, in_map=True))),
             (r'\'(?P<item>.*?)(?<!\\)\'',
              lambda m_self, string: m_self.type_and_value("BSTR", lambda: string)),
             (r'\"(?P<item>.*?)(?<!\\)\"',
@@ -1005,12 +1006,16 @@ def post_validate_control_group(self):
             if c.type != "UINT" or c.value is None or c.value < 0:
                 raise TypeError("control group members must be literal positive integers.")
 
-    def parse(self, instr):
+    def parse(self, instr, in_map=None):
         """Parses entire instr and returns a list of instances."""
+        if in_map is None:
+            in_map = self.in_map
         instr = instr.strip()
         values = []
         while instr != '':
-            value = type(self)(*self.init_args(), **self.init_kwargs(), base_stem=self.base_stem)
+            kwargs = self.init_kwargs()
+            kwargs["in_map"] = in_map
+            value = type(self)(*self.init_args(), **kwargs, base_stem=self.base_stem)
             instr = value.get_value(instr)
             values.append(value)
         return values