Add some validation in parse_specs.py for the struct/range/handle thing

Author: aarongreig

scripts/core/CONTRIB.rst

@@ -214,8 +214,9 @@ they are preventing you from implementing a feature please open an issue and we
 will be happy to try and accommodate your use case. Otherwise beware of the
 following:
 
-* A function parameter which is a struct type that has any of the following
-  members in its type definition must not have the ``[range]`` tag:
+* A function parameter or struct member which is a struct type that has any of
+  the following members in its type definition must not have the ``[range]``
+  tag:
 
   * An object handle with the ``[range]`` tag
 

scripts/parse_specs.py

@@ -83,7 +83,7 @@ def _get_etor_value(value, prev):
 """
     validate documents meet some basic (easily detectable) requirements of code generation
 """
-def _validate_doc(f, d, tags, line_num):
+def _validate_doc(f, d, tags, line_num, meta):
     is_iso = lambda x : re.match(r"[_a-zA-Z][_a-zA-Z0-9]{0,30}", x)
 
     def __validate_ordinal(d):
@@ -265,7 +265,35 @@ def __validate_base(d):
             elif type_traits.is_properties(d['name']) and not d.get('base', "").endswith("base_properties_t"):
                 raise Exception("'base' must be '%s_base_properties_t': %s"%(namespace, d['name']))
 
-    def __validate_members(d, tags):
+    def __validate_struct_range_members(name, members, meta):
+        def has_handle(members, meta):
+            for m in members:
+                if type_traits.is_handle(m):
+                    return True
+                if type_traits.is_struct(m, meta):
+                    return has_handle(
+                        type_traits.get_struct_members(m['type']), meta)
+            return False
+
+        for m in members:
+            if param_traits.is_range(m) and type_traits.is_handle(m['type']):
+                raise Exception(
+                    f"struct range {name} must not contain range of object handles {m['name']}"
+                )
+            if type_traits.is_struct(m['type'], meta):
+                member_members = type_traits.get_struct_members(
+                    m['type'], meta)
+                # We can't handle a range of structs with handles within a range of structs
+                if param_traits.is_range(m) and has_handle(
+                        member_members, meta):
+                    raise Exception(
+                        f"struct range {m['name']} is already within struct range {name}, and must not contain an object handle"
+                    )
+                # We keep passing the original name so we can report it in
+                # exception messages.
+                __validate_struct_range_members(name, member_members, meta)
+
+    def __validate_members(d, tags, meta):
         if 'members' not in d:
             raise Exception("'%s' requires the following sequence of mappings: {`members`}"%d['type'])
 
@@ -295,12 +323,19 @@ def __validate_members(d, tags):
             if d['type'] == 'union'and item.get('tag') is None:
                 raise Exception(prefix + f"union member {item['name']} must include a 'tag' annotation")
 
+            if type_traits.is_struct(item['type'],
+                                     meta) and param_traits.is_range(item):
+                member_members = type_traits.get_struct_members(
+                    item['type'], meta)
+                __validate_struct_range_members(item['name'], member_members,
+                                                meta)
+
             ver = __validate_version(item, prefix=prefix, base_version=d_ver)
             if ver < max_ver:
                 raise Exception(prefix+"'version' must be increasing: %s"%item['version'])
             max_ver = ver
 
-    def __validate_params(d, tags):
+    def __validate_params(d, tags, meta):
         if 'params' not in d:
             raise Exception("'function' requires the following sequence of mappings: {`params`}")
 
@@ -347,6 +382,11 @@ def __validate_params(d, tags):
                 if not has_queue:
                     raise Exception(prefix+"bounds must only be used on entry points which take a `hQueue` parameter")
 
+            if type_traits.is_struct(item['type'],
+                                     meta) and param_traits.is_range(item):
+                members = type_traits.get_struct_members(item['type'], meta)
+                __validate_struct_range_members(item['name'], members, meta)
+
             ver = __validate_version(item, prefix=prefix, base_version=d_ver)
             if ver < max_ver:
                 raise Exception(prefix+"'version' must be increasing: %s"%item['version'])
@@ -421,7 +461,7 @@ def __validate_union_tag(d):
                 __validate_union_tag(d)
             __validate_type(d, 'name', tags)
             __validate_base(d)
-            __validate_members(d, tags)
+            __validate_members(d, tags, meta)
             __validate_details(d)
             __validate_ordinal(d)
             __validate_version(d)
@@ -435,7 +475,7 @@ def __validate_union_tag(d):
             else:
                 __validate_name(d, 'name', tags, case='camel')
 
-            __validate_params(d, tags)
+            __validate_params(d, tags, meta)
             __validate_details(d)
             __validate_ordinal(d)
             __validate_version(d)
@@ -893,7 +933,7 @@ def parse(section, version, tags, meta, ref):
 
         for i, d in enumerate(docs):
             d = _preprocess(d)
-            if not _validate_doc(f, d, tags, line_nums[i]):
+            if not _validate_doc(f, d, tags, line_nums[i], meta):
                 continue
 
             d = _filter_version(d, float(version))

scripts/templates/helper.py

@@ -248,6 +248,14 @@ def get_array_element_type(cls, name):
         match = re.match(cls.RE_ARRAY, name)
         return match.groups()[0]
 
+    @staticmethod
+    def get_struct_members(type_name, meta):
+        struct_type = _remove_const_ptr(type_name)
+        if not struct_type in meta['struct']:
+            raise Exception(
+                f"Cannot return members of non-struct type {struct_type}")
+        return meta['struct'][struct_type]['members']
+
 """
     Extracts traits from a value name
 """
@@ -1305,9 +1313,8 @@ def get_struct_handle_members(namespace,
                     'optional': param_traits.is_optional(m)
                 })
         elif type_traits.is_struct(m['type'], meta):
-            member_struct_type = _remove_const_ptr(m['type'])
-            member_struct_members = meta['struct'][member_struct_type][
-                'members']
+            member_struct_members = type_traits.get_struct_members(
+                m['type'], meta)
             if param_traits.is_range(m):
                 # If we've hit a range of structs we need to start a new recursion looking
                 # for handle members. We do not support range within range, so skip that
@@ -1319,7 +1326,7 @@ def get_struct_handle_members(namespace,
                     handle_members.append({
                         'parent': parent,
                         'name': m['name'],
-                        'type': subt(namespace, tags, member_struct_type),
+                        'type': subt(namespace, tags, _remove_const_ptr(m['type'])),
                         'range_start': param_traits.range_start(m),
                         'range_end': param_traits.range_end(m),
                         'handle_members': range_handle_members
@@ -1363,8 +1370,7 @@ def get_object_handle_structs_to_convert(namespace, tags, obj, meta):
 
     for item in params:
         if type_traits.is_struct(item['type'], meta):
-            members = meta['struct'][_remove_const_ptr(
-                item['type'])]['members']
+            members = type_traits.get_struct_members(item['type'], meta)
             handle_members = get_struct_handle_members(namespace, tags, meta,
                                                        members)
             if handle_members: