qapi: Back out doc comments added just to please qapi.py

This reverts commit 3313b612's changes to tests/qapi-schema/, except
for tests/qapi-schema/doc-*.

We could keep some of these doc comments to serve as positive test
cases.  However, they don't actually add to what we get from doc
comment use in actual schemas, as we we don't test output matches
expectations, and don't systematically cover doc comment features.
Proper positive test coverage would be nice.
Signed-off-by: NMarkus Armbruster <armbru@redhat.com>
Reviewed-by: NEric Blake <eblake@redhat.com>
Message-Id: <1489582656-31133-4-git-send-email-armbru@redhat.com>

tests/qapi-schema/alternate-any.err

-tests/qapi-schema/alternate-any.json:6: Alternate 'Alt' member 'one' cannot use type 'any'
+tests/qapi-schema/alternate-any.json:2: Alternate 'Alt' member 'one' cannot use type 'any'

tests/qapi-schema/alternate-any.json

 # we do not allow the 'any' type as an alternate branch
-
-##
-# @Alt:
-##
 { 'alternate': 'Alt',
   'data': { 'one': 'any',
             'two': 'int' } }

tests/qapi-schema/alternate-array.err

-tests/qapi-schema/alternate-array.json:12: Member 'two' of alternate 'Alt' cannot be an array
+tests/qapi-schema/alternate-array.json:5: Member 'two' of alternate 'Alt' cannot be an array

tests/qapi-schema/alternate-array.json

 # we do not allow array branches in alternates
-
-##
-# @One:
-##
 # TODO: should we support this?
 { 'struct': 'One',
   'data': { 'name': 'str' } }
-##
-# @Alt:
-##
 { 'alternate': 'Alt',
   'data': { 'one': 'One',
             'two': [ 'int' ] } }

tests/qapi-schema/alternate-base.err

-tests/qapi-schema/alternate-base.json:11: Unknown key 'base' in alternate 'Alt'
+tests/qapi-schema/alternate-base.json:4: Unknown key 'base' in alternate 'Alt'

tests/qapi-schema/alternate-base.json

 # we reject alternate with base type
-
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { 'string': 'str' } }
-##
-# @Alt:
-##
 { 'alternate': 'Alt',
   'base': 'Base',
   'data': { 'number': 'int' } }

tests/qapi-schema/alternate-clash.err

-tests/qapi-schema/alternate-clash.json:11: 'a_b' (branch of Alt1) collides with 'a-b' (branch of Alt1)
+tests/qapi-schema/alternate-clash.json:7: 'a_b' (branch of Alt1) collides with 'a-b' (branch of Alt1)

tests/qapi-schema/alternate-clash.json

@@ -4,9 +4,5 @@
 # TODO: In the future, if alternates are simplified to not generate
 # the implicit Alt1Kind enum, we would still have a collision with the
 # resulting C union trying to have two members named 'a_b'.
-
-##
-# @Alt1:
-##
 { 'alternate': 'Alt1',
   'data': { 'a-b': 'str', 'a_b': 'int' } }

tests/qapi-schema/alternate-conflict-dict.err

-tests/qapi-schema/alternate-conflict-dict.json:16: Alternate 'Alt' member 'two' can't be distinguished from member 'one'
+tests/qapi-schema/alternate-conflict-dict.json:6: Alternate 'Alt' member 'two' can't be distinguished from member 'one'

tests/qapi-schema/alternate-conflict-dict.json

 # we reject alternates with multiple object branches
-
-##
-# @One:
-##
 { 'struct': 'One',
   'data': { 'name': 'str' } }
-##
-# @Two:
-##
 { 'struct': 'Two',
   'data': { 'value': 'int' } }
-##
-# @Alt:
-##
 { 'alternate': 'Alt',
   'data': { 'one': 'One',
             'two': 'Two' } }

tests/qapi-schema/alternate-conflict-string.err

-tests/qapi-schema/alternate-conflict-string.json:11: Alternate 'Alt' member 'two' can't be distinguished from member 'one'
+tests/qapi-schema/alternate-conflict-string.json:4: Alternate 'Alt' member 'two' can't be distinguished from member 'one'

tests/qapi-schema/alternate-conflict-string.json

 # we reject alternates with multiple string-like branches
-
-##
-# @Enum:
-##
 { 'enum': 'Enum',
   'data': [ 'hello', 'world' ] }
-##
-# @Alt:
-##
 { 'alternate': 'Alt',
   'data': { 'one': 'str',
             'two': 'Enum' } }

tests/qapi-schema/alternate-empty.err

-tests/qapi-schema/alternate-empty.json:6: Alternate 'Alt' should have at least two branches in 'data'
+tests/qapi-schema/alternate-empty.json:2: Alternate 'Alt' should have at least two branches in 'data'

tests/qapi-schema/alternate-empty.json

 # alternates must list at least two types to be useful
-
-##
-# @Alt:
-##
 { 'alternate': 'Alt', 'data': { 'i': 'int' } }

tests/qapi-schema/alternate-nested.err

-tests/qapi-schema/alternate-nested.json:11: Member 'nested' of alternate 'Alt2' cannot use alternate type 'Alt1'
+tests/qapi-schema/alternate-nested.json:4: Member 'nested' of alternate 'Alt2' cannot use alternate type 'Alt1'

tests/qapi-schema/alternate-nested.json

 # we reject a nested alternate branch
-
-##
-# @Alt1:
-##
 { 'alternate': 'Alt1',
   'data': { 'name': 'str', 'value': 'int' } }
-##
-# @Alt2:
-##
 { 'alternate': 'Alt2',
   'data': { 'nested': 'Alt1', 'b': 'bool' } }

tests/qapi-schema/alternate-unknown.err

-tests/qapi-schema/alternate-unknown.json:6: Member 'unknown' of alternate 'Alt' uses unknown type 'MissingType'
+tests/qapi-schema/alternate-unknown.json:2: Member 'unknown' of alternate 'Alt' uses unknown type 'MissingType'

tests/qapi-schema/alternate-unknown.json

 # we reject an alternate with unknown type in branch
-
-##
-# @Alt:
-##
 { 'alternate': 'Alt',
   'data': { 'unknown': 'MissingType', 'i': 'int' } }

tests/qapi-schema/args-alternate.err

-tests/qapi-schema/args-alternate.json:11: 'data' for command 'oops' cannot use alternate type 'Alt'
+tests/qapi-schema/args-alternate.json:3: 'data' for command 'oops' cannot use alternate type 'Alt'

tests/qapi-schema/args-alternate.json

 # we do not allow alternate arguments
-
-##
-# @Alt:
-##
 { 'alternate': 'Alt', 'data': { 'case1': 'int', 'case2': 'str' } }
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': 'Alt' }

tests/qapi-schema/args-any.err

-tests/qapi-schema/args-any.json:6: 'data' for command 'oops' cannot use built-in type 'any'
+tests/qapi-schema/args-any.json:2: 'data' for command 'oops' cannot use built-in type 'any'

tests/qapi-schema/args-any.json

 # we do not allow an 'any' argument
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': 'any' }

tests/qapi-schema/args-array-empty.err

-tests/qapi-schema/args-array-empty.json:6: Member 'empty' of 'data' for command 'oops': array type must contain single type name
+tests/qapi-schema/args-array-empty.json:2: Member 'empty' of 'data' for command 'oops': array type must contain single type name

tests/qapi-schema/args-array-empty.json

 # we reject an array for data if it does not contain a known type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': { 'empty': [ ] } }

tests/qapi-schema/args-array-unknown.err

-tests/qapi-schema/args-array-unknown.json:6: Member 'array' of 'data' for command 'oops' uses unknown type 'NoSuchType'
+tests/qapi-schema/args-array-unknown.json:2: Member 'array' of 'data' for command 'oops' uses unknown type 'NoSuchType'

tests/qapi-schema/args-array-unknown.json

 # we reject an array for data if it does not contain a known type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': { 'array': [ 'NoSuchType' ] } }

tests/qapi-schema/args-bad-boxed.err

-tests/qapi-schema/args-bad-boxed.json:6: 'boxed' of command 'foo' should only use true value
+tests/qapi-schema/args-bad-boxed.json:2: 'boxed' of command 'foo' should only use true value

tests/qapi-schema/args-bad-boxed.json

 # 'boxed' should only appear with value true
-
-##
-# @foo:
-##
 { 'command': 'foo', 'boxed': false }

tests/qapi-schema/args-boxed-anon.err

-tests/qapi-schema/args-boxed-anon.json:6: 'data' for command 'foo' should be a type name
+tests/qapi-schema/args-boxed-anon.json:2: 'data' for command 'foo' should be a type name

tests/qapi-schema/args-boxed-anon.json

 # 'boxed' can only be used with named types
-
-##
-# @foo:
-##
 { 'command': 'foo', 'boxed': true, 'data': { 'string': 'str' } }

tests/qapi-schema/args-boxed-empty.err

-tests/qapi-schema/args-boxed-empty.json:11: Cannot use 'boxed' with empty type
+tests/qapi-schema/args-boxed-empty.json:3: Cannot use 'boxed' with empty type

tests/qapi-schema/args-boxed-empty.json

 # 'boxed' requires a non-empty type
-
-##
-# @Empty:
-##
 { 'struct': 'Empty', 'data': {} }
-
-##
-# @foo:
-##
 { 'command': 'foo', 'boxed': true, 'data': 'Empty' }

tests/qapi-schema/args-boxed-string.err

-tests/qapi-schema/args-boxed-string.json:6: 'data' for command 'foo' cannot use built-in type 'str'
+tests/qapi-schema/args-boxed-string.json:2: 'data' for command 'foo' cannot use built-in type 'str'

tests/qapi-schema/args-boxed-string.json

 # 'boxed' requires a complex (not built-in) type
-
-##
-# @foo:
-##
 { 'command': 'foo', 'boxed': true, 'data': 'str' }

tests/qapi-schema/args-int.err

-tests/qapi-schema/args-int.json:6: 'data' for command 'oops' cannot use built-in type 'int'
+tests/qapi-schema/args-int.json:2: 'data' for command 'oops' cannot use built-in type 'int'

tests/qapi-schema/args-int.json

 # we reject commands where data is not an array or complex type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': 'int' }

tests/qapi-schema/args-invalid.err

-tests/qapi-schema/args-invalid.json:4: 'data' for command 'foo' should be a dictionary or type name
+tests/qapi-schema/args-invalid.json:1: 'data' for command 'foo' should be a dictionary or type name

tests/qapi-schema/args-invalid.json

-##
-# @foo:
-##
 { 'command': 'foo',
   'data': false }

tests/qapi-schema/args-member-array-bad.err

-tests/qapi-schema/args-member-array-bad.json:6: Member 'member' of 'data' for command 'oops': array type must contain single type name
+tests/qapi-schema/args-member-array-bad.json:2: Member 'member' of 'data' for command 'oops': array type must contain single type name

tests/qapi-schema/args-member-array-bad.json

 # we reject data if it does not contain a valid array type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': { 'member': [ { 'nested': 'str' } ] } }

tests/qapi-schema/args-member-case.err

-tests/qapi-schema/args-member-case.json:6: 'Arg' (parameter of no-way-this-will-get-whitelisted) should not use uppercase
+tests/qapi-schema/args-member-case.json:2: 'Arg' (parameter of no-way-this-will-get-whitelisted) should not use uppercase

tests/qapi-schema/args-member-case.json

 # Member names should be 'lower-case' unless the struct/command is whitelisted
-
-##
-# @no-way-this-will-get-whitelisted:
-##
 { 'command': 'no-way-this-will-get-whitelisted', 'data': { 'Arg': 'int' } }

tests/qapi-schema/args-member-unknown.err

-tests/qapi-schema/args-member-unknown.json:6: Member 'member' of 'data' for command 'oops' uses unknown type 'NoSuchType'
+tests/qapi-schema/args-member-unknown.json:2: Member 'member' of 'data' for command 'oops' uses unknown type 'NoSuchType'

tests/qapi-schema/args-member-unknown.json

 # we reject data if it does not contain a known type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': { 'member': 'NoSuchType' } }

tests/qapi-schema/args-name-clash.err

-tests/qapi-schema/args-name-clash.json:8: 'a_b' (parameter of oops) collides with 'a-b' (parameter of oops)
+tests/qapi-schema/args-name-clash.json:4: 'a_b' (parameter of oops) collides with 'a-b' (parameter of oops)

tests/qapi-schema/args-name-clash.json

 # C member name collision
 # Reject members that clash when mapped to C names (we would have two 'a_b'
 # members).
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': { 'a-b': 'str', 'a_b': 'str' } }

tests/qapi-schema/args-union.err

-tests/qapi-schema/args-union.json:10: 'data' for command 'oops' cannot use union type 'Uni'
+tests/qapi-schema/args-union.json:3: 'data' for command 'oops' cannot use union type 'Uni'

tests/qapi-schema/args-union.json

 # use of union arguments requires 'boxed':true
-
-##
-# @Uni:
-##
 { 'union': 'Uni', 'data': { 'case1': 'int', 'case2': 'str' } }
-##
-# oops:
-##
 { 'command': 'oops', 'data': 'Uni' }

tests/qapi-schema/args-unknown.err

-tests/qapi-schema/args-unknown.json:6: 'data' for command 'oops' uses unknown type 'NoSuchType'
+tests/qapi-schema/args-unknown.json:2: 'data' for command 'oops' uses unknown type 'NoSuchType'

tests/qapi-schema/args-unknown.json

 # we reject data if it does not contain a known type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': 'NoSuchType' }

tests/qapi-schema/bad-base.err

-tests/qapi-schema/bad-base.json:10: 'base' for struct 'MyType' cannot use union type 'Union'
+tests/qapi-schema/bad-base.json:3: 'base' for struct 'MyType' cannot use union type 'Union'

tests/qapi-schema/bad-base.json

 # we reject a base that is not a struct
-
-##
-# @Union:
-##
 { 'union': 'Union', 'data': { 'a': 'int', 'b': 'str' } }
-##
-# @MyType:
-##
 { 'struct': 'MyType', 'base': 'Union', 'data': { 'c': 'int' } }

tests/qapi-schema/bad-data.err

-tests/qapi-schema/bad-data.json:6: 'data' for command 'oops' cannot be an array
+tests/qapi-schema/bad-data.json:2: 'data' for command 'oops' cannot be an array

tests/qapi-schema/bad-data.json

 # we ensure 'data' is a dictionary for all but enums
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': [ ] }

tests/qapi-schema/bad-ident.err

-tests/qapi-schema/bad-ident.json:6: 'struct' does not allow optional name '*oops'
+tests/qapi-schema/bad-ident.json:2: 'struct' does not allow optional name '*oops'

tests/qapi-schema/bad-ident.json

 # we reject creating a type name with bad name
-
-##
-# @*oops:
-##
 { 'struct': '*oops', 'data': { 'i': 'int' } }

tests/qapi-schema/bad-type-bool.err

-tests/qapi-schema/bad-type-bool.json:6: 'struct' key must have a string value
+tests/qapi-schema/bad-type-bool.json:2: 'struct' key must have a string value

tests/qapi-schema/bad-type-bool.json

 # we reject an expression with a metatype that is not a string
-
-##
-# @true:
-##
 { 'struct': true, 'data': { } }

tests/qapi-schema/bad-type-dict.err

-tests/qapi-schema/bad-type-dict.json:6: 'command' key must have a string value
+tests/qapi-schema/bad-type-dict.json:2: 'command' key must have a string value

tests/qapi-schema/bad-type-dict.json

 # we reject an expression with a metatype that is not a string
-
-##
-# @foo:
-##
 { 'command': { } }

tests/qapi-schema/base-cycle-direct.err

-tests/qapi-schema/base-cycle-direct.json:6: Object Loopy contains itself
+tests/qapi-schema/base-cycle-direct.json:2: Object Loopy contains itself

tests/qapi-schema/base-cycle-direct.json

 # we reject a loop in base classes
-
-##
-# @Loopy:
-##
 { 'struct': 'Loopy', 'base': 'Loopy', 'data': {} }

tests/qapi-schema/base-cycle-indirect.err

-tests/qapi-schema/base-cycle-indirect.json:6: Object Base1 contains itself
+tests/qapi-schema/base-cycle-indirect.json:2: Object Base1 contains itself

tests/qapi-schema/base-cycle-indirect.json

 # we reject a loop in base classes
-
-##
-# @Base1:
-##
 { 'struct': 'Base1', 'base': 'Base2', 'data': {} }
-##
-# @Base2:
-##
 { 'struct': 'Base2', 'base': 'Base1', 'data': {} }

tests/qapi-schema/command-int.err

-tests/qapi-schema/command-int.json:6: built-in 'int' is already defined
+tests/qapi-schema/command-int.json:2: built-in 'int' is already defined

tests/qapi-schema/command-int.json

 # we reject collisions between commands and types
-
-##
-# @int:
-##
 { 'command': 'int', 'data': { 'character': 'str' } }

tests/qapi-schema/comments.json

 # Unindented comment
-
-##
-# @Status:
-##
 { 'enum': 'Status',             # Comment to the right of code
   # Indented comment
   'data': [ 'good', 'bad', 'ugly' ] }

tests/qapi-schema/comments.out

@@ -2,4 +2,3 @@ enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbo
     prefix QTYPE
 enum Status ['good', 'bad', 'ugly']
 object q_empty
-doc symbol=Status expr=('enum', 'Status')

tests/qapi-schema/double-type.err

-tests/qapi-schema/double-type.json:6: Unknown key 'command' in struct 'bar'
+tests/qapi-schema/double-type.json:2: Unknown key 'command' in struct 'bar'

tests/qapi-schema/double-type.json

 # we reject an expression with ambiguous metatype
-
-##
-# @foo:
-##
 { 'command': 'foo', 'struct': 'bar', 'data': { } }

tests/qapi-schema/enum-bad-name.err

-tests/qapi-schema/enum-bad-name.json:6: Member of enum 'MyEnum' uses invalid name 'not^possible'
+tests/qapi-schema/enum-bad-name.json:2: Member of enum 'MyEnum' uses invalid name 'not^possible'

tests/qapi-schema/enum-bad-name.json

 # we ensure all enum names can map to C
-
-##
-# @MyEnum:
-##
 { 'enum': 'MyEnum', 'data': [ 'not^possible' ] }

tests/qapi-schema/enum-bad-prefix.err

-tests/qapi-schema/enum-bad-prefix.json:6: Enum 'MyEnum' requires a string for 'prefix'
+tests/qapi-schema/enum-bad-prefix.json:2: Enum 'MyEnum' requires a string for 'prefix'

tests/qapi-schema/enum-bad-prefix.json

 # The prefix must be a string type
-
-##
-# @MyEnum:
-##
 { 'enum': 'MyEnum', 'data': [ 'one' ], 'prefix': [ 'fish' ] }

tests/qapi-schema/enum-clash-member.err

-tests/qapi-schema/enum-clash-member.json:6: 'one_two' (member of MyEnum) collides with 'one-two' (member of MyEnum)
+tests/qapi-schema/enum-clash-member.json:2: 'one_two' (member of MyEnum) collides with 'one-two' (member of MyEnum)

tests/qapi-schema/enum-clash-member.json

 # we reject enums where members will clash when mapped to C enum
-
-##
-# @MyEnum:
-##
 { 'enum': 'MyEnum', 'data': [ 'one-two', 'one_two' ] }

tests/qapi-schema/enum-dict-member.err

-tests/qapi-schema/enum-dict-member.json:6: Member of enum 'MyEnum' requires a string name
+tests/qapi-schema/enum-dict-member.json:2: Member of enum 'MyEnum' requires a string name

tests/qapi-schema/enum-dict-member.json

 # we reject any enum member that is not a string
-
-##
-# @MyEnum:
-##
 { 'enum': 'MyEnum', 'data': [ { 'value': 'str' } ] }

tests/qapi-schema/enum-member-case.err

-tests/qapi-schema/enum-member-case.json:10: 'Value' (member of NoWayThisWillGetWhitelisted) should not use uppercase
+tests/qapi-schema/enum-member-case.json:3: 'Value' (member of NoWayThisWillGetWhitelisted) should not use uppercase

tests/qapi-schema/enum-member-case.json

 # Member names should be 'lower-case' unless the enum is whitelisted
-
-##
-# @UuidInfo:
-##
 { 'enum': 'UuidInfo', 'data': [ 'Value' ] } # UuidInfo is whitelisted
-##
-# @NoWayThisWillGetWhitelisted:
-##
 { 'enum': 'NoWayThisWillGetWhitelisted', 'data': [ 'Value' ] }

tests/qapi-schema/enum-missing-data.err

-tests/qapi-schema/enum-missing-data.json:6: Key 'data' is missing from enum 'MyEnum'
+tests/qapi-schema/enum-missing-data.json:2: Key 'data' is missing from enum 'MyEnum'

tests/qapi-schema/enum-missing-data.json

 # we require that all QAPI enums have a data array
-
-##
-# @MyEnum:
-##
 { 'enum': 'MyEnum' }

tests/qapi-schema/enum-wrong-data.err

-tests/qapi-schema/enum-wrong-data.json:6: Enum 'MyEnum' requires an array for 'data'
+tests/qapi-schema/enum-wrong-data.json:2: Enum 'MyEnum' requires an array for 'data'

tests/qapi-schema/enum-wrong-data.json

 # we require that all qapi enums have an array for data
-
-##
-# @MyEnum:
-##
 { 'enum': 'MyEnum', 'data': { 'value': 'str' } }

tests/qapi-schema/event-boxed-empty.err

-tests/qapi-schema/event-boxed-empty.json:6: Use of 'boxed' requires 'data'
+tests/qapi-schema/event-boxed-empty.json:2: Use of 'boxed' requires 'data'

tests/qapi-schema/event-boxed-empty.json

 # 'boxed' requires a non-empty type
-
-##
-# @FOO:
-##
 { 'event': 'FOO', 'boxed': true }

tests/qapi-schema/event-case.json

 # TODO: might be nice to enforce naming conventions; but until then this works
 # even though events should usually be ALL_CAPS
-
-##
-# @oops:
-##
 { 'event': 'oops' }

tests/qapi-schema/event-case.out

@@ -3,4 +3,3 @@ enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbo
 event oops None
    boxed=False
 object q_empty
-doc symbol=oops expr=('event', 'oops')

tests/qapi-schema/event-nest-struct.err

-tests/qapi-schema/event-nest-struct.json:5: Member 'a' of 'data' for event 'EVENT_A' should be a type name
+tests/qapi-schema/event-nest-struct.json:1: Member 'a' of 'data' for event 'EVENT_A' should be a type name

tests/qapi-schema/event-nest-struct.json

-##
-# @EVENT_A:
-# event-nest-struct
-##
 { 'event': 'EVENT_A',
   'data': { 'a' : { 'string' : 'str', 'integer': 'int' }, 'b' : 'str' } }

tests/qapi-schema/flat-union-array-branch.err

-tests/qapi-schema/flat-union-array-branch.json:20: Member 'value1' of union 'TestUnion' cannot be an array
+tests/qapi-schema/flat-union-array-branch.json:8: Member 'value1' of union 'TestUnion' cannot be an array

tests/qapi-schema/flat-union-array-branch.json

-##
-# @TestEnum:
-##
 # we require flat union branches to be a struct
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { 'enum1': 'TestEnum' } }
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'Base',
   'discriminator': 'enum1',

tests/qapi-schema/flat-union-bad-base.err

-tests/qapi-schema/flat-union-bad-base.json:21: 'string' (member of TestTypeA) collides with 'string' (base of TestUnion)
+tests/qapi-schema/flat-union-bad-base.json:8: 'string' (member of TestTypeA) collides with 'string' (base of TestUnion)

tests/qapi-schema/flat-union-bad-base.json

 # we allow anonymous base, but enforce no duplicate keys
-
-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': { 'enum1': 'TestEnum', 'string': 'str' },
   'discriminator': 'enum1',

tests/qapi-schema/flat-union-bad-discriminator.err

-tests/qapi-schema/flat-union-bad-discriminator.json:27: Discriminator of flat union 'TestUnion' requires a string name
+tests/qapi-schema/flat-union-bad-discriminator.json:11: Discriminator of flat union 'TestUnion' requires a string name

tests/qapi-schema/flat-union-bad-discriminator.json

 # we require the discriminator to be a string naming a base-type member
 # this tests the old syntax for anonymous unions before we added alternates
-
-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @TestBase:
-##
 { 'struct': 'TestBase',
   'data': { 'enum1': 'TestEnum', 'kind': 'str' } }
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'TestBase',
   'discriminator': {},

tests/qapi-schema/flat-union-base-any.err

-tests/qapi-schema/flat-union-base-any.json:21: 'base' for union 'TestUnion' cannot use built-in type 'any'
+tests/qapi-schema/flat-union-base-any.json:8: 'base' for union 'TestUnion' cannot use built-in type 'any'

tests/qapi-schema/flat-union-base-any.json

 # we require the base to be an existing struct
-
-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'any',
   'discriminator': 'enum1',

tests/qapi-schema/flat-union-base-union.err

-tests/qapi-schema/flat-union-base-union.json:30: 'base' for union 'TestUnion' cannot use union type 'UnionBase'
+tests/qapi-schema/flat-union-base-union.json:14: 'base' for union 'TestUnion' cannot use union type 'UnionBase'

tests/qapi-schema/flat-union-base-union.json

@@ -2,31 +2,15 @@
 # TODO: It would be possible to allow a union as a base, as long as all
 # permutations of QMP names exposed by base do not clash with any QMP
 # member names added by local variants.
-
-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
-##
-# @UnionBase:
-##
 { 'union': 'UnionBase',
   'data': { 'kind1': 'TestTypeA',
             'kind2': 'TestTypeB' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'UnionBase',
   'discriminator': 'type',

tests/qapi-schema/flat-union-clash-member.err

-tests/qapi-schema/flat-union-clash-member.json:27: 'name' (member of Branch1) collides with 'name' (member of Base)
+tests/qapi-schema/flat-union-clash-member.json:11: 'name' (member of Branch1) collides with 'name' (member of Base)

tests/qapi-schema/flat-union-clash-member.json

 # We check for no duplicate keys between branch members and base
 # base's member 'name' clashes with Branch1's
-
-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { 'enum1': 'TestEnum', '*name': 'str' } }
-##
-# @Branch1:
-##
 { 'struct': 'Branch1',
   'data': { 'name': 'str' } }
-##
-# @Branch2:
-##
 { 'struct': 'Branch2',
   'data': { 'value': 'int' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'Base',
   'discriminator': 'enum1',

tests/qapi-schema/flat-union-empty.err

-tests/qapi-schema/flat-union-empty.json:14: Union 'Union' cannot have empty 'data'
+tests/qapi-schema/flat-union-empty.json:4: Union 'Union' cannot have empty 'data'

tests/qapi-schema/flat-union-empty.json

 # flat unions cannot be empty
-
-##
-# @Empty:
-##
 { 'enum': 'Empty', 'data': [ ] }
-##
-# @Base:
-##
 { 'struct': 'Base', 'data': { 'type': 'Empty' } }
-##
-# @Union:
-##
 { 'union': 'Union', 'base': 'Base', 'discriminator': 'type', 'data': { } }

tests/qapi-schema/flat-union-incomplete-branch.err

-tests/qapi-schema/flat-union-incomplete-branch.json:16: Union 'TestUnion' data missing 'value2' branch
+tests/qapi-schema/flat-union-incomplete-branch.json:6: Union 'TestUnion' data missing 'value2' branch

tests/qapi-schema/flat-union-incomplete-branch.json

 # we require all branches of the union to be covered
-
-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': { 'type': 'TestEnum' },
   'discriminator': 'type',

tests/qapi-schema/flat-union-inline.err

-tests/qapi-schema/flat-union-inline.json:17: Member 'value1' of union 'TestUnion' should be a type name
+tests/qapi-schema/flat-union-inline.json:7: Member 'value1' of union 'TestUnion' should be a type name

tests/qapi-schema/flat-union-inline.json

 # we require branches to be a struct name
 # TODO: should we allow anonymous inline branch types?
-
-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { 'enum1': 'TestEnum', 'kind': 'str' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'Base',
   'discriminator': 'enum1',

tests/qapi-schema/flat-union-int-branch.err

-tests/qapi-schema/flat-union-int-branch.json:21: Member 'value1' of union 'TestUnion' cannot use built-in type 'int'
+tests/qapi-schema/flat-union-int-branch.json:8: Member 'value1' of union 'TestUnion' cannot use built-in type 'int'

tests/qapi-schema/flat-union-int-branch.json

 # we require flat union branches to be a struct
-
-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { 'enum1': 'TestEnum' } }
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'Base',
   'discriminator': 'enum1',

tests/qapi-schema/flat-union-invalid-branch-key.err

-tests/qapi-schema/flat-union-invalid-branch-key.json:28: Discriminator value 'value_wrong' is not found in enum 'TestEnum'
+tests/qapi-schema/flat-union-invalid-branch-key.json:13: Discriminator value 'value_wrong' is not found in enum 'TestEnum'

tests/qapi-schema/flat-union-invalid-branch-key.json

-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
 
-##
-# @TestBase:
-##
 { 'struct': 'TestBase',
   'data': { 'enum1': 'TestEnum' } }
 
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
 
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
 
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'TestBase',
   'discriminator': 'enum1',

tests/qapi-schema/flat-union-invalid-discriminator.err

-tests/qapi-schema/flat-union-invalid-discriminator.json:28: Discriminator 'enum_wrong' is not a member of base struct 'TestBase'
+tests/qapi-schema/flat-union-invalid-discriminator.json:13: Discriminator 'enum_wrong' is not a member of base struct 'TestBase'

tests/qapi-schema/flat-union-invalid-discriminator.json

-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
 
-##
-# @TestBase:
-##
 { 'struct': 'TestBase',
   'data': { 'enum1': 'TestEnum' } }
 
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
 
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
 
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'TestBase',
   'discriminator': 'enum_wrong',

tests/qapi-schema/flat-union-no-base.err

-tests/qapi-schema/flat-union-no-base.json:22: Flat union 'TestUnion' must have a base
+tests/qapi-schema/flat-union-no-base.json:9: Flat union 'TestUnion' must have a base

tests/qapi-schema/flat-union-no-base.json

 # flat unions require a base
 # TODO: simple unions should be able to use an enum discriminator
-
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
-##
-# @Enum:
-##
 { 'enum': 'Enum',
   'data': [ 'value1', 'value2' ] }
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'discriminator': 'Enum',
   'data': { 'value1': 'TestTypeA',

tests/qapi-schema/flat-union-optional-discriminator.err

-tests/qapi-schema/flat-union-optional-discriminator.json:19: Discriminator of flat union 'MyUnion' does not allow optional name '*switch'
+tests/qapi-schema/flat-union-optional-discriminator.json:6: Discriminator of flat union 'MyUnion' does not allow optional name '*switch'

tests/qapi-schema/flat-union-optional-discriminator.json

 # we require the discriminator to be non-optional
-
-##
-# @Enum:
-##
 { 'enum': 'Enum', 'data': [ 'one', 'two' ] }
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { '*switch': 'Enum' } }
-##
-# @Branch:
-##
 { 'struct': 'Branch', 'data': { 'name': 'str' } }
-##
-# @MyUnion:
-##
 { 'union': 'MyUnion',
   'base': 'Base',
   'discriminator': '*switch',

tests/qapi-schema/flat-union-string-discriminator.err

-tests/qapi-schema/flat-union-string-discriminator.json:28: Discriminator 'kind' must be of enumeration type
+tests/qapi-schema/flat-union-string-discriminator.json:13: Discriminator 'kind' must be of enumeration type

tests/qapi-schema/flat-union-string-discriminator.json

-##
-# @TestEnum:
-##
 { 'enum': 'TestEnum',
   'data': [ 'value1', 'value2' ] }
 
-##
-# @TestBase:
-##
 { 'struct': 'TestBase',
   'data': { 'enum1': 'TestEnum', 'kind': 'str' } }
 
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
 
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
 
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'TestBase',
   'discriminator': 'kind',

tests/qapi-schema/ident-with-escape.json

 # we allow escape sequences in strings, if they map back to ASCII
 # { 'command': 'fooA', 'data': { 'bar1': 'str' } }
-
-##
-# @fooA:
-##
 { 'c\u006fmmand': '\u0066\u006f\u006FA',
   'd\u0061ta': { '\u0062\u0061\u00721': '\u0073\u0074\u0072' } }

tests/qapi-schema/ident-with-escape.out

@@ -5,4 +5,3 @@ command fooA q_obj_fooA-arg -> None
 object q_empty
 object q_obj_fooA-arg
     member bar1: str optional=False
-doc symbol=fooA expr=('command', 'fooA')

tests/qapi-schema/include-relpath-sub.json

-##
-# @Status:
-##
 { 'enum': 'Status',
   'data': [ 'good', 'bad', 'ugly' ] }

tests/qapi-schema/include-relpath.out

@@ -2,4 +2,3 @@ enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbo
     prefix QTYPE
 enum Status ['good', 'bad', 'ugly']
 object q_empty
-doc symbol=Status expr=('enum', 'Status')

tests/qapi-schema/include-repetition.out

@@ -2,4 +2,3 @@ enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbo
     prefix QTYPE
 enum Status ['good', 'bad', 'ugly']
 object q_empty
-doc symbol=Status expr=('enum', 'Status')

tests/qapi-schema/include-simple-sub.json

-##
-# @Status:
-##
 { 'enum': 'Status',
   'data': [ 'good', 'bad', 'ugly' ] }

tests/qapi-schema/include-simple.out

@@ -2,4 +2,3 @@ enum QType ['none', 'qnull', 'qint', 'qstring', 'qdict', 'qlist', 'qfloat', 'qbo
     prefix QTYPE
 enum Status ['good', 'bad', 'ugly']
 object q_empty
-doc symbol=Status expr=('enum', 'Status')

tests/qapi-schema/indented-expr.json

-##
-# @eins:
-##
 { 'command' : 'eins' }
-##
-# @zwei:
-##
  { 'command' : 'zwei' }

tests/qapi-schema/indented-expr.out

@@ -5,5 +5,3 @@ command eins None -> None
 object q_empty
 command zwei None -> None
    gen=True success_response=True boxed=False
-doc symbol=eins expr=('command', 'eins')
-doc symbol=zwei expr=('command', 'zwei')

tests/qapi-schema/missing-type.err

-tests/qapi-schema/missing-type.json:6: Expression is missing metatype
+tests/qapi-schema/missing-type.json:2: Expression is missing metatype

tests/qapi-schema/missing-type.json

 # we reject an expression with missing metatype
-
-##
-# @foo:
-##
 { 'data': { } }

tests/qapi-schema/nested-struct-data.err

-tests/qapi-schema/nested-struct-data.json:6: Member 'a' of 'data' for command 'foo' should be a type name
+tests/qapi-schema/nested-struct-data.json:2: Member 'a' of 'data' for command 'foo' should be a type name

tests/qapi-schema/nested-struct-data.json

 # inline subtypes collide with our desired future use of defaults
-
-##
-# @foo:
-##
 { 'command': 'foo',
   'data': { 'a' : { 'string' : 'str', 'integer': 'int' }, 'b' : 'str' } }

tests/qapi-schema/qapi-schema-test.json

@@ -3,153 +3,67 @@
 # This file is a stress test of supported qapi constructs that must
 # parse and compile correctly.
 
-##
-# = Section
-# == subsection
-#
-# Some text foo with *strong* and _emphasis_
-# 1. with a list
-# 2. like that @foo
-#
-# And some code:
-# | $ echo foo
-# | -> do this
-# | <- get that
-#
-# Note: is not a meta
-##
-
-##
-# @TestStruct:
-#
-# body with @var
-#
-# @integer: foo
-#           blah
-#
-#           bao
-#
-# @boolean: bar
-# @string: baz
-#
-# Example:
-#
-# -> { "execute": ... }
-# <- { "return": ... }
-#
-# Since: 2.3
-# Note: a note
-#
-##
 { 'struct': 'TestStruct',
   'data': { 'integer': 'int', 'boolean': 'bool', 'string': 'str' } }
 
-##
-# @NestedEnumsOne:
 # for testing enums
-##
 { 'struct': 'NestedEnumsOne',
   'data': { 'enum1': 'EnumOne',   # Intentional forward reference
             '*enum2': 'EnumOne', 'enum3': 'EnumOne', '*enum4': 'EnumOne' } }
 
-##
-# @MyEnum:
 # An empty enum, although unusual, is currently acceptable
-##
 { 'enum': 'MyEnum', 'data': [ ] }
 
-##
-# @Empty1:
 # Likewise for an empty struct, including an empty base
-##
 { 'struct': 'Empty1', 'data': { } }
-##
-# @Empty2:
-##
 { 'struct': 'Empty2', 'base': 'Empty1', 'data': { } }
 
-##
-# @user_def_cmd0:
-##
 { 'command': 'user_def_cmd0', 'data': 'Empty2', 'returns': 'Empty2' }
 
-##
-# @QEnumTwo:
 # for testing override of default naming heuristic
-##
 { 'enum': 'QEnumTwo',
   'prefix': 'QENUM_TWO',
   'data': [ 'value1', 'value2' ] }
 
-##
-# @UserDefOne:
 # for testing nested structs
-##
 { 'struct': 'UserDefOne',
   'base': 'UserDefZero',        # intentional forward reference
   'data': { 'string': 'str',
             '*enum1': 'EnumOne' } }   # intentional forward reference
 
-##
-# @EnumOne:
-##
 { 'enum': 'EnumOne',
   'data': [ 'value1', 'value2', 'value3' ] }
 
-##
-# @UserDefZero:
-##
 { 'struct': 'UserDefZero',
   'data': { 'integer': 'int' } }
 
-##
-# @UserDefTwoDictDict:
-##
 { 'struct': 'UserDefTwoDictDict',
   'data': { 'userdef': 'UserDefOne', 'string': 'str' } }
 
-##
-# @UserDefTwoDict:
-##
 { 'struct': 'UserDefTwoDict',
   'data': { 'string1': 'str',
             'dict2': 'UserDefTwoDictDict',
             '*dict3': 'UserDefTwoDictDict' } }
 
-##
-# @UserDefTwo:
-##
 { 'struct': 'UserDefTwo',
   'data': { 'string0': 'str',
             'dict1': 'UserDefTwoDict' } }
 
-##
-# @ForceArrays:
 # dummy struct to force generation of array types not otherwise mentioned
-##
 { 'struct': 'ForceArrays',
   'data': { 'unused1':['UserDefOne'], 'unused2':['UserDefTwo'],
             'unused3':['TestStruct'] } }
 
-##
-# @UserDefA:
 # 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),
 # by intentionally using two branches that both have a C member 'a_b'
-##
 { 'struct': 'UserDefA',
   'data': { 'boolean': 'bool', '*a_b': 'int' } }
 
-##
-# @UserDefB:
-##
 { 'struct': 'UserDefB',
   'data': { 'intb': 'int', '*a-b': 'bool' } }
 
-##
-# @UserDefFlatUnion:
-##
 { 'union': 'UserDefFlatUnion',
   'base': 'UserDefUnionBase',   # intentional forward reference
   'discriminator': 'enum1',
@@ -157,71 +71,35 @@
             'value2' : 'UserDefB',
             'value3' : 'UserDefB' } }
 
-##
-# @UserDefUnionBase:
-##
 { 'struct': 'UserDefUnionBase',
   'base': 'UserDefZero',
   'data': { 'string': 'str', 'enum1': 'EnumOne' } }
 
-##
-# @UserDefFlatUnion2:
 # this variant of UserDefFlatUnion defaults to a union that uses members with
 # allocated types to test corner cases in the cleanup/dealloc visitor
-##
 { 'union': 'UserDefFlatUnion2',
   'base': { '*integer': 'int', 'string': 'str', 'enum1': 'QEnumTwo' },
   'discriminator': 'enum1',
   'data': { 'value1' : 'UserDefC', # intentional forward reference
             'value2' : 'UserDefB' } }
 
-##
-# @WrapAlternate:
-##
 { 'struct': 'WrapAlternate',
   'data': { 'alt': 'UserDefAlternate' } }
-##
-# @UserDefAlternate:
-##
 { 'alternate': 'UserDefAlternate',
   'data': { 'udfu': 'UserDefFlatUnion', 's': 'str', 'i': 'int' } }
 
-##
-# @UserDefC:
-##
 { 'struct': 'UserDefC',
   'data': { 'string1': 'str', 'string2': 'str' } }
 
 # for testing use of 'number' within alternates
-##
-# @AltStrBool:
-##
 { 'alternate': 'AltStrBool', 'data': { 's': 'str', 'b': 'bool' } }
-##
-# @AltStrNum:
-##
 { 'alternate': 'AltStrNum', 'data': { 's': 'str', 'n': 'number' } }
-##
-# @AltNumStr:
-##
 { 'alternate': 'AltNumStr', 'data': { 'n': 'number', 's': 'str' } }
-##
-# @AltStrInt:
-##
 { 'alternate': 'AltStrInt', 'data': { 's': 'str', 'i': 'int' } }
-##
-# @AltIntNum:
-##
 { 'alternate': 'AltIntNum', 'data': { 'i': 'int', 'n': 'number' } }
-##
-# @AltNumInt:
-##
 { 'alternate': 'AltNumInt', 'data': { 'n': 'number', 'i': 'int' } }
 
-##
-# @UserDefNativeListUnion:
 # for testing native lists
-##
 { 'union': 'UserDefNativeListUnion',
   'data': { 'integer': ['int'],
             's8': ['int8'],
@@ -239,61 +117,19 @@
             'any': ['any'] } }
 
 # testing commands
-##
-# @user_def_cmd:
-##
 { 'command': 'user_def_cmd', 'data': {} }
-##
-# @user_def_cmd1:
-##
 { 'command': 'user_def_cmd1', 'data': {'ud1a': 'UserDefOne'} }
-##
-# @user_def_cmd2:
-##
 { 'command': 'user_def_cmd2',
   'data': {'ud1a': 'UserDefOne', '*ud1b': 'UserDefOne'},
   'returns': 'UserDefTwo' }
 
-##
-# Another comment
-##
-
-##
-# @guest-get-time:
-#
-# @guest-get-time body
-#
-# @a: an integer
-# @b: #optional integer
-#
-# Returns: returns something
-#
-# Example:
-#
-# -> { "execute": "guest-get-time", ... }
-# <- { "return": "42" }
-#
-##
-
 # Returning a non-dictionary requires a name from the whitelist
 { 'command': 'guest-get-time', 'data': {'a': 'int', '*b': 'int' },
   'returns': 'int' }
-##
-# @guest-sync:
-##
 { 'command': 'guest-sync', 'data': { 'arg': 'any' }, 'returns': 'any' }
-##
-# @boxed-struct:
-##
 { 'command': 'boxed-struct', 'boxed': true, 'data': 'UserDefZero' }
-##
-# @boxed-union:
-##
 { 'command': 'boxed-union', 'data': 'UserDefNativeListUnion', 'boxed': true }
 
-##
-# @UserDefOptions:
-#
 # For testing integer range flattening in opts-visitor. The following schema
 # corresponds to the option format:
 #
@@ -301,7 +137,6 @@
 #
 # For simplicity, this example doesn't use [type=]discriminator nor optargs
 # specific to discriminator values.
-##
 { 'struct': 'UserDefOptions',
   'data': {
     '*i64' : [ 'int'    ],
@@ -311,83 +146,35 @@
     '*u64x':   'uint64'  } }
 
 # testing event
-##
-# @EventStructOne:
-##
 { 'struct': 'EventStructOne',
   'data': { 'struct1': 'UserDefOne', 'string': 'str', '*enum2': 'EnumOne' } }
 
-##
-# @EVENT_A:
-##
 { 'event': 'EVENT_A' }
-##
-# @EVENT_B:
-##
 { 'event': 'EVENT_B',
   'data': { } }
-##
-# @EVENT_C:
-##
 { 'event': 'EVENT_C',
   'data': { '*a': 'int', '*b': 'UserDefOne', 'c': 'str' } }
-##
-# @EVENT_D:
-##
 { 'event': 'EVENT_D',
   'data': { 'a' : 'EventStructOne', 'b' : 'str', '*c': 'str', '*enum3': 'EnumOne' } }
-##
-# @EVENT_E:
-##
 { 'event': 'EVENT_E', 'boxed': true, 'data': 'UserDefZero' }
-##
-# @EVENT_F:
-##
 { 'event': 'EVENT_F', 'boxed': true, 'data': 'UserDefAlternate' }
 
 # test that we correctly compile downstream extensions, as well as munge
 # ticklish names
-##
-# @__org.qemu_x-Enum:
-##
 { 'enum': '__org.qemu_x-Enum', 'data': [ '__org.qemu_x-value' ] }
-##
-# @__org.qemu_x-Base:
-##
 { 'struct': '__org.qemu_x-Base',
   'data': { '__org.qemu_x-member1': '__org.qemu_x-Enum' } }
-##
-# @__org.qemu_x-Struct:
-##
 { 'struct': '__org.qemu_x-Struct', 'base': '__org.qemu_x-Base',
   'data': { '__org.qemu_x-member2': 'str', '*wchar-t': 'int' } }
-##
-# @__org.qemu_x-Union1:
-##
 { 'union': '__org.qemu_x-Union1', 'data': { '__org.qemu_x-branch': 'str' } }
-##
-# @__org.qemu_x-Struct2:
-##
 { 'struct': '__org.qemu_x-Struct2',
   'data': { 'array': ['__org.qemu_x-Union1'] } }
-##
-# @__org.qemu_x-Union2:
-##
 { 'union': '__org.qemu_x-Union2', 'base': '__org.qemu_x-Base',
   'discriminator': '__org.qemu_x-member1',
   'data': { '__org.qemu_x-value': '__org.qemu_x-Struct2' } }
-##
-# @__org.qemu_x-Alt:
-##
 { 'alternate': '__org.qemu_x-Alt',
   'data': { '__org.qemu_x-branch': 'str', 'b': '__org.qemu_x-Base' } }
-##
-# @__ORG.QEMU_X-EVENT:
-##
 { 'event': '__ORG.QEMU_X-EVENT', 'data': '__org.qemu_x-Struct' }
-##
-# @__org.qemu_x-command:
-##
 { 'command': '__org.qemu_x-command',
   'data': { 'a': ['__org.qemu_x-Enum'], 'b': ['__org.qemu_x-Struct'],
             'c': '__org.qemu_x-Union2', 'd': '__org.qemu_x-Alt' },

tests/qapi-schema/qapi-schema-test.out

@@ -232,133 +232,3 @@ command user_def_cmd1 q_obj_user_def_cmd1-arg -> None
    gen=True success_response=True boxed=False
 command user_def_cmd2 q_obj_user_def_cmd2-arg -> UserDefTwo
    gen=True success_response=True boxed=False
-doc freeform
-    body=
-= Section
-== subsection
-
-Some text foo with *strong* and _emphasis_
-1. with a list
-2. like that @foo
-
-And some code:
-| $ echo foo
-| -> do this
-| <- get that
-
-Note: is not a meta
-doc symbol=TestStruct expr=('struct', 'TestStruct')
-    arg=integer
-foo
-blah
-
-bao
-    arg=boolean
-bar
-    arg=string
-baz
-    section=Example
--> { "execute": ... }
-<- { "return": ... }
-    section=Since
-2.3
-    section=Note
-a note
-    body=
-body with @var
-doc symbol=NestedEnumsOne expr=('struct', 'NestedEnumsOne')
-    body=
-for testing enums
-doc symbol=MyEnum expr=('enum', 'MyEnum')
-    body=
-An empty enum, although unusual, is currently acceptable
-doc symbol=Empty1 expr=('struct', 'Empty1')
-    body=
-Likewise for an empty struct, including an empty base
-doc symbol=Empty2 expr=('struct', 'Empty2')
-doc symbol=user_def_cmd0 expr=('command', 'user_def_cmd0')
-doc symbol=QEnumTwo expr=('enum', 'QEnumTwo')
-    body=
-for testing override of default naming heuristic
-doc symbol=UserDefOne expr=('struct', 'UserDefOne')
-    body=
-for testing nested structs
-doc symbol=EnumOne expr=('enum', 'EnumOne')
-doc symbol=UserDefZero expr=('struct', 'UserDefZero')
-doc symbol=UserDefTwoDictDict expr=('struct', 'UserDefTwoDictDict')
-doc symbol=UserDefTwoDict expr=('struct', 'UserDefTwoDict')
-doc symbol=UserDefTwo expr=('struct', 'UserDefTwo')
-doc symbol=ForceArrays expr=('struct', 'ForceArrays')
-    body=
-dummy struct to force generation of array types not otherwise mentioned
-doc symbol=UserDefA expr=('struct', 'UserDefA')
-    body=
-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),
-by intentionally using two branches that both have a C member 'a_b'
-doc symbol=UserDefB expr=('struct', 'UserDefB')
-doc symbol=UserDefFlatUnion expr=('union', 'UserDefFlatUnion')
-doc symbol=UserDefUnionBase expr=('struct', 'UserDefUnionBase')
-doc symbol=UserDefFlatUnion2 expr=('union', 'UserDefFlatUnion2')
-    body=
-this variant of UserDefFlatUnion defaults to a union that uses members with
-allocated types to test corner cases in the cleanup/dealloc visitor
-doc symbol=WrapAlternate expr=('struct', 'WrapAlternate')
-doc symbol=UserDefAlternate expr=('alternate', 'UserDefAlternate')
-doc symbol=UserDefC expr=('struct', 'UserDefC')
-doc symbol=AltStrBool expr=('alternate', 'AltStrBool')
-doc symbol=AltStrNum expr=('alternate', 'AltStrNum')
-doc symbol=AltNumStr expr=('alternate', 'AltNumStr')
-doc symbol=AltStrInt expr=('alternate', 'AltStrInt')
-doc symbol=AltIntNum expr=('alternate', 'AltIntNum')
-doc symbol=AltNumInt expr=('alternate', 'AltNumInt')
-doc symbol=UserDefNativeListUnion expr=('union', 'UserDefNativeListUnion')
-    body=
-for testing native lists
-doc symbol=user_def_cmd expr=('command', 'user_def_cmd')
-doc symbol=user_def_cmd1 expr=('command', 'user_def_cmd1')
-doc symbol=user_def_cmd2 expr=('command', 'user_def_cmd2')
-doc freeform
-    body=
-Another comment
-doc symbol=guest-get-time expr=('command', 'guest-get-time')
-    arg=a
-an integer
-    arg=b
-#optional integer
-    section=Returns
-returns something
-    section=Example
--> { "execute": "guest-get-time", ... }
-<- { "return": "42" }
-    body=
-@guest-get-time body
-doc symbol=guest-sync expr=('command', 'guest-sync')
-doc symbol=boxed-struct expr=('command', 'boxed-struct')
-doc symbol=boxed-union expr=('command', 'boxed-union')
-doc symbol=UserDefOptions expr=('struct', 'UserDefOptions')
-    body=
-For testing integer range flattening in opts-visitor. The following schema
-corresponds to the option format:
-
--userdef i64=3-6,i64=-5--1,u64=2,u16=1,u16=7-12
-
-For simplicity, this example doesn't use [type=]discriminator nor optargs
-specific to discriminator values.
-doc symbol=EventStructOne expr=('struct', 'EventStructOne')
-doc symbol=EVENT_A expr=('event', 'EVENT_A')
-doc symbol=EVENT_B expr=('event', 'EVENT_B')
-doc symbol=EVENT_C expr=('event', 'EVENT_C')
-doc symbol=EVENT_D expr=('event', 'EVENT_D')
-doc symbol=EVENT_E expr=('event', 'EVENT_E')
-doc symbol=EVENT_F expr=('event', 'EVENT_F')
-doc symbol=__org.qemu_x-Enum expr=('enum', '__org.qemu_x-Enum')
-doc symbol=__org.qemu_x-Base expr=('struct', '__org.qemu_x-Base')
-doc symbol=__org.qemu_x-Struct expr=('struct', '__org.qemu_x-Struct')
-doc symbol=__org.qemu_x-Union1 expr=('union', '__org.qemu_x-Union1')
-doc symbol=__org.qemu_x-Struct2 expr=('struct', '__org.qemu_x-Struct2')
-doc symbol=__org.qemu_x-Union2 expr=('union', '__org.qemu_x-Union2')
-doc symbol=__org.qemu_x-Alt expr=('alternate', '__org.qemu_x-Alt')
-doc symbol=__ORG.QEMU_X-EVENT expr=('event', '__ORG.QEMU_X-EVENT')
-doc symbol=__org.qemu_x-command expr=('command', '__org.qemu_x-command')

tests/qapi-schema/redefined-builtin.err

-tests/qapi-schema/redefined-builtin.json:6: built-in 'size' is already defined
+tests/qapi-schema/redefined-builtin.json:2: built-in 'size' is already defined

tests/qapi-schema/redefined-builtin.json

 # we reject types that duplicate builtin names
-
-##
-# @size:
-##
 { 'struct': 'size', 'data': { 'myint': 'size' } }

tests/qapi-schema/redefined-command.err

-tests/qapi-schema/redefined-command.json:10: command 'foo' is already defined
+tests/qapi-schema/redefined-command.json:3: command 'foo' is already defined

tests/qapi-schema/redefined-command.json

 # we reject commands defined more than once
-
-##
-# @foo:
-##
 { 'command': 'foo', 'data': { 'one': 'str' } }
-##
-# @foo:
-##
 { 'command': 'foo', 'data': { '*two': 'str' } }

tests/qapi-schema/redefined-event.err

-tests/qapi-schema/redefined-event.json:10: event 'EVENT_A' is already defined
+tests/qapi-schema/redefined-event.json:3: event 'EVENT_A' is already defined

tests/qapi-schema/redefined-event.json

 # we reject duplicate events
-
-##
-# @EVENT_A:
-##
 { 'event': 'EVENT_A', 'data': { 'myint': 'int' } }
-##
-# @EVENT_A:
-##
 { 'event': 'EVENT_A', 'data': { 'myint': 'int' } }

tests/qapi-schema/redefined-type.err

-tests/qapi-schema/redefined-type.json:10: struct 'foo' is already defined
+tests/qapi-schema/redefined-type.json:3: struct 'foo' is already defined

tests/qapi-schema/redefined-type.json

 # we reject types defined more than once
-
-##
-# @foo:
-##
 { 'struct': 'foo', 'data': { 'one': 'str' } }
-##
-# @foo:
-##
 { 'enum': 'foo', 'data': [ 'two' ] }

tests/qapi-schema/reserved-command-q.err

-tests/qapi-schema/reserved-command-q.json:12: 'command' uses invalid name 'q-unix'
+tests/qapi-schema/reserved-command-q.json:5: 'command' uses invalid name 'q-unix'

tests/qapi-schema/reserved-command-q.json

 # C entity name collision
 # We reject names like 'q-unix', because they can collide with the mangled
 # name for 'unix' in generated C.
-
-##
-# @unix:
-##
 { 'command': 'unix' }
-##
-# @q-unix:
-##
 { 'command': 'q-unix' }

tests/qapi-schema/reserved-enum-q.err

-tests/qapi-schema/reserved-enum-q.json:8: Member of enum 'Foo' uses invalid name 'q-Unix'
+tests/qapi-schema/reserved-enum-q.json:4: Member of enum 'Foo' uses invalid name 'q-Unix'

tests/qapi-schema/reserved-enum-q.json

 # C entity name collision
 # We reject names like 'q-unix', because they can collide with the mangled
 # name for 'unix' in generated C.
-
-##
-# @Foo:
-##
 { 'enum': 'Foo', 'data': [ 'unix', 'q-Unix' ] }

tests/qapi-schema/reserved-member-has.err

-tests/qapi-schema/reserved-member-has.json:9: Member of 'data' for command 'oops' uses reserved name 'has-a'
+tests/qapi-schema/reserved-member-has.json:5: Member of 'data' for command 'oops' uses reserved name 'has-a'

tests/qapi-schema/reserved-member-has.json

@@ -2,8 +2,4 @@
 # We reject names like 'has-a', because they can collide with the flag
 # for an optional 'a' in generated C.
 # TODO we could munge the optional flag name to avoid the collision.
-
-##
-# @oops:
-##
 { 'command': 'oops', 'data': { '*a': 'str', 'has-a': 'str' } }

tests/qapi-schema/reserved-member-q.err

-tests/qapi-schema/reserved-member-q.json:8: Member of 'data' for struct 'Foo' uses invalid name 'q-unix'
+tests/qapi-schema/reserved-member-q.json:4: Member of 'data' for struct 'Foo' uses invalid name 'q-unix'

tests/qapi-schema/reserved-member-q.json

 # C member name collision
 # We reject names like 'q-unix', because they can collide with the mangled
 # name for 'unix' in generated C.
-
-##
-# @Foo:
-##
 { 'struct': 'Foo', 'data': { 'unix':'int', 'q-unix':'bool' } }

tests/qapi-schema/reserved-member-u.err

-tests/qapi-schema/reserved-member-u.json:11: Member of 'data' for struct 'Oops' uses reserved name 'u'
+tests/qapi-schema/reserved-member-u.json:7: Member of 'data' for struct 'Oops' uses reserved name 'u'

tests/qapi-schema/reserved-member-u.json

@@ -4,8 +4,4 @@
 # This is true even for non-unions, because it is possible to convert a
 # struct to flat union while remaining backwards compatible in QMP.
 # TODO - we could munge the member name to 'q_u' to avoid the collision
-
-##
-# @Oops:
-##
 { 'struct': 'Oops', 'data': { 'u': 'str' } }

tests/qapi-schema/reserved-member-underscore.err

-tests/qapi-schema/reserved-member-underscore.json:8: Member of 'data' for struct 'Oops' uses invalid name '_oops'
+tests/qapi-schema/reserved-member-underscore.json:4: Member of 'data' for struct 'Oops' uses invalid name '_oops'

tests/qapi-schema/reserved-member-underscore.json

 # C member name collision
 # We reject use of a single leading underscore in all names (names must
 # begin with a letter or a downstream extension double-underscore prefix).
-
-##
-# @Oops:
-##
 { 'struct': 'Oops', 'data': { '_oops': 'str' } }

tests/qapi-schema/reserved-type-kind.err

-tests/qapi-schema/reserved-type-kind.json:6: enum 'UnionKind' should not end in 'Kind'
+tests/qapi-schema/reserved-type-kind.json:2: enum 'UnionKind' should not end in 'Kind'

tests/qapi-schema/reserved-type-kind.json

 # we reject types that would conflict with implicit union enum
-
-##
-# @UnionKind:
-##
 { 'enum': 'UnionKind', 'data': [ 'oops' ] }

tests/qapi-schema/reserved-type-list.err

-tests/qapi-schema/reserved-type-list.json:9: struct 'FooList' should not end in 'List'
+tests/qapi-schema/reserved-type-list.json:5: struct 'FooList' should not end in 'List'

tests/qapi-schema/reserved-type-list.json

@@ -2,8 +2,4 @@
 # We reserve names ending in 'List' for use by array types.
 # TODO - we could choose array names to avoid collision with user types,
 # in order to let this compile
-
-##
-# @FooList:
-##
 { 'struct': 'FooList', 'data': { 's': 'str' } }

tests/qapi-schema/returns-alternate.err

-tests/qapi-schema/returns-alternate.json:10: 'returns' for command 'oops' cannot use alternate type 'Alt'
+tests/qapi-schema/returns-alternate.json:3: 'returns' for command 'oops' cannot use alternate type 'Alt'

tests/qapi-schema/returns-alternate.json

 # we reject returns if it is an alternate type
-
-##
-# @Alt:
-##
 { 'alternate': 'Alt', 'data': { 'a': 'int', 'b': 'str' } }
-##
-# @oops:
-##
 { 'command': 'oops', 'returns': 'Alt' }

tests/qapi-schema/returns-array-bad.err

-tests/qapi-schema/returns-array-bad.json:6: 'returns' for command 'oops': array type must contain single type name
+tests/qapi-schema/returns-array-bad.json:2: 'returns' for command 'oops': array type must contain single type name

tests/qapi-schema/returns-array-bad.json

 # we reject an array return that is not a single type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'returns': [ 'str', 'str' ] }

tests/qapi-schema/returns-dict.err

-tests/qapi-schema/returns-dict.json:6: 'returns' for command 'oops' should be a type name
+tests/qapi-schema/returns-dict.json:2: 'returns' for command 'oops' should be a type name

tests/qapi-schema/returns-dict.json

 # we reject inline struct return type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'returns': { 'a': 'str' } }

tests/qapi-schema/returns-unknown.err

-tests/qapi-schema/returns-unknown.json:6: 'returns' for command 'oops' uses unknown type 'NoSuchType'
+tests/qapi-schema/returns-unknown.json:2: 'returns' for command 'oops' uses unknown type 'NoSuchType'

tests/qapi-schema/returns-unknown.json

 # we reject returns if it does not contain a known type
-
-##
-# @oops:
-##
 { 'command': 'oops', 'returns': 'NoSuchType' }

tests/qapi-schema/returns-whitelist.err

-tests/qapi-schema/returns-whitelist.json:26: 'returns' for command 'no-way-this-will-get-whitelisted' cannot use built-in type 'int'
+tests/qapi-schema/returns-whitelist.json:10: 'returns' for command 'no-way-this-will-get-whitelisted' cannot use built-in type 'int'

tests/qapi-schema/returns-whitelist.json

 # we enforce that 'returns' be a dict or array of dict unless whitelisted
-
-##
-# @human-monitor-command:
-##
 { 'command': 'human-monitor-command',
   'data': {'command-line': 'str', '*cpu-index': 'int'},
   'returns': 'str' }
-##
-# @TpmModel:
-##
 { 'enum': 'TpmModel', 'data': [ 'tpm-tis' ] }
-##
-# @query-tpm-models:
-##
 { 'command': 'query-tpm-models', 'returns': ['TpmModel'] }
-##
-# @guest-get-time:
-##
 { 'command': 'guest-get-time',
   'returns': 'int' }
 
-##
-# @no-way-this-will-get-whitelisted:
-##
 { 'command': 'no-way-this-will-get-whitelisted',
   'returns': [ 'int' ] }

tests/qapi-schema/struct-base-clash-deep.err

-tests/qapi-schema/struct-base-clash-deep.json:20: 'name' (member of Sub) collides with 'name' (member of Base)
+tests/qapi-schema/struct-base-clash-deep.json:10: 'name' (member of Sub) collides with 'name' (member of Base)

tests/qapi-schema/struct-base-clash-deep.json

@@ -2,21 +2,11 @@
 # Here, 'name' would have to appear twice on the wire, locally and
 # indirectly for the grandparent base; the collision doesn't care that
 # one instance is optional.
-
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { 'name': 'str' } }
-##
-# @Mid:
-##
 { 'struct': 'Mid',
   'base': 'Base',
   'data': { 'value': 'int' } }
-##
-# @Sub:
-##
 { 'struct': 'Sub',
   'base': 'Mid',
   'data': { '*name': 'str' } }

tests/qapi-schema/struct-base-clash.err

-tests/qapi-schema/struct-base-clash.json:12: 'name' (member of Sub) collides with 'name' (member of Base)
+tests/qapi-schema/struct-base-clash.json:5: 'name' (member of Sub) collides with 'name' (member of Base)

tests/qapi-schema/struct-base-clash.json

 # Reject attempts to duplicate QMP members
 # Here, 'name' would have to appear twice on the wire, locally and for base.
-
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { 'name': 'str' } }
-##
-# @Sub:
-##
 { 'struct': 'Sub',
   'base': 'Base',
   'data': { 'name': 'str' } }

tests/qapi-schema/struct-data-invalid.err

-tests/qapi-schema/struct-data-invalid.json:4: 'data' for struct 'foo' should be a dictionary or type name
+tests/qapi-schema/struct-data-invalid.json:1: 'data' for struct 'foo' should be a dictionary or type name

tests/qapi-schema/struct-data-invalid.json

-##
-# @foo:
-##
 { 'struct': 'foo',
   'data': false }

tests/qapi-schema/struct-member-invalid.err

-tests/qapi-schema/struct-member-invalid.json:4: Member 'a' of 'data' for struct 'foo' should be a type name
+tests/qapi-schema/struct-member-invalid.json:1: Member 'a' of 'data' for struct 'foo' should be a type name

tests/qapi-schema/struct-member-invalid.json

-##
-# @foo:
-##
 { 'struct': 'foo',
   'data': { 'a': false } }

tests/qapi-schema/test-qapi.py

@@ -55,17 +55,3 @@ class QAPISchemaTestVisitor(QAPISchemaVisitor):
 
 schema = QAPISchema(sys.argv[1])
 schema.visit(QAPISchemaTestVisitor())
-
-for doc in schema.docs:
-    if doc.symbol:
-        print 'doc symbol=%s expr=%s' % \
-            (doc.symbol, doc.expr.items()[0])
-    else:
-        print 'doc freeform'
-    for arg, section in doc.args.iteritems():
-        print '    arg=%s\n%s' % (arg, section)
-    for section in doc.sections:
-        print '    section=%s\n%s' % (section.name, section)
-    body = str(doc.body)
-    if body:
-        print '    body=\n%s' % body

tests/qapi-schema/type-bypass-bad-gen.err

-tests/qapi-schema/type-bypass-bad-gen.json:6: 'gen' of command 'foo' should only use false value
+tests/qapi-schema/type-bypass-bad-gen.json:2: 'gen' of command 'foo' should only use false value

tests/qapi-schema/type-bypass-bad-gen.json

 # 'gen' should only appear with value false
-
-##
-# @foo:
-##
 { 'command': 'foo', 'gen': 'whatever' }

tests/qapi-schema/unicode-str.err

-tests/qapi-schema/unicode-str.json:6: 'command' uses invalid name 'é'
+tests/qapi-schema/unicode-str.json:2: 'command' uses invalid name 'é'

tests/qapi-schema/unicode-str.json

 # we don't support full Unicode strings, yet
-
-##
-# @e:
-##
 { 'command': 'é' }

tests/qapi-schema/union-base-no-discriminator.err

-tests/qapi-schema/union-base-no-discriminator.json:23: Simple union 'TestUnion' must not have a base
+tests/qapi-schema/union-base-no-discriminator.json:11: Simple union 'TestUnion' must not have a base

tests/qapi-schema/union-base-no-discriminator.json

-##
-# @TestTypeA:
-##
 # we reject simple unions with a base (or flat unions without discriminator)
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
 
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
 
-##
-# @Base:
-##
 { 'struct': 'Base',
   'data': { 'string': 'str' } }
 
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'Base',
   'data': { 'value1': 'TestTypeA',

tests/qapi-schema/union-branch-case.err

-tests/qapi-schema/union-branch-case.json:6: 'Branch' (branch of NoWayThisWillGetWhitelisted) should not use uppercase
+tests/qapi-schema/union-branch-case.json:2: 'Branch' (branch of NoWayThisWillGetWhitelisted) should not use uppercase

tests/qapi-schema/union-branch-case.json

 # Branch names should be 'lower-case' unless the union is whitelisted
-
-##
-# @NoWayThisWillGetWhitelisted:
-##
 { 'union': 'NoWayThisWillGetWhitelisted', 'data': { 'Branch': 'int' } }

tests/qapi-schema/union-clash-branches.err

-tests/qapi-schema/union-clash-branches.json:8: 'a_b' (branch of TestUnion) collides with 'a-b' (branch of TestUnion)
+tests/qapi-schema/union-clash-branches.json:4: 'a_b' (branch of TestUnion) collides with 'a-b' (branch of TestUnion)

tests/qapi-schema/union-clash-branches.json

 # Union branch name collision
 # Reject a union that would result in a collision in generated C names (this
 # would try to generate two members 'a_b').
-
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'data': { 'a-b': 'int', 'a_b': 'str' } }

tests/qapi-schema/union-empty.err

-tests/qapi-schema/union-empty.json:6: Union 'Union' cannot have empty 'data'
+tests/qapi-schema/union-empty.json:2: Union 'Union' cannot have empty 'data'

tests/qapi-schema/union-empty.json

 # unions cannot be empty
-
-##
-# @Union:
-##
 { 'union': 'Union', 'data': { } }

tests/qapi-schema/union-invalid-base.err

-tests/qapi-schema/union-invalid-base.json:18: 'base' for union 'TestUnion' cannot use built-in type 'int'
+tests/qapi-schema/union-invalid-base.json:8: 'base' for union 'TestUnion' cannot use built-in type 'int'

tests/qapi-schema/union-invalid-base.json

 # a union base type must be a struct
-
-##
-# @TestTypeA:
-##
 { 'struct': 'TestTypeA',
   'data': { 'string': 'str' } }
 
-##
-# @TestTypeB:
-##
 { 'struct': 'TestTypeB',
   'data': { 'integer': 'int' } }
 
-##
-# @TestUnion:
-##
 { 'union': 'TestUnion',
   'base': 'int',
   'discriminator': 'int',

tests/qapi-schema/union-optional-branch.err

-tests/qapi-schema/union-optional-branch.json:6: Member of union 'Union' does not allow optional name '*a'
+tests/qapi-schema/union-optional-branch.json:2: Member of union 'Union' does not allow optional name '*a'

tests/qapi-schema/union-optional-branch.json

 # union branches cannot be optional
-
-##
-# @Union:
-##
 { 'union': 'Union', 'data': { '*a': 'int', 'b': 'str' } }

tests/qapi-schema/union-unknown.err

-tests/qapi-schema/union-unknown.json:6: Member 'unknown' of union 'Union' uses unknown type 'MissingType'
+tests/qapi-schema/union-unknown.json:2: Member 'unknown' of union 'Union' uses unknown type 'MissingType'

tests/qapi-schema/union-unknown.json

 # we reject a union with unknown type in branch
-
-##
-# @Union:
-##
 { 'union': 'Union',
   'data': { 'unknown': 'MissingType' } }

tests/qapi-schema/unknown-escape.err

-tests/qapi-schema/unknown-escape.json:7:21: Unknown escape \x
+tests/qapi-schema/unknown-escape.json:3:21: Unknown escape \x

tests/qapi-schema/unknown-escape.json

 # we only recognize JSON escape sequences, plus our \' extension (no \x)
-
-##
-# @foo:
-##
 # { 'command': 'foo', 'data': {} }
 { 'command': 'foo', 'dat\x61':{} }

tests/qapi-schema/unknown-expr-key.err

-tests/qapi-schema/unknown-expr-key.json:6: Unknown key 'bogus' in struct 'bar'
+tests/qapi-schema/unknown-expr-key.json:2: Unknown key 'bogus' in struct 'bar'

tests/qapi-schema/unknown-expr-key.json

 # we reject an expression with unknown top-level keys
-
-##
-# @bar:
-##
 { 'struct': 'bar', 'data': { 'string': 'str'}, 'bogus': { } }