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):
