[Qemu-devel] [PATCH v6 06/12] qapi: Track owner of each object member

[Eric Blake]

Future commits will migrate semantic checking away from parsing
and over to the various QAPISchema*.check() methods.  But to
report an error message about an incorrect semantic use of a
member of an object type, we need to know which type, command,
or event owns the member.  Rather than making all the check()
methods have to pass around additional information, it is easier
to have each member track who owns it in the first place.

The source information is intended for human consumption in
error messages, and a new describe() method is added to access
the resulting information.  For example, given the qapi:
 { 'command': 'foo', 'data': { 'string': 'str' } }
an implementation of visit_command() that calls
 arg_type.members[0].describe()
will see "'string' (member of foo arguments)".

Where implicit types are involved, the code intentionally tries
to pick the name of the owner of that implicit type, rather than
the type name itself (a user reading the error message should be
able to grep for the problem in their original file, but will not
be able to locate a generated implicit name).

No change to generated code.

Signed-off-by: Eric Blake <address@hidden>

---
v6: rebase on new lazy array creation and simple union 'type'
motion; tweak commit message
---
 scripts/qapi.py | 53 +++++++++++++++++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 20 deletions(-)

diff --git a/scripts/qapi.py b/scripts/qapi.py
index 19cca97..880de94 100644
--- a/scripts/qapi.py
+++ b/scripts/qapi.py
@@ -993,14 +993,16 @@ class QAPISchemaObjectType(QAPISchemaType):


 class QAPISchemaObjectTypeMember(object):
-    def __init__(self, name, typ, optional):
+    def __init__(self, name, typ, optional, owner):
         assert isinstance(name, str)
         assert isinstance(typ, str)
         assert isinstance(optional, bool)
+        assert isinstance(owner, str) and ':' not in owner
         self.name = name
         self._type_name = typ
         self.type = None
         self.optional = optional
+        self._owner = owner

     def check(self, schema, all_members, seen):
         assert self.name not in seen
@@ -1009,6 +1011,9 @@ class QAPISchemaObjectTypeMember(object):
         all_members.append(self)
         seen[self.name] = self

+    def describe(self):
+        return "'%s' (member of %s)" % (self.name, self._owner)
+

 class QAPISchemaObjectTypeVariants(object):
     def __init__(self, tag_name, tag_member, variants):
@@ -1035,13 +1040,16 @@ class QAPISchemaObjectTypeVariants(object):


 class QAPISchemaObjectTypeVariant(QAPISchemaObjectTypeMember):
-    def __init__(self, name, typ):
-        QAPISchemaObjectTypeMember.__init__(self, name, typ, False)
+    def __init__(self, name, typ, owner):
+        QAPISchemaObjectTypeMember.__init__(self, name, typ, False, owner)

     def check(self, schema, tag_type, seen):
         QAPISchemaObjectTypeMember.check(self, schema, [], seen)
         assert self.name in tag_type.values

+    def describe(self):
+        return "'%s' (branch of %s)" % (self.name, self._owner)
+
     # This function exists to support ugly simple union special cases
     # TODO get rid of them, and drop the function
     def simple_union_type(self):
@@ -1193,7 +1201,7 @@ class QAPISchema(object):
         prefix = expr.get('prefix')
         self._def_entity(QAPISchemaEnumType(name, info, data, prefix))

-    def _make_member(self, name, typ, info):
+    def _make_member(self, name, typ, info, owner):
         optional = False
         if name.startswith('*'):
             name = name[1:]
@@ -1201,10 +1209,10 @@ class QAPISchema(object):
         if isinstance(typ, list):
             assert len(typ) == 1
             typ = self._make_array_type(typ[0], info)
-        return QAPISchemaObjectTypeMember(name, typ, optional)
+        return QAPISchemaObjectTypeMember(name, typ, optional, owner)

-    def _make_members(self, data, info):
-        return [self._make_member(key, value, info)
+    def _make_members(self, data, info, owner):
+        return [self._make_member(key, value, info, owner)
                 for (key, value) in data.iteritems()]

     def _def_struct_type(self, expr, info):
@@ -1212,25 +1220,26 @@ class QAPISchema(object):
         base = expr.get('base')
         data = expr['data']
         self._def_entity(QAPISchemaObjectType(name, info, base,
-                                              self._make_members(data, info),
+                                              self._make_members(data, info,
+                                                                 name),
                                               None))

-    def _make_variant(self, case, typ):
-        return QAPISchemaObjectTypeVariant(case, typ)
+    def _make_variant(self, case, typ, owner):
+        return QAPISchemaObjectTypeVariant(case, typ, owner)

-    def _make_simple_variant(self, case, typ, info):
+    def _make_simple_variant(self, case, typ, info, owner):
         if isinstance(typ, list):
             assert len(typ) == 1
             typ = self._make_array_type(typ[0], info)
         typ = self._make_implicit_object_type(typ, info, 'wrapper',
                                               [self._make_member('data', typ,
-                                                                 info)])
-        return QAPISchemaObjectTypeVariant(case, typ)
+                                                                 info, owner)])
+        return QAPISchemaObjectTypeVariant(case, typ, owner)

     def _make_tag_enum(self, type_name, info, variants):
         typ = self._make_implicit_enum_type(type_name, info,
                                             [v.name for v in variants])
-        return QAPISchemaObjectTypeMember('type', typ, False)
+        return QAPISchemaObjectTypeMember('type', typ, False, type_name)

     def _def_union_type(self, expr, info):
         name = expr['union']
@@ -1239,15 +1248,15 @@ class QAPISchema(object):
         tag_name = expr.get('discriminator')
         tag_enum = None
         if tag_name:
-            variants = [self._make_variant(key, value)
+            variants = [self._make_variant(key, value, name)
                         for (key, value) in data.iteritems()]
         else:
-            variants = [self._make_simple_variant(key, value, info)
+            variants = [self._make_simple_variant(key, value, info, name)
                         for (key, value) in data.iteritems()]
             tag_enum = self._make_tag_enum(name, info, variants)
         self._def_entity(
             QAPISchemaObjectType(name, info, base,
-                                 self._make_members(OrderedDict(), info),
+                                 self._make_members(OrderedDict(), info, name),
                                  QAPISchemaObjectTypeVariants(tag_name,
                                                               tag_enum,
                                                               variants)))
@@ -1255,7 +1264,7 @@ class QAPISchema(object):
     def _def_alternate_type(self, expr, info):
         name = expr['alternate']
         data = expr['data']
-        variants = [self._make_variant(key, value)
+        variants = [self._make_variant(key, value, name)
                     for (key, value) in data.iteritems()]
         tag_enum = self._make_tag_enum(name, info, variants)
         self._def_entity(
@@ -1271,9 +1280,11 @@ class QAPISchema(object):
         gen = expr.get('gen', True)
         success_response = expr.get('success-response', True)
         if isinstance(data, OrderedDict):
+            owner = name + ' arguments'
             data = self._make_implicit_object_type(name, info, 'arg',
                                                    self._make_members(data,
-                                                                      info))
+                                                                      info,
+                                                                      owner))
         if isinstance(rets, list):
             assert len(rets) == 1
             rets = self._make_array_type(rets[0], info)
@@ -1284,9 +1295,11 @@ class QAPISchema(object):
         name = expr['event']
         data = expr.get('data')
         if isinstance(data, OrderedDict):
+            owner = name + ' data'
             data = self._make_implicit_object_type(name, info, 'arg',
                                                    self._make_members(data,
-                                                                      info))
+                                                                      info,
+                                                                      owner))
         self._def_entity(QAPISchemaEvent(name, info, data))

     def _def_exprs(self):
-- 
2.4.3