diff mbox

[v6,03/12] qapi: Lazy creation of array types

Message ID 1443760312-656-4-git-send-email-eblake@redhat.com
State New
Headers show

Commit Message

Eric Blake Oct. 2, 2015, 4:31 a.m. UTC
Commit ac88219a had several TODO markers about whether we needed
to automatically create the corresponding array type alongside
any other type.  It turns out that most of the time, we don't!

As part of lazy creation of array types, this patch now assigns
an 'info' to array types at their point of first instantiation,
rather than leaving it None.

There are a few exceptions: 1) We have a few situations where we
use an array type in internal code but do not expose that type
through QMP; fix it by declaring a dummy type that forces the
generator to see that we want to use the array type.

2) The builtin arrays (such as intList for QAPI ['int']) must
always be generated, because of the way our QAPI_TYPES_BUILTIN
compile guard works: we have situations (at the very least
tests/test-qmp-output-visitor.c) that include both top-level
"qapi-types.h" (via "error.h") and a secondary
"test-qapi-types.h". If we were to only emit the builtin types
when used locally, then the first .h file would not include all
types, but the second .h does not declare anything at all because
the first .h set QAPI_TYPES_BUILTIN, and we would end up with
compilation error due to things like unknown type 'int8List'.

Actually, we may need to revisit how we do type guards, and
change from a single QAPI_TYPES_BUILTIN over to a different
usage pattern that does one #ifdef per qapi type - right now,
the only types that are declared multiple times between two qapi
.json files for inclusion by a single .c file happen to be the
builtin arrays.  But now that we have QAPI 'include' statements,
it is logical to assume that we will soon reach a point where
we want to reuse non-builtin types (yes, I'm thinking about what
it will take to add introspection to QGA, where we will want to
reuse the SchemaInfo type and friends).  One #ifdef per type
will help ensure that generating the same qapi type into more
than one qapi-types.h won't cause collisions when both are
included in the same .c file; but we also have to solve how to
avoid creating duplicate qapi-types.c entry points.  So that
is a problem left for another day.

Interestingly, the introspection output is unchanged - this is
because we already cull all types that are not indirectly
reachable from a command or event, so introspection was already
using only a subset of array types.  The subset of types
introspected is now a much larger percentage of the overall set
of array types emitted in qapi-types.h (since the larger set
shrunk), but still not 100% (proof that the array types emitted
for our new Dummy struct, and the new Dummy struct itself, don't
affect QMP).  Of course, the rest of the generated output is
drastically shrunk (a number of unused array types are no longer
generated) [for best results, diff the generated files with
'git diff --patience --no-index pre post'].

Signed-off-by: Eric Blake <eblake@redhat.com>

---
v6: new patch
---
 qapi-schema.json                        | 10 +++++++++
 scripts/qapi.py                         | 39 ++++++++++++++++-----------------
 tests/qapi-schema/qapi-schema-test.json |  4 ++++
 tests/qapi-schema/qapi-schema-test.out  |  3 +++
 4 files changed, 36 insertions(+), 20 deletions(-)

Comments

Markus Armbruster Oct. 2, 2015, 8:06 a.m. UTC | #1
Woot!

Eric Blake <eblake@redhat.com> writes:

> Commit ac88219a had several TODO markers about whether we needed
> to automatically create the corresponding array type alongside
> any other type.  It turns out that most of the time, we don't!
>
> As part of lazy creation of array types, this patch now assigns
> an 'info' to array types at their point of first instantiation,
> rather than leaving it None.

I guess our general for info should be:

For explicitly defined entities, info points to the (explicit)
definition.  For implicitly defined entities, it points to a place that
triggers implicit definition.  For some kinds of entities, multiple
places may exist, and info points to one of them.

First one we encounter is as good as any, and easy to compute.

> There are a few exceptions: 1) We have a few situations where we
> use an array type in internal code but do not expose that type
> through QMP; fix it by declaring a dummy type that forces the
> generator to see that we want to use the array type.
>
> 2) The builtin arrays (such as intList for QAPI ['int']) must
> always be generated, because of the way our QAPI_TYPES_BUILTIN
> compile guard works: we have situations (at the very least
> tests/test-qmp-output-visitor.c) that include both top-level
> "qapi-types.h" (via "error.h") and a secondary
> "test-qapi-types.h". If we were to only emit the builtin types
> when used locally, then the first .h file would not include all
> types, but the second .h does not declare anything at all because
> the first .h set QAPI_TYPES_BUILTIN, and we would end up with
> compilation error due to things like unknown type 'int8List'.

Yes.

> Actually, we may need to revisit how we do type guards, and
> change from a single QAPI_TYPES_BUILTIN over to a different
> usage pattern that does one #ifdef per qapi type - right now,
> the only types that are declared multiple times between two qapi
> .json files for inclusion by a single .c file happen to be the
> builtin arrays.  But now that we have QAPI 'include' statements,
> it is logical to assume that we will soon reach a point where
> we want to reuse non-builtin types (yes, I'm thinking about what
> it will take to add introspection to QGA, where we will want to
> reuse the SchemaInfo type and friends).  One #ifdef per type
> will help ensure that generating the same qapi type into more
> than one qapi-types.h won't cause collisions when both are
> included in the same .c file; but we also have to solve how to
> avoid creating duplicate qapi-types.c entry points.  So that
> is a problem left for another day.

Yes, let's leave it for later.

> Interestingly, the introspection output is unchanged - this is
> because we already cull all types that are not indirectly
> reachable from a command or event, so introspection was already
> using only a subset of array types.  The subset of types
> introspected is now a much larger percentage of the overall set
> of array types emitted in qapi-types.h (since the larger set
> shrunk), but still not 100% (proof that the array types emitted
> for our new Dummy struct, and the new Dummy struct itself, don't
> affect QMP).  Of course, the rest of the generated output is
> drastically shrunk (a number of unused array types are no longer
> generated) [for best results, diff the generated files with
> 'git diff --patience --no-index pre post'].

Here, you're talking about the effect on generated code.  I'd put the
specific case of introspection last, in a paragraph of its own.

How much is "drastically"?  Here's what I get:

    $ git-diff --patience --no-index --stat o n
    {o => n}/qapi-types.c | 2239 +-----------------------------
    {o => n}/qapi-types.h | 1800 +-----------------------
    {o => n}/qapi-visit.c | 3605 +------------------------------------------------
    {o => n}/qapi-visit.h |  151 +--
    4 files changed, 23 insertions(+), 7772 deletions(-)
    $ wc o/* | tail -n 1
     34738  90018 985738 total
    $ wc n/* | tail -n 1
     26989  71981 788721 total

That's a >20% shrink.

    $ grep -c 'typedef .*List;' {o,n}/qapi-types.h 
    o/qapi-types.h:219
    n/qapi-types.h:69

Less than a third of the array types are still around.  Includes 14
built-in array types.

Compiled size with -O2 for me, before:

   text	   data	    bss	    dec	    hex	filename
  39235	   4576	      0	  43811	   ab23	qapi-types.o
 159424	      0	      0	 159424	  26ec0	qapi-visit.o

After:

   text	   data	    bss	    dec	    hex	filename
  24931	   4576	      0	  29507	   7343	qapi-types.o
 115581	      0	      0	 115581	  1c37d	qapi-visit.o

A 30% shrink.  Lovely.

Further reductions are probably possible.  One step at a time.

Generating code makes profligate wastefulness so much easier.

> Signed-off-by: Eric Blake <eblake@redhat.com>
>
> ---
> v6: new patch
> ---
>  qapi-schema.json                        | 10 +++++++++
>  scripts/qapi.py                         | 39 ++++++++++++++++-----------------
>  tests/qapi-schema/qapi-schema-test.json |  4 ++++
>  tests/qapi-schema/qapi-schema-test.out  |  3 +++
>  4 files changed, 36 insertions(+), 20 deletions(-)
>
> diff --git a/qapi-schema.json b/qapi-schema.json
> index 8b0520c..98bf0b2 100644
> --- a/qapi-schema.json
> +++ b/qapi-schema.json
> @@ -3396,6 +3396,16 @@
>              'features': 'int' } }
>
>  ##
> +# @Dummy
> +#
> +# Not used by QMP; hack to let us use X86CPUFeatureWordInfoList internally
> +#
> +# Since 2.5
> +##
> +{ 'struct': 'Dummy', 'data': { 'unused': ['X86CPUFeatureWordInfo'] } }

DummyToForceArrays?

> +
> +
> +##
>  # @RxState:
>  #
>  # Packets receiving state
> diff --git a/scripts/qapi.py b/scripts/qapi.py
> index 8123ab3..15640b6 100644
> --- a/scripts/qapi.py
> +++ b/scripts/qapi.py
> @@ -1143,7 +1143,7 @@ class QAPISchema(object):
>      def _def_builtin_type(self, name, json_type, c_type, c_null):
>          self._def_entity(QAPISchemaBuiltinType(name, json_type,
>                                                 c_type, c_null))
> -        self._make_array_type(name)     # TODO really needed?
> +        self._make_array_type(name, None)

Should we keep a TODO here?

>
>      def _def_predefineds(self):
>          for t in [('str',    'string',  'char' + pointer_suffix, 'NULL'),
> @@ -1170,10 +1170,10 @@ class QAPISchema(object):
>          self._def_entity(QAPISchemaEnumType(name, None, values, None))
>          return name
>
> -    def _make_array_type(self, element_type):
> +    def _make_array_type(self, element_type, info):
>          name = element_type + 'List'
>          if not self.lookup_type(name):
> -            self._def_entity(QAPISchemaArrayType(name, None, element_type))
> +            self._def_entity(QAPISchemaArrayType(name, info, element_type))
>          return name
>
>      def _make_implicit_object_type(self, name, role, members):
> @@ -1190,20 +1190,19 @@ class QAPISchema(object):
>          data = expr['data']
>          prefix = expr.get('prefix')
>          self._def_entity(QAPISchemaEnumType(name, info, data, prefix))
> -        self._make_array_type(name)     # TODO really needed?
>
> -    def _make_member(self, name, typ):
> +    def _make_member(self, name, typ, info):
>          optional = False
>          if name.startswith('*'):
>              name = name[1:]
>              optional = True
>          if isinstance(typ, list):
>              assert len(typ) == 1
> -            typ = self._make_array_type(typ[0])
> +            typ = self._make_array_type(typ[0], info)
>          return QAPISchemaObjectTypeMember(name, typ, optional)
>
> -    def _make_members(self, data):
> -        return [self._make_member(key, value)
> +    def _make_members(self, data, info):
> +        return [self._make_member(key, value, info)
>                  for (key, value) in data.iteritems()]
>
>      def _def_struct_type(self, expr, info):
> @@ -1211,19 +1210,19 @@ class QAPISchema(object):
>          base = expr.get('base')
>          data = expr['data']
>          self._def_entity(QAPISchemaObjectType(name, info, base,
> -                                              self._make_members(data),
> +                                              self._make_members(data, info),
>                                                None))
> -        self._make_array_type(name)     # TODO really needed?
>
>      def _make_variant(self, case, typ):
>          return QAPISchemaObjectTypeVariant(case, typ)
>
> -    def _make_simple_variant(self, case, typ):
> +    def _make_simple_variant(self, case, typ, info):
>          if isinstance(typ, list):
>              assert len(typ) == 1
> -            typ = self._make_array_type(typ[0])
> +            typ = self._make_array_type(typ[0], info)
>          typ = self._make_implicit_object_type(typ, 'wrapper',
> -                                              [self._make_member('data', typ)])
> +                                              [self._make_member('data', typ,
> +                                                                 info)])

Consider a hanging indent here:

        typ = self._make_implicit_object_type(
                    typ, 'wrapper', [self._make_member('data', typ, info)])

>          return QAPISchemaObjectTypeVariant(case, typ)
>
>      def _make_tag_enum(self, type_name, variants):
> @@ -1240,16 +1239,15 @@ class QAPISchema(object):
>              variants = [self._make_variant(key, value)
>                          for (key, value) in data.iteritems()]
>          else:
> -            variants = [self._make_simple_variant(key, value)
> +            variants = [self._make_simple_variant(key, value, info)
>                          for (key, value) in data.iteritems()]
>              tag_enum = self._make_tag_enum(name, variants)
>          self._def_entity(
>              QAPISchemaObjectType(name, info, base,
> -                                 self._make_members(OrderedDict()),
> +                                 self._make_members(OrderedDict(), info),
>                                   QAPISchemaObjectTypeVariants(tag_name,
>                                                                tag_enum,
>                                                                variants)))
> -        self._make_array_type(name)     # TODO really needed?
>
>      def _def_alternate_type(self, expr, info):
>          name = expr['alternate']
> @@ -1262,7 +1260,6 @@ class QAPISchema(object):
>                                      QAPISchemaObjectTypeVariants(None,
>                                                                   tag_enum,
>                                                                   variants)))
> -        self._make_array_type(name)     # TODO really needed?
>
>      def _def_command(self, expr, info):
>          name = expr['command']
> @@ -1272,10 +1269,11 @@ class QAPISchema(object):
>          success_response = expr.get('success-response', True)
>          if isinstance(data, OrderedDict):
>              data = self._make_implicit_object_type(name, 'arg',
> -                                                   self._make_members(data))
> +                                                   self._make_members(data,
> +                                                                      info))

Hanging indent?

>          if isinstance(rets, list):
>              assert len(rets) == 1
> -            rets = self._make_array_type(rets[0])
> +            rets = self._make_array_type(rets[0], info)
>          self._def_entity(QAPISchemaCommand(name, info, data, rets, gen,
>                                             success_response))
>
> @@ -1284,7 +1282,8 @@ class QAPISchema(object):
>          data = expr.get('data')
>          if isinstance(data, OrderedDict):
>              data = self._make_implicit_object_type(name, 'arg',
> -                                                   self._make_members(data))
> +                                                   self._make_members(data,
> +                                                                      info))

Hanging indent?

>          self._def_entity(QAPISchemaEvent(name, info, data))
>
>      def _def_exprs(self):
> diff --git a/tests/qapi-schema/qapi-schema-test.json b/tests/qapi-schema/qapi-schema-test.json
> index abe59fd..020ff2e 100644
> --- a/tests/qapi-schema/qapi-schema-test.json
> +++ b/tests/qapi-schema/qapi-schema-test.json
> @@ -31,6 +31,10 @@
>    'data': { 'string0': 'str',
>              'dict1': 'UserDefTwoDict' } }
>
> +# dummy struct to force generation of array types not otherwise mentioned
> +{ 'struct': 'ForceArrays',
> +  'data': { 'unused1':['UserDefOne'], 'unused2':['UserDefTwo'] } }
> +
>  # for testing unions
>  # Among other things, test that a name collision between branches does
>  # not cause any problems (since only one branch can be in use at a time),
> diff --git a/tests/qapi-schema/qapi-schema-test.out b/tests/qapi-schema/qapi-schema-test.out
> index 8f81784..2a8c82e 100644
> --- a/tests/qapi-schema/qapi-schema-test.out
> +++ b/tests/qapi-schema/qapi-schema-test.out
> @@ -86,6 +86,9 @@ object EventStructOne
>      member struct1: UserDefOne optional=False
>      member string: str optional=False
>      member enum2: EnumOne optional=True
> +object ForceArrays
> +    member unused1: UserDefOneList optional=False
> +    member unused2: UserDefTwoList optional=False
>  object NestedEnumsOne
>      member enum1: EnumOne optional=False
>      member enum2: EnumOne optional=True
Eric Blake Oct. 2, 2015, 1:05 p.m. UTC | #2
On 10/02/2015 02:06 AM, Markus Armbruster wrote:
> Woot!
> 
> Eric Blake <eblake@redhat.com> writes:
> 
>> Commit ac88219a had several TODO markers about whether we needed
>> to automatically create the corresponding array type alongside
>> any other type.  It turns out that most of the time, we don't!
>>
>> As part of lazy creation of array types, this patch now assigns
>> an 'info' to array types at their point of first instantiation,
>> rather than leaving it None.
> 
> I guess our general for info should be:

s/general/general description/ ?

> 
> For explicitly defined entities, info points to the (explicit)
> definition.  For implicitly defined entities, it points to a place that
> triggers implicit definition.  For some kinds of entities, multiple
> places may exist, and info points to one of them.
> 

Right now, we don't document any of the fields, but I can certainly add
that comment.


> 
> Here, you're talking about the effect on generated code.  I'd put the
> specific case of introspection last, in a paragraph of its own.
> 

Improving the commit message is easier than redoing bad code :)

>> +++ b/qapi-schema.json
>> @@ -3396,6 +3396,16 @@
>>              'features': 'int' } }
>>
>>  ##
>> +# @Dummy
>> +#
>> +# Not used by QMP; hack to let us use X86CPUFeatureWordInfoList internally
>> +#
>> +# Since 2.5
>> +##
>> +{ 'struct': 'Dummy', 'data': { 'unused': ['X86CPUFeatureWordInfo'] } }
> 
> DummyToForceArrays?

Sure.

> 
>> +
>> +
>> +##
>>  # @RxState:
>>  #
>>  # Packets receiving state
>> diff --git a/scripts/qapi.py b/scripts/qapi.py
>> index 8123ab3..15640b6 100644
>> --- a/scripts/qapi.py
>> +++ b/scripts/qapi.py
>> @@ -1143,7 +1143,7 @@ class QAPISchema(object):
>>      def _def_builtin_type(self, name, json_type, c_type, c_null):
>>          self._def_entity(QAPISchemaBuiltinType(name, json_type,
>>                                                 c_type, c_null))
>> -        self._make_array_type(name)     # TODO really needed?
>> +        self._make_array_type(name, None)
> 
> Should we keep a TODO here?

Sure, with better text explaining the guard issue on types shared in
multiple qapi-types.h files.


>>          typ = self._make_implicit_object_type(typ, 'wrapper',
>> -                                              [self._make_member('data', typ)])
>> +                                              [self._make_member('data', typ,
>> +                                                                 info)])
> 
> Consider a hanging indent here:
> 
>         typ = self._make_implicit_object_type(
>                     typ, 'wrapper', [self._make_member('data', typ, info)])


Okay.  pep8 and pylint like it (I'm not used to doing it, but it does
look better, and emacs didn't fight me too hard).
Markus Armbruster Oct. 6, 2015, 8:35 a.m. UTC | #3
Eric Blake <eblake@redhat.com> writes:

> On 10/02/2015 02:06 AM, Markus Armbruster wrote:
>> Woot!
>> 
>> Eric Blake <eblake@redhat.com> writes:
>> 
>>> Commit ac88219a had several TODO markers about whether we needed
>>> to automatically create the corresponding array type alongside
>>> any other type.  It turns out that most of the time, we don't!
>>>
>>> As part of lazy creation of array types, this patch now assigns
>>> an 'info' to array types at their point of first instantiation,
>>> rather than leaving it None.
>> 
>> I guess our general for info should be:
>
> s/general/general description/ ?

General idea.

Looks like my typing engine doesn't run on all cylinders on Fridays...

>> For explicitly defined entities, info points to the (explicit)
>> definition.  For implicitly defined entities, it points to a place that
>> triggers implicit definition.  For some kinds of entities, multiple
>> places may exist, and info points to one of them.
>> 
>
> Right now, we don't document any of the fields, but I can certainly add
> that comment.
>
>
>> 
>> Here, you're talking about the effect on generated code.  I'd put the
>> specific case of introspection last, in a paragraph of its own.
>> 
>
> Improving the commit message is easier than redoing bad code :)
>
>>> +++ b/qapi-schema.json
>>> @@ -3396,6 +3396,16 @@
>>>              'features': 'int' } }
>>>
>>>  ##
>>> +# @Dummy
>>> +#
>>> +# Not used by QMP; hack to let us use X86CPUFeatureWordInfoList internally
>>> +#
>>> +# Since 2.5
>>> +##
>>> +{ 'struct': 'Dummy', 'data': { 'unused': ['X86CPUFeatureWordInfo'] } }
>> 
>> DummyToForceArrays?
>
> Sure.
>
>> 
>>> +
>>> +
>>> +##
>>>  # @RxState:
>>>  #
>>>  # Packets receiving state
>>> diff --git a/scripts/qapi.py b/scripts/qapi.py
>>> index 8123ab3..15640b6 100644
>>> --- a/scripts/qapi.py
>>> +++ b/scripts/qapi.py
>>> @@ -1143,7 +1143,7 @@ class QAPISchema(object):
>>>      def _def_builtin_type(self, name, json_type, c_type, c_null):
>>>          self._def_entity(QAPISchemaBuiltinType(name, json_type,
>>>                                                 c_type, c_null))
>>> -        self._make_array_type(name)     # TODO really needed?
>>> +        self._make_array_type(name, None)
>> 
>> Should we keep a TODO here?
>
> Sure, with better text explaining the guard issue on types shared in
> multiple qapi-types.h files.
>
>
>>>          typ = self._make_implicit_object_type(typ, 'wrapper',
>>> - [self._make_member('data', typ)])
>>> + [self._make_member('data', typ,
>>> +                                                                 info)])
>> 
>> Consider a hanging indent here:
>> 
>>         typ = self._make_implicit_object_type(
>>                     typ, 'wrapper', [self._make_member('data', typ, info)])
>
>
> Okay.  pep8 and pylint like it (I'm not used to doing it, but it does
> look better, and emacs didn't fight me too hard).

I'm still getting used to hanging indents myself.  When in Rome...
diff mbox

Patch

diff --git a/qapi-schema.json b/qapi-schema.json
index 8b0520c..98bf0b2 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -3396,6 +3396,16 @@ 
             'features': 'int' } }

 ##
+# @Dummy
+#
+# Not used by QMP; hack to let us use X86CPUFeatureWordInfoList internally
+#
+# Since 2.5
+##
+{ 'struct': 'Dummy', 'data': { 'unused': ['X86CPUFeatureWordInfo'] } }
+
+
+##
 # @RxState:
 #
 # Packets receiving state
diff --git a/scripts/qapi.py b/scripts/qapi.py
index 8123ab3..15640b6 100644
--- a/scripts/qapi.py
+++ b/scripts/qapi.py
@@ -1143,7 +1143,7 @@  class QAPISchema(object):
     def _def_builtin_type(self, name, json_type, c_type, c_null):
         self._def_entity(QAPISchemaBuiltinType(name, json_type,
                                                c_type, c_null))
-        self._make_array_type(name)     # TODO really needed?
+        self._make_array_type(name, None)

     def _def_predefineds(self):
         for t in [('str',    'string',  'char' + pointer_suffix, 'NULL'),
@@ -1170,10 +1170,10 @@  class QAPISchema(object):
         self._def_entity(QAPISchemaEnumType(name, None, values, None))
         return name

-    def _make_array_type(self, element_type):
+    def _make_array_type(self, element_type, info):
         name = element_type + 'List'
         if not self.lookup_type(name):
-            self._def_entity(QAPISchemaArrayType(name, None, element_type))
+            self._def_entity(QAPISchemaArrayType(name, info, element_type))
         return name

     def _make_implicit_object_type(self, name, role, members):
@@ -1190,20 +1190,19 @@  class QAPISchema(object):
         data = expr['data']
         prefix = expr.get('prefix')
         self._def_entity(QAPISchemaEnumType(name, info, data, prefix))
-        self._make_array_type(name)     # TODO really needed?

-    def _make_member(self, name, typ):
+    def _make_member(self, name, typ, info):
         optional = False
         if name.startswith('*'):
             name = name[1:]
             optional = True
         if isinstance(typ, list):
             assert len(typ) == 1
-            typ = self._make_array_type(typ[0])
+            typ = self._make_array_type(typ[0], info)
         return QAPISchemaObjectTypeMember(name, typ, optional)

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

     def _def_struct_type(self, expr, info):
@@ -1211,19 +1210,19 @@  class QAPISchema(object):
         base = expr.get('base')
         data = expr['data']
         self._def_entity(QAPISchemaObjectType(name, info, base,
-                                              self._make_members(data),
+                                              self._make_members(data, info),
                                               None))
-        self._make_array_type(name)     # TODO really needed?

     def _make_variant(self, case, typ):
         return QAPISchemaObjectTypeVariant(case, typ)

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

     def _make_tag_enum(self, type_name, variants):
@@ -1240,16 +1239,15 @@  class QAPISchema(object):
             variants = [self._make_variant(key, value)
                         for (key, value) in data.iteritems()]
         else:
-            variants = [self._make_simple_variant(key, value)
+            variants = [self._make_simple_variant(key, value, info)
                         for (key, value) in data.iteritems()]
             tag_enum = self._make_tag_enum(name, variants)
         self._def_entity(
             QAPISchemaObjectType(name, info, base,
-                                 self._make_members(OrderedDict()),
+                                 self._make_members(OrderedDict(), info),
                                  QAPISchemaObjectTypeVariants(tag_name,
                                                               tag_enum,
                                                               variants)))
-        self._make_array_type(name)     # TODO really needed?

     def _def_alternate_type(self, expr, info):
         name = expr['alternate']
@@ -1262,7 +1260,6 @@  class QAPISchema(object):
                                     QAPISchemaObjectTypeVariants(None,
                                                                  tag_enum,
                                                                  variants)))
-        self._make_array_type(name)     # TODO really needed?

     def _def_command(self, expr, info):
         name = expr['command']
@@ -1272,10 +1269,11 @@  class QAPISchema(object):
         success_response = expr.get('success-response', True)
         if isinstance(data, OrderedDict):
             data = self._make_implicit_object_type(name, 'arg',
-                                                   self._make_members(data))
+                                                   self._make_members(data,
+                                                                      info))
         if isinstance(rets, list):
             assert len(rets) == 1
-            rets = self._make_array_type(rets[0])
+            rets = self._make_array_type(rets[0], info)
         self._def_entity(QAPISchemaCommand(name, info, data, rets, gen,
                                            success_response))

@@ -1284,7 +1282,8 @@  class QAPISchema(object):
         data = expr.get('data')
         if isinstance(data, OrderedDict):
             data = self._make_implicit_object_type(name, 'arg',
-                                                   self._make_members(data))
+                                                   self._make_members(data,
+                                                                      info))
         self._def_entity(QAPISchemaEvent(name, info, data))

     def _def_exprs(self):
diff --git a/tests/qapi-schema/qapi-schema-test.json b/tests/qapi-schema/qapi-schema-test.json
index abe59fd..020ff2e 100644
--- a/tests/qapi-schema/qapi-schema-test.json
+++ b/tests/qapi-schema/qapi-schema-test.json
@@ -31,6 +31,10 @@ 
   'data': { 'string0': 'str',
             'dict1': 'UserDefTwoDict' } }

+# dummy struct to force generation of array types not otherwise mentioned
+{ 'struct': 'ForceArrays',
+  'data': { 'unused1':['UserDefOne'], 'unused2':['UserDefTwo'] } }
+
 # for testing unions
 # Among other things, test that a name collision between branches does
 # not cause any problems (since only one branch can be in use at a time),
diff --git a/tests/qapi-schema/qapi-schema-test.out b/tests/qapi-schema/qapi-schema-test.out
index 8f81784..2a8c82e 100644
--- a/tests/qapi-schema/qapi-schema-test.out
+++ b/tests/qapi-schema/qapi-schema-test.out
@@ -86,6 +86,9 @@  object EventStructOne
     member struct1: UserDefOne optional=False
     member string: str optional=False
     member enum2: EnumOne optional=True
+object ForceArrays
+    member unused1: UserDefOneList optional=False
+    member unused2: UserDefTwoList optional=False
 object NestedEnumsOne
     member enum1: EnumOne optional=False
     member enum2: EnumOne optional=True