Merge lp:~ubuntu-branches/ubuntu/natty/gobject-introspection/natty-201101212212 into lp:ubuntu/natty/gobject-introspection

[James Westby]

The package history in the archive and the history in the bzr branch differ. As the archive is authoritative the history of lp:ubuntu/natty/gobject-introspection now reflects that and the old bzr branch has been pushed to lp:~ubuntu-branches/ubuntu/natty/gobject-introspection/natty-201101212212. A merge should be performed if necessary.

Unmerged revisions

39. By Ken VanDine on 2011-01-21

releasing version 0.10.1-1ubuntu1

38. By Ken VanDine on 2011-01-21

releasing version 0.10.1-1ubuntu2

37. By Ken VanDine on 2011-01-21

releasing version 0.10.1-1ubuntu1

=== removed directory '.pc'
=== removed file '.pc/.version'
--- .pc/.version	2011-01-21 11:20:57 +0000
+++ .pc/.version	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-2

=== removed directory '.pc/0001-Preserve-the-c-type-of-array-elements.patch'
=== removed directory '.pc/0001-Preserve-the-c-type-of-array-elements.patch/giscanner'
=== removed file '.pc/0001-Preserve-the-c-type-of-array-elements.patch/giscanner/maintransformer.py'
--- .pc/0001-Preserve-the-c-type-of-array-elements.patch/giscanner/maintransformer.py	2011-01-21 11:20:57 +0000
+++ .pc/0001-Preserve-the-c-type-of-array-elements.patch/giscanner/maintransformer.py	1970-01-01 00:00:00 +0000
@@ -1,1130 +0,0 @@
-# -*- Mode: Python -*-
-# Copyright (C) 2010 Red Hat, Inc.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the
-# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-# Boston, MA 02111-1307, USA.
-#
-
-import re
-
-from . import ast
-from . import message
-from .annotationparser import (TAG_VFUNC, TAG_SINCE, TAG_DEPRECATED, TAG_RETURNS,
-                               TAG_ATTRIBUTES, TAG_RENAME_TO, TAG_TYPE,
-                               TAG_UNREF_FUNC, TAG_REF_FUNC, TAG_SET_VALUE_FUNC,
-                               TAG_GET_VALUE_FUNC)
-from .annotationparser import (OPT_ALLOW_NONE, OPT_ARRAY, OPT_ATTRIBUTE,
-                               OPT_ELEMENT_TYPE, OPT_IN, OPT_INOUT,
-                               OPT_INOUT_ALT, OPT_OUT, OPT_SCOPE,
-                               OPT_OUT_CALLER_ALLOCATES, OPT_OUT_CALLEE_ALLOCATES,
-                               OPT_TYPE, OPT_CLOSURE, OPT_DESTROY, OPT_TRANSFER, OPT_SKIP,
-                               OPT_FOREIGN, OPT_ARRAY_FIXED_SIZE,
-                               OPT_ARRAY_LENGTH, OPT_ARRAY_ZERO_TERMINATED)
-from .annotationparser import AnnotationParser
-from .transformer import TransformerException
-from .utils import to_underscores, to_underscores_noprefix
-
-class MainTransformer(object):
-
-    def __init__(self, transformer, blocks):
-        self._transformer = transformer
-        self._blocks = blocks
-        self._namespace = transformer.namespace
-        self._uscore_type_names = {}
-
-    # Public API
-
-    def transform(self):
-        contents = list(self._namespace.itervalues())
-        if len(contents) == 0:
-            message.fatal("""Namespace is empty; likely causes are:
-* Not including .h files to be scanned
-* Broken --identifier-prefix
-""")
-
-        # Some initial namespace surgery
-        self._namespace.walk(self._pass_fixup_hidden_fields)
-
-        # We have a rough tree which should have most of of the types
-        # we know about.  Let's attempt closure; walk over all of the
-        # Type() types and see if they match up with something.
-        self._namespace.walk(self._pass_type_resolution)
-
-        # Read in annotations needed early
-        self._namespace.walk(self._pass_read_annotations_early)
-
-        # Determine some default values for transfer etc.
-        # based on the current tree.
-        self._namespace.walk(self._pass_callable_defaults)
-
-        # Read in most annotations now.
-        self._namespace.walk(self._pass_read_annotations)
-
-        # Now that we've possibly seen more types from annotations,
-        # do another type resolution pass.
-        self._namespace.walk(self._pass_type_resolution)
-
-        # Generate a reverse mapping "bar_baz" -> BarBaz
-        for node in self._namespace.itervalues():
-            if isinstance(node, ast.Registered) and node.get_type is not None:
-                self._uscore_type_names[node.c_symbol_prefix] = node
-            elif isinstance(node, (ast.Record, ast.Union)):
-                uscored = to_underscores_noprefix(node.name).lower()
-                self._uscore_type_names[uscored] = node
-
-        for node in list(self._namespace.itervalues()):
-            if isinstance(node, ast.Function):
-                # Discover which toplevel functions are actually methods
-                self._pair_function(node)
-            if isinstance(node, (ast.Class, ast.Interface)):
-                self._pair_class_virtuals(node)
-
-        # Some annotations need to be post function pairing
-        self._namespace.walk(self._pass_read_annotations2)
-
-        # Another type resolution pass after we've parsed virtuals, etc.
-        self._namespace.walk(self._pass_type_resolution)
-
-        self._namespace.walk(self._pass3)
-
-        # TODO - merge into pass3
-        self._pair_quarks_with_enums()
-
-    # Private
-
-    def _pass_fixup_hidden_fields(self, node, chain):
-        """Hide all callbacks starting with _; the typical
-usage is void (*_gtk_reserved1)(void);"""
-        if not isinstance(node, (ast.Class, ast.Interface,
-                                 ast.Record, ast.Union)):
-            return True
-        for field in node.fields:
-            if field is None:
-                continue
-            if (field.name.startswith('_')
-                and field.anonymous_node is not None
-                and isinstance(field.anonymous_node, ast.Callback)):
-                field.introspectable = False
-        return True
-
-    def _get_validate_parameter_name(self, parent, param_name, origin):
-        try:
-            param = parent.get_parameter(param_name)
-        except ValueError, e:
-            param = None
-        if param is None:
-            if isinstance(origin, ast.Parameter):
-                origin_name = 'parameter %s' % (origin.argname, )
-            else:
-                origin_name = 'return value'
-            message.log_node(
-                message.FATAL, parent,
-                "can't find parameter %s referenced by %s of %r"
-                % (param_name, origin_name, parent.name))
-
-        return param.argname
-
-    def _apply_annotation_rename_to(self, node, chain, block):
-        if not block:
-            return
-        rename_to = block.get(TAG_RENAME_TO)
-        if not rename_to:
-            return
-        rename_to = rename_to.value
-        target = self._namespace.get_by_symbol(rename_to)
-        if not target:
-            message.warn_node(node,
-                "Can't find symbol %r referenced by Rename annotation" % (
-                rename_to, ))
-        elif target.shadowed_by:
-            message.warn_node(node,
-                "Function %r already shadowed by %r, can't overwrite with %r" % (
-                target.symbol,
-                target.shadowed_by,
-                rename_to))
-        elif target.shadows:
-            message.warn_node(node,
-                "Function %r already shadows %r, can't multiply shadow with %r" % (
-                target.symbol,
-                target.shadows,
-                rename_to))
-        else:
-            target.shadowed_by = node.name
-            node.shadows = target.name
-
-    def _apply_annotations_function(self, node, chain):
-        block = self._blocks.get(node.symbol)
-        self._apply_annotations_callable(node, chain, block)
-
-    def _pass_read_annotations_early(self, node, chain):
-        if isinstance(node, ast.Record):
-            if node.ctype is not None:
-                block = self._blocks.get(node.ctype)
-            else:
-                block = self._blocks.get(node.c_name)
-            self._apply_annotations_annotated(node, block)
-        return True
-
-    def _pass_callable_defaults(self, node, chain):
-        if isinstance(node, (ast.Callable, ast.Signal)):
-            for param in node.parameters:
-                if param.transfer is None:
-                    param.transfer = self._get_transfer_default(node, param)
-            if node.retval.transfer is None:
-                node.retval.transfer = self._get_transfer_default(node, node.retval)
-        return True
-
-    def _get_annotation_name(self, node):
-        if isinstance(node, (ast.Class, ast.Interface, ast.Record,
-                             ast.Union, ast.Enum, ast.Bitfield,
-                             ast.Callback, ast.Alias)):
-            if node.ctype is not None:
-                return node.ctype
-            elif isinstance(node, ast.Registered) and node.gtype_name is not None:
-                return node.gtype_name
-            return node.c_name
-        raise AssertionError("Unhandled node %r" % (node, ))
-
-    def _get_block(self, node):
-        return self._blocks.get(self._get_annotation_name(node))
-
-    def _pass_read_annotations(self, node, chain):
-        if not node.namespace:
-            return False
-        if isinstance(node, ast.Alias):
-            self._apply_annotations_alias(node, chain)
-        if isinstance(node, ast.Function):
-            self._apply_annotations_function(node, chain)
-        if isinstance(node, ast.Callback):
-            self._apply_annotations_callable(node, chain, block = self._get_block(node))
-        if isinstance(node, (ast.Class, ast.Interface, ast.Union, ast.Enum,
-                             ast.Bitfield, ast.Callback)):
-            self._apply_annotations_annotated(node, self._get_block(node))
-        if isinstance(node, (ast.Class, ast.Interface, ast.Record, ast.Union)):
-            block = self._get_block(node)
-            for field in node.fields:
-                self._apply_annotations_field(node, block, field)
-        if isinstance(node, (ast.Class, ast.Interface)):
-            for prop in node.properties:
-                self._apply_annotations_property(node, prop)
-            for sig in node.signals:
-                self._apply_annotations_signal(node, sig)
-        if isinstance(node, ast.Class):
-            block = self._get_block(node)
-            if block:
-                tag = block.get(TAG_UNREF_FUNC)
-                node.unref_func = tag.value if tag else None
-                tag = block.get(TAG_REF_FUNC)
-                node.ref_func = tag.value if tag else None
-                tag = block.get(TAG_SET_VALUE_FUNC)
-                node.set_value_func = tag.value if tag else None
-                tag = block.get(TAG_GET_VALUE_FUNC)
-                node.get_value_func = tag.value if tag else None
-        return True
-
-    def _adjust_container_type(self, parent, node, options):
-        has_element_type = OPT_ELEMENT_TYPE in options
-        has_array = OPT_ARRAY in options
-
-        if has_array:
-            self._apply_annotations_array(parent, node, options)
-        elif has_element_type:
-            self._apply_annotations_element_type(parent, node, options)
-
-    def _resolve(self, type_str, type_node=None, node=None, parent=None):
-        def grab_one(type_str, resolver, top_combiner, combiner):
-            """Return a complete type, and the trailing string part after it.
-            Use resolver() on each identifier, and combiner() on the parts of
-            each complete type. (top_combiner is used on the top-most type.)"""
-            bits = re.split(r'([,<>])', type_str, 1)
-            first, sep, rest = [bits[0], '', ''] if (len(bits)==1) else bits
-            args = [resolver(first)]
-            if sep == '<':
-                while sep != '>':
-                    next, rest = grab_one(rest, resolver, combiner, combiner)
-                    args.append(next)
-                    sep, rest = rest[0], rest[1:]
-            else:
-                rest = sep + rest
-            return top_combiner(*args), rest
-        def resolver(ident):
-            res = self._transformer.create_type_from_user_string(ident)
-            return res
-        def combiner(base, *rest):
-            if not rest:
-                return base
-            if isinstance(base, ast.List) and len(rest) == 1:
-                return ast.List(base.name, *rest)
-            if isinstance(base, ast.Map) and len(rest) == 2:
-                return ast.Map(*rest)
-            message.warn(
-                "Too many parameters in type specification %r" % (type_str, ))
-            return base
-        def top_combiner(base, *rest):
-            if type_node is not None and isinstance(type_node, ast.Type):
-                base.is_const = type_node.is_const
-            return combiner(base, *rest)
-
-        result, rest = grab_one(type_str, resolver, top_combiner, combiner)
-        if rest:
-            message.warn("Trailing components in type specification %r" % (
-                type_str, ))
-
-        if not result.resolved:
-            position = None
-            if parent is not None and isinstance(parent, ast.Function):
-                text = parent.symbol
-                position = self._get_position(parent, node)
-            else:
-                text = type_str
-            message.warn_node(parent, "%s: Unknown type: %r" %
-                              (text, result.ctype), positions=position)
-        return result
-
-    def _get_position(self, func, param):
-        block = self._blocks.get(func.symbol)
-        if block:
-            if isinstance(param, ast.Parameter):
-                tag = block.tags.get(param.argname)
-            elif isinstance(param, ast.Return):
-                tag = block.tags.get(TAG_RETURNS)
-            else:
-                tag = None
-
-            if tag.position:
-                return tag.position
-
-        return block.position
-
-    def _apply_annotations_array(self, parent, node, options):
-        array_opt = options.get(OPT_ARRAY)
-        if array_opt:
-            array_values = array_opt.all()
-        else:
-            array_values = {}
-
-        element_type = options.get(OPT_ELEMENT_TYPE)
-        if element_type is not None:
-            element_type_node = self._resolve(element_type.one(),
-                                              node.type, node, parent)
-        elif isinstance(node.type, ast.Array):
-            element_type_node = node.type.element_type
-        else:
-            # We're assuming here that Foo* with an (array) annotation
-            # and no (element-type) means array of Foo
-            element_type_node = node.type.clone()
-            # Explicitly erase ctype since it's no longer valid
-            element_type_node.ctype = None
-
-        if isinstance(node.type, ast.Array):
-            array_type = node.type.array_type
-        else:
-            array_type = None
-        container_type = ast.Array(array_type, element_type_node,
-                               ctype=node.type.ctype,
-                               is_const=node.type.is_const)
-        if OPT_ARRAY_ZERO_TERMINATED in array_values:
-            container_type.zeroterminated = array_values.get(
-                OPT_ARRAY_ZERO_TERMINATED) == '1'
-        length = array_values.get(OPT_ARRAY_LENGTH)
-        if length is not None:
-            paramname = self._get_validate_parameter_name(parent, length, node)
-            if paramname:
-                param = parent.get_parameter(paramname)
-                param.direction = node.direction
-                if param.direction == ast.PARAM_DIRECTION_OUT:
-                    param.transfer = ast.PARAM_TRANSFER_FULL
-                container_type.length_param_name = param.argname
-        fixed = array_values.get(OPT_ARRAY_FIXED_SIZE)
-        if fixed:
-            try:
-                container_type.size = int(fixed)
-            except ValueError:
-                # Already warned in annotationparser.py
-                return
-        node.type = container_type
-
-    def _apply_annotations_element_type(self, parent, node, options):
-        element_type_opt = options.get(OPT_ELEMENT_TYPE)
-        if element_type_opt is None:
-            message.warn(
-                'element-type annotation takes at least one option, '
-                'none given',
-                options.position)
-            return
-
-        if isinstance(node.type, ast.List):
-            if element_type_opt.length() != 1:
-                message.warn(
-                    'element-type annotation for a list must have exactly '
-                    'one option, not %d options' % (element_type_opt.length(), ),
-                    options.position)
-                return
-            node.type.element_type = self._resolve(element_type_opt.one(),
-                                                   node.type, node, parent)
-        elif isinstance(node.type, ast.Map):
-            if element_type_opt.length() != 2:
-                message.warn(
-                    'element-type annotation for a hash table must have exactly '
-                    'two options, not %d option(s)' % (element_type_opt.length(), ),
-                    options.position)
-                return
-            element_type = element_type_opt.flat()
-            node.type.key_type = self._resolve(element_type[0],
-                                               node.type, node, parent)
-            node.type.value_type = self._resolve(element_type[1],
-                                                 node.type, node, parent)
-        elif isinstance(node.type, ast.Array):
-            if element_type_opt.length() != 1:
-                message.warn(
-                    'element-type annotation for an array must have exactly '
-                    'one option, not %d options' % (element_type_opt.length(), ),
-                    options.position)
-                return
-            node.type.element_type = self._resolve(element_type_opt.one(),
-                                                   node.type, node, parent)
-        else:
-            message.warn_node(parent,
-                "Unknown container %r for element-type annotation" % (node.type, ))
-
-    def _get_transfer_default_param(self, parent, node):
-        if node.direction in [ast.PARAM_DIRECTION_INOUT,
-                              ast.PARAM_DIRECTION_OUT]:
-            if node.caller_allocates:
-                return ast.PARAM_TRANSFER_NONE
-            return ast.PARAM_TRANSFER_FULL
-        return ast.PARAM_TRANSFER_NONE
-
-    def _get_transfer_default_returntype_basic(self, typeval):
-        if (typeval.is_equiv(ast.BASIC_GIR_TYPES)
-            or typeval.is_const
-            or typeval.is_equiv(ast.TYPE_NONE)):
-            return ast.PARAM_TRANSFER_NONE
-        elif typeval.is_equiv(ast.TYPE_STRING):
-            # Non-const strings default to FULL
-            return ast.PARAM_TRANSFER_FULL
-        elif typeval.target_fundamental:
-            # This looks like just GType right now
-            return None
-        return None
-
-    def _is_gi_subclass(self, typeval, supercls_type):
-        cls = self._transformer.lookup_typenode(typeval)
-        assert cls, str(typeval)
-        supercls = self._transformer.lookup_typenode(supercls_type)
-        assert supercls
-        if cls is supercls:
-            return True
-        if cls.parent and cls.parent.target_giname != 'GObject.Object':
-            return self._is_gi_subclass(cls.parent, supercls_type)
-        return False
-
-    def _get_transfer_default_return(self, parent, node):
-        typeval = node.type
-        basic = self._get_transfer_default_returntype_basic(typeval)
-        if basic:
-            return basic
-        if not typeval.target_giname:
-            return None
-        target = self._transformer.lookup_typenode(typeval)
-        if isinstance(target, ast.Alias):
-            return self._get_transfer_default_returntype_basic(target.target)
-        elif (isinstance(target, ast.Boxed)
-              or (isinstance(target, (ast.Record, ast.Union))
-                  and (target.gtype_name is not None or target.foreign))):
-            return ast.PARAM_TRANSFER_FULL
-        elif isinstance(target, (ast.Enum, ast.Bitfield)):
-            return ast.PARAM_TRANSFER_NONE
-        # Handle constructors specially here
-        elif isinstance(parent, ast.Function) and parent.is_constructor:
-            if isinstance(target, ast.Class):
-                initially_unowned_type = ast.Type(target_giname='GObject.InitiallyUnowned')
-                initially_unowned = self._transformer.lookup_typenode(initially_unowned_type)
-                if initially_unowned and self._is_gi_subclass(typeval, initially_unowned_type):
-                    return ast.PARAM_TRANSFER_NONE
-                else:
-                    return ast.PARAM_TRANSFER_FULL
-            elif isinstance(target, (ast.Record, ast.Union)):
-                return ast.PARAM_TRANSFER_FULL
-            else:
-                raise AssertionError("Invalid constructor")
-        elif isinstance(target, (ast.Class, ast.Record, ast.Union)):
-            # Explicitly no default for these
-            return None
-        else:
-            return None
-
-    def _get_transfer_default(self, parent, node):
-        if node.type.is_equiv(ast.TYPE_NONE) or isinstance(node.type, ast.Varargs):
-            return ast.PARAM_TRANSFER_NONE
-        elif isinstance(node, ast.Parameter):
-            return self._get_transfer_default_param(parent, node)
-        elif isinstance(node, ast.Return):
-            return self._get_transfer_default_return(parent, node)
-        elif isinstance(node, ast.Field):
-            return ast.PARAM_TRANSFER_NONE
-        elif isinstance(node, ast.Property):
-            return ast.PARAM_TRANSFER_NONE
-        else:
-            raise AssertionError(node)
-
-    def _apply_annotations_param_ret_common(self, parent, node, tag):
-        options = getattr(tag, 'options', {})
-
-        param_type = options.get(OPT_TYPE)
-        if param_type:
-            node.type = self._resolve(param_type.one(),
-                                      node.type, node, parent)
-
-        caller_allocates = False
-        annotated_direction = None
-        if (OPT_INOUT in options or
-            OPT_INOUT_ALT in options):
-            annotated_direction = ast.PARAM_DIRECTION_INOUT
-        elif OPT_OUT in options:
-            subtype = options[OPT_OUT]
-            if subtype is not None:
-                subtype = subtype.one()
-            annotated_direction = ast.PARAM_DIRECTION_OUT
-            if subtype in (None, ''):
-                if node.type.target_giname and node.type.ctype:
-                    target = self._transformer.lookup_giname(node.type.target_giname)
-                    has_double_indirection = '**' in node.type.ctype
-                    is_structure_or_union = isinstance(target, (ast.Record, ast.Union))
-                    caller_allocates = (not has_double_indirection and is_structure_or_union)
-                else:
-                    caller_allocates = False
-            elif subtype == OPT_OUT_CALLER_ALLOCATES:
-                caller_allocates = True
-            elif subtype == OPT_OUT_CALLEE_ALLOCATES:
-                caller_allocates = False
-        elif OPT_IN in options:
-            annotated_direction = ast.PARAM_DIRECTION_IN
-
-        if (annotated_direction is not None) and (annotated_direction != node.direction):
-            node.direction = annotated_direction
-            node.caller_allocates = caller_allocates
-            # Also reset the transfer default if we're toggling direction
-            node.transfer = self._get_transfer_default(parent, node)
-
-        transfer_tag = options.get(OPT_TRANSFER)
-        if transfer_tag and transfer_tag.length() == 1:
-            node.transfer = transfer_tag.one()
-
-        self._adjust_container_type(parent, node, options)
-
-        if (OPT_ALLOW_NONE in options or
-            node.type.target_giname == 'Gio.Cancellable'):
-            node.allow_none = True
-
-        if tag is not None and tag.comment is not None:
-            node.doc = tag.comment
-
-        if options:
-            for attribute in options.getall(OPT_ATTRIBUTE):
-                node.attributes.append(attribute.flat())
-
-    def _apply_annotations_annotated(self, node, block):
-        if block is None:
-            return
-
-        node.doc = block.comment
-
-        since_tag = block.get(TAG_SINCE)
-        if since_tag is not None:
-            node.version = since_tag.value
-
-        deprecated_tag = block.get(TAG_DEPRECATED)
-        if deprecated_tag is not None:
-            value = deprecated_tag.value
-            if ': ' in value:
-                version, desc = value.split(': ')
-            else:
-                desc = value
-                version = None
-            node.deprecated = desc
-            if version is not None:
-                node.deprecated_version = version
-
-        annos_tag = block.get(TAG_ATTRIBUTES)
-        if annos_tag is not None:
-            options = AnnotationParser.parse_options(annos_tag, annos_tag.value)
-            for key, value in options.iteritems():
-                if value:
-                    node.attributes.append((key, value.one()))
-
-        if OPT_SKIP in block.options:
-            node.skip = True
-
-        if OPT_FOREIGN in block.options:
-            node.foreign = True
-
-    def _apply_annotations_alias(self, node, chain):
-        block = self._get_block(node)
-        self._apply_annotations_annotated(node, block)
-
-    def _apply_annotations_param(self, parent, param, tag):
-        if tag:
-            options = tag.options
-        else:
-            options = {}
-        if isinstance(parent, (ast.Function, ast.VFunction)):
-            scope = options.get(OPT_SCOPE)
-            if scope and scope.length() == 1:
-                param.scope = scope.one()
-                param.transfer = ast.PARAM_TRANSFER_NONE
-
-            destroy = options.get(OPT_DESTROY)
-            if destroy:
-                param.destroy_name = self._get_validate_parameter_name(parent,
-                                                                       destroy.one(),
-                                                                       param)
-                if param.destroy_name is not None:
-                    param.scope = ast.PARAM_SCOPE_NOTIFIED
-                    destroy_param = parent.get_parameter(param.destroy_name)
-                    # This is technically bogus; we're setting the scope on the destroy
-                    # itself.  But this helps avoid tripping a warning from finaltransformer,
-                    # since we don't have a way right now to flag this callback a destroy.
-                    destroy_param.scope = ast.PARAM_SCOPE_NOTIFIED
-            closure = options.get(OPT_CLOSURE)
-            if closure and closure.length() == 1:
-                param.closure_name = self._get_validate_parameter_name(parent,
-                                                                       closure.one(),
-                                                                       param)
-        elif isinstance(parent, ast.Callback):
-            if OPT_CLOSURE in options:
-                # For callbacks, (closure) appears without an
-                # argument, and tags a parameter that is a closure. We
-                # represent it (weirdly) in the gir and typelib by
-                # setting param.closure_name to itself.
-                param.closure_name = param.argname
-
-        self._apply_annotations_param_ret_common(parent, param, tag)
-
-    def _apply_annotations_return(self, parent, return_, block):
-        if block:
-            tag = block.get(TAG_RETURNS)
-        else:
-            tag = None
-        self._apply_annotations_param_ret_common(parent, return_, tag)
-
-    def _apply_annotations_params(self, parent, params, block):
-        allparams = []
-        if parent.instance_parameter:
-            allparams.append(parent.instance_parameter.argname)
-        for param in params:
-            if block:
-                tag = block.get(param.argname)
-            else:
-                tag = None
-            self._apply_annotations_param(parent, param, tag)
-            allparams.append(param.argname)
-
-        if not block:
-            return
-        docparams = block.params[:]
-        for doc_name in docparams:
-            if doc_name in allparams:
-                continue
-            # Skip varargs, see #629759
-            if doc_name.lower() in ['...', 'varargs', TAG_RETURNS]:
-                continue
-            if len(allparams) == 0:
-                text = ''
-            elif len(allparams) == 1:
-                text = ', should be %r' % (allparams[0], )
-            else:
-                text = ', should be one of %s' % (
-                ', '.join(repr(p) for p in allparams), )
-
-            tag = block.get(doc_name)
-            message.warn(
-                '%s: unknown parameter %r in documentation comment%s' % (
-                block.name, doc_name, text),
-                tag.position)
-
-    def _apply_annotations_callable(self, node, chain, block):
-        self._apply_annotations_annotated(node, block)
-        self._apply_annotations_params(node, node.parameters, block)
-        self._apply_annotations_return(node, node.retval, block)
-
-    def _check_arg_annotations(self, parent, params, block):
-        if block is None:
-            return
-        for tag in block.tags.keys():
-            if tag == TAG_RETURNS:
-                continue
-            for param in params:
-                if param.argname == tag:
-                    break
-            else:
-                message.warn(
-                    "Annotation for '%s' refers to unknown argument '%s'"
-                    % (parent.name, tag))
-
-    def _apply_annotations_field(self, parent, block, field):
-        if not block:
-            return
-        tag = block.get(field.name)
-        if not tag:
-            return
-        t = tag.options.get(OPT_TYPE)
-        if not t:
-            return
-        field.type = self._transformer.create_type_from_user_string(t.one())
-
-    def _apply_annotations_property(self, parent, prop):
-        prefix = self._get_annotation_name(parent)
-        block = self._blocks.get('%s:%s' % (prefix, prop.name))
-        self._apply_annotations_annotated(prop, block)
-        if not block:
-            return
-        transfer_tag = block.get(OPT_TRANSFER)
-        if transfer_tag is not None:
-            prop.transfer = transfer_tag.value
-        else:
-            prop.transfer = self._get_transfer_default(parent, prop)
-        type_tag = block.get(TAG_TYPE)
-        if type_tag:
-            prop.type = self._resolve(type_tag.value, prop.type, prop, parent)
-
-    def _apply_annotations_signal(self, parent, signal):
-        prefix = self._get_annotation_name(parent)
-        block = self._blocks.get('%s::%s' % (prefix, signal.name))
-        self._apply_annotations_annotated(signal, block)
-        # We're only attempting to name the signal parameters if
-        # the number of parameter tags (@foo) is the same or greater
-        # than the number of signal parameters
-        if block and len(block.tags) > len(signal.parameters):
-            names = block.tags.items()
-            # Resolve real parameter names early, so that in later
-            # phase we can refer to them while resolving annotations.
-            for i, param in enumerate(signal.parameters):
-                param.argname, tag = names[i+1]
-        else:
-            names = []
-        for i, param in enumerate(signal.parameters):
-            if names:
-                name, tag = names[i+1]
-                options = getattr(tag, 'options', {})
-                param_type = options.get(OPT_TYPE)
-                if param_type:
-                    param.type = self._resolve(param_type.one(), param.type,
-                                               param, parent)
-            else:
-                tag = None
-            self._apply_annotations_param(signal, param, tag)
-        self._apply_annotations_return(signal, signal.retval, block)
-
-    def _pass_read_annotations2(self, node, chain):
-        if isinstance(node, ast.Function):
-            self._apply_annotations2_function(node, chain)
-        return True
-
-    def _apply_annotations2_function(self, node, chain):
-        block = self._blocks.get(node.symbol)
-
-        self._apply_annotation_rename_to(node, chain, block)
-
-        # Handle virtual invokers
-        parent = chain[-1] if chain else None
-        if not (block and parent):
-            return
-        virtual = block.get(TAG_VFUNC)
-        if not virtual:
-            return
-        invoker_name = virtual.value
-        matched = False
-        for vfunc in parent.virtual_methods:
-            if vfunc.name == invoker_name:
-                matched = True
-                vfunc.invoker = node.name
-                # Also merge in annotations
-                self._apply_annotations_callable(vfunc, [parent], block)
-                break
-        if not matched:
-            message.warn_node(node,
-                "Virtual slot %r not found for %r annotation" % (invoker_name, TAG_VFUNC))
-
-    def _resolve_and_filter_type_list(self, typelist):
-        """Given a list of Type instances, return a new list of types with
-the ones that failed to resolve removed."""
-        # Create a copy we'll modify
-        new_typelist = list(typelist)
-        for typeval in typelist:
-            resolved = self._transformer.resolve_type(typeval)
-            if not resolved:
-                new_typelist.remove(typeval)
-        return new_typelist
-
-    def _pass_type_resolution(self, node, chain):
-        if isinstance(node, ast.Alias):
-            self._transformer.resolve_type(node.target)
-        if isinstance(node, ast.Callable):
-            for parameter in node.parameters:
-                self._transformer.resolve_type(parameter.type)
-            self._transformer.resolve_type(node.retval.type)
-        if isinstance(node, ast.Constant):
-            self._transformer.resolve_type(node.value_type)
-        if isinstance(node, (ast.Class, ast.Interface, ast.Record, ast.Union)):
-            for field in node.fields:
-                if field.anonymous_node:
-                    pass
-                else:
-                    self._transformer.resolve_type(field.type)
-        if isinstance(node, (ast.Class, ast.Interface)):
-            resolved_parent = None
-            for parent in node.parent_chain:
-                try:
-                    self._transformer.resolve_type(parent)
-                except ValueError, e:
-                    continue
-                target = self._transformer.lookup_typenode(parent)
-                if target:
-                    node.parent = parent
-                    break
-            else:
-                if isinstance(node, ast.Interface) or not node.fundamental:
-                    node.parent = ast.Type(target_giname='GObject.Object')
-                else:
-                    node.parent = None
-            for prop in node.properties:
-                self._transformer.resolve_type(prop.type)
-            for sig in node.signals:
-                for param in sig.parameters:
-                    self._transformer.resolve_type(param.type)
-        if isinstance(node, ast.Class):
-            node.interfaces = self._resolve_and_filter_type_list(node.interfaces)
-        if isinstance(node, ast.Interface):
-            node.prerequisites = self._resolve_and_filter_type_list(node.prerequisites)
-        return True
-
-    def _pair_quarks_with_enums(self):
-        # self._uscore_type_names is an authoritative mapping of types
-        # to underscored versions, since it is based on get_type() methods;
-        # but only covers enums that are registered as GObject enums.
-        # Create a fallback mapping based on all known enums in this module.
-        uscore_enums = {}
-        for enum in self._namespace.itervalues():
-            if not isinstance(enum, ast.Enum):
-                continue
-            type_name = enum.ctype
-            uscored = to_underscores(type_name).lower()
-
-            uscore_enums[uscored] = enum
-
-            try:
-                no_uscore_prefixed = self._transformer.strip_identifier(type_name)
-            except TransformerException, e:
-                message.warn(e)
-                no_uscore_prefixed = None
-
-            if no_uscore_prefixed not in uscore_enums:
-                uscore_enums[no_uscore_prefixed] = enum
-
-        for node in self._namespace.itervalues():
-            if not isinstance(node, ast.Function):
-                continue
-            if node.retval.type.target_giname != 'GLib.Quark':
-                continue
-            short = node.symbol[:-len('_quark')]
-            if short == "g_io_error":
-                # Special case; GIOError was already taken forcing GIOErrorEnum
-                assert self._namespace.name == 'Gio'
-                enum = self._namespace.get('IOErrorEnum')
-            else:
-                enum = self._uscore_type_names.get(short)
-                if enum is None:
-                    enum = uscore_enums.get(short)
-            if enum is not None:
-                enum.error_quark = node.symbol
-            else:
-                message.warn_node(node,
-                    """%s: Couldn't find corresponding enumeration""" % (node.symbol, ))
-
-    def _split_uscored_by_type(self, uscored):
-        """'uscored' should be an un-prefixed uscore string.  This
-function searches through the namespace for the longest type which
-prefixes uscored, and returns (type, suffix).  Example, assuming
-namespace Gtk, type is TextBuffer:
-
-_split_uscored_by_type(text_buffer_try_new) -> (ast.Class(TextBuffer), 'try_new')"""
-        node = None
-        count = 0
-        prev_split_count = -1
-        while True:
-            components = uscored.rsplit('_', count)
-            if len(components) == prev_split_count:
-                return None
-            prev_split_count = len(components)
-            type_string = components[0]
-            node = self._uscore_type_names.get(type_string)
-            if node:
-                return (node, '_'.join(components[1:]))
-            count += 1
-
-    def _pair_function(self, func):
-        """Check to see whether a toplevel function should be a
-method or constructor of some type."""
-        if func.symbol.endswith('_get_type') or func.symbol.startswith('_'):
-            return
-        (ns, subsymbol) = self._transformer.split_csymbol(func.symbol)
-        assert ns == self._namespace
-        if self._pair_constructor(func, subsymbol):
-            return
-        elif self._pair_method(func, subsymbol):
-            return
-        elif self._pair_static_method(func, subsymbol):
-            return
-
-    def _uscored_identifier_for_type(self, typeval):
-        """Given a Type(target_giname='Foo.BarBaz'), return 'bar_baz'."""
-        name = typeval.get_giname()
-        return to_underscores_noprefix(name).lower()
-
-    def _pair_method(self, func, subsymbol):
-        if not func.parameters:
-            return False
-        first = func.parameters[0]
-        target = self._transformer.lookup_typenode(first.type)
-        if not isinstance(target, (ast.Class, ast.Interface,
-                                   ast.Record, ast.Union,
-                                   ast.Boxed)):
-            return False
-        if target.namespace != self._namespace:
-            return False
-
-        # A quick hack here...in the future we should catch C signature/GI signature
-        # mismatches in a general way in finaltransformer
-        if first.type.ctype is not None and first.type.ctype.count('*') != 1:
-            return False
-
-        # Here we check both the c_symbol_prefix and (if that fails),
-        # attempt to do a default uscoring of the type.  The reason we
-        # look at a default underscore transformation is for
-        # gdk_window_object_get_type(), which says to us that the
-        # prefix is "gdk_window_object", when really it's just
-        # "gdk_window".  Possibly need an annotation to override this.
-        prefix_matches = False
-        uscored_prefix = None
-        if hasattr(target, 'c_symbol_prefix') and target.c_symbol_prefix is not None:
-            prefix_matches = subsymbol.startswith(target.c_symbol_prefix)
-            if prefix_matches:
-                uscored_prefix = target.c_symbol_prefix
-        if not prefix_matches:
-            uscored_prefix = self._uscored_identifier_for_type(first.type)
-            if not subsymbol.startswith(uscored_prefix):
-                return False
-        func.instance_parameter = func.parameters.pop(0)
-        subsym_idx = func.symbol.find(subsymbol)
-        self._namespace.float(func)
-        func.name = func.symbol[(subsym_idx + len(uscored_prefix) + 1):]
-        target.methods.append(func)
-        func.is_method = True
-        return True
-
-    def _pair_static_method(self, func, subsymbol):
-        split = self._split_uscored_by_type(subsymbol)
-        if split is None:
-            return False
-        (node, funcname) = split
-
-        # We actually should treat static methods on a wider class of objects:
-        #  ast.Class, ast.Interface, ast.Record, ast.Union, ast.Boxed
-        # But we stick to ast.Class for now for compatibility with existing code.
-        #
-        # See https://bugzilla.gnome.org/show_bug.cgi?id=572408
-        #
-        if not isinstance(node, ast.Class):
-            return False
-
-        self._namespace.float(func)
-        func.name = funcname
-        node.static_methods.append(func)
-
-    def _pair_constructor(self, func, subsymbol):
-        if not (func.symbol.find('_new_') >= 0 or func.symbol.endswith('_new')):
-            return False
-        target = self._transformer.lookup_typenode(func.retval.type)
-        if not (isinstance(target, ast.Class)
-                or (isinstance(target, (ast.Record, ast.Union, ast.Boxed))
-                    and (target.get_type is not None or target.foreign))):
-            return False
-
-        split = self._split_uscored_by_type(subsymbol)
-        if split is None:
-            # TODO - need a e.g. (method) annotation
-            message.warn_node(func,
-                "Can't find matching type for constructor; symbol=%r" % (func.symbol, ))
-            return False
-        (origin_node, funcname) = split
-        # Some sanity checks; only objects and boxeds can have ctors
-        if not (isinstance(origin_node, ast.Class)
-                or (isinstance(origin_node, (ast.Record, ast.Union, ast.Boxed))
-                    and (origin_node.get_type is not None or origin_node.foreign))):
-            return False
-        # Verify the namespace - don't want to append to foreign namespaces!
-        if origin_node.namespace != self._namespace:
-            return False
-        # If it takes the object as a first arg, it's not a constructor
-        if len(func.parameters) > 0:
-            first_arg = self._transformer.lookup_typenode(func.parameters[0].type)
-            if (first_arg is not None) and first_arg.gi_name == origin_node.gi_name:
-                return False
-
-        if isinstance(target, ast.Class):
-            parent = origin_node
-            while parent and (not parent.gi_name == 'GObject.Object'):
-                if parent == target:
-                    break
-                if parent.parent:
-                    parent = self._transformer.lookup_typenode(parent.parent)
-                else:
-                    parent = None
-                if parent is None or parent.gi_name == 'GObject.Object':
-                    message.warn_node(func,
-                        "Return value is not superclass for constructor; "
-                        "symbol=%r constructed=%r return=%r" % (
-                        func.symbol,
-                        str(origin_node.create_type()),
-                        str(func.retval.type)))
-                    return False
-        else:
-            if origin_node != target:
-                message.warn_node(func,
-                    "Constructor return type mismatch symbol=%r "
-                    "constructed=%r return=%r" % (
-                    func.symbol,
-                    str(origin_node.create_type()),
-                    str(func.retval.type)))
-                return False
-        self._namespace.float(func)
-        func.name = funcname
-        func.is_constructor = True
-        origin_node.constructors.append(func)
-        # Constructors have default return semantics
-        if not func.retval.transfer:
-            func.retval.transfer = self._get_transfer_default_return(func, func.retval)
-        return True
-
-    def _pair_class_virtuals(self, node):
-        """Look for virtual methods from the class structure."""
-        if not node.glib_type_struct:
-            message.warn_node(node,
-                "Failed to find class structure for %r" % (node.name, ))
-            return
-
-        node_type = node.create_type()
-        class_struct = self._transformer.lookup_typenode(node.glib_type_struct)
-
-        # Object class fields are assumed to be read-only
-        # (see also _introspect_object and transformer.py)
-        for field in class_struct.fields:
-            if isinstance(field, ast.Field):
-                field.writable = False
-
-        for field in class_struct.fields:
-            if not isinstance(field.anonymous_node, ast.Callback):
-                continue
-            callback = field.anonymous_node
-            # Check the first parameter is the object
-            if len(callback.parameters) == 0:
-                continue
-            firstparam_type = callback.parameters[0].type
-            if firstparam_type != node_type:
-                continue
-            vfunc = ast.VFunction.from_callback(callback)
-            vfunc.instance_parameter = callback.parameters[0]
-            vfunc.inherit_file_positions(callback)
-            node.virtual_methods.append(vfunc)
-
-        # Take the set of virtual methods we found, and try
-        # to pair up with any matching methods using the
-        # name+signature.
-        for vfunc in node.virtual_methods:
-            for method in node.methods:
-                if method.name != vfunc.name:
-                    continue
-                if method.retval.type != vfunc.retval.type:
-                    continue
-                if len(method.parameters) != len(vfunc.parameters):
-                    continue
-                for i in xrange(len(method.parameters)):
-                    m_type = method.parameters[i].type
-                    v_type = vfunc.parameters[i].type
-                    if m_type != v_type:
-                        continue
-                vfunc.invoker = method.name
-                # Apply any annotations we have from the invoker to
-                # the vfunc
-                block = self._blocks.get(method.symbol)
-                self._apply_annotations_callable(vfunc, [], block)
-                break
-
-    def _pass3(self, node, chain):
-        """Pass 3 is after we've loaded GType data and performed type
-        closure."""
-        if isinstance(node, ast.Callable):
-            self._pass3_callable_callbacks(node)
-            self._pass3_callable_throws(node)
-        return True
-
-    def _pass3_callable_callbacks(self, node):
-        """Check to see if we have anything that looks like a
-        callback+user_data+GDestroyNotify set."""
-
-        params = node.parameters
-
-        # First, do defaults for well-known callback types
-        for i, param in enumerate(params):
-            argnode = self._transformer.lookup_typenode(param.type)
-            if isinstance(argnode, ast.Callback):
-                if param.type.target_giname in ('Gio.AsyncReadyCallback',
-                                                'GLib.DestroyNotify'):
-                    param.scope = ast.PARAM_SCOPE_ASYNC
-                    param.transfer = ast.PARAM_TRANSFER_NONE
-
-        callback_param = None
-        for i, param in enumerate(params):
-            argnode = self._transformer.lookup_typenode(param.type)
-            is_destroynotify = False
-            if isinstance(argnode, ast.Callback):
-                if param.type.target_giname == 'GLib.DestroyNotify':
-                    is_destroynotify = True
-                else:
-                    callback_param = param
-                    continue
-            if callback_param is None:
-                continue
-            if is_destroynotify:
-                callback_param.destroy_name = param.argname
-                callback_param.scope = ast.PARAM_SCOPE_NOTIFIED
-                callback_param.transfer = ast.PARAM_TRANSFER_NONE
-            elif (param.type.is_equiv(ast.TYPE_ANY) and
-                  param.argname is not None and
-                  param.argname.endswith('data')):
-                callback_param.closure_name = param.argname
-
-    def _pass3_callable_throws(self, node):
-        """Check to see if we have anything that looks like a
-        callback+user_data+GDestroyNotify set."""
-        if not node.parameters:
-            return
-        last_param = node.parameters[-1]
-        # Checking type.name=='GLib.Error' generates false positives
-        # on methods that take a 'GError *'
-        if last_param.type.ctype == 'GError**':
-            node.parameters.pop()
-            node.throws = True

=== removed directory '.pc/0001-Preserve-the-c-type-of-array-elements.patch/tests'
=== removed directory '.pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner'
=== removed file '.pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Annotation-1.0-expected.gir'
--- .pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Annotation-1.0-expected.gir	2011-01-21 11:20:57 +0000
+++ .pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Annotation-1.0-expected.gir	1970-01-01 00:00:00 +0000
@@ -1,814 +0,0 @@
-<?xml version="1.0"?>
-<!-- This file was automatically generated from C sources - DO NOT EDIT!
-To affect the contents of this file, edit the original C definitions,
-and/or use gtk-doc annotations.  -->
-<repository version="1.2"
-            xmlns="http://www.gtk.org/introspection/core/1.0"
-            xmlns:c="http://www.gtk.org/introspection/c/1.0"
-            xmlns:glib="http://www.gtk.org/introspection/glib/1.0">
-  <include name="GLib" version="2.0"/>
-  <include name="GObject" version="2.0"/>
-  <include name="Utility" version="1.0"/>
-  <package name="gobject-2.0"/>
-  <c:include name="annotation.h"/>
-  <namespace name="Annotation"
-             version="1.0"
-             shared-library="libannotation.so"
-             c:identifier-prefixes="Annotation"
-             c:symbol-prefixes="annotation">
-    <bitfield name="Bitfield" c:type="AnnotationBitfield">
-      <member name="foo" value="1" c:identifier="ANN_FLAG_FOO"/>
-      <member name="bar" value="2" c:identifier="ANN_FLAG_BAR"/>
-    </bitfield>
-    <callback name="Callback" c:type="AnnotationCallback">
-      <doc xml:whitespace="preserve">This is a callback.</doc>
-      <return-value transfer-ownership="none">
-        <doc xml:whitespace="preserve">array of ints</doc>
-        <type name="gint" c:type="gint*"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <doc xml:whitespace="preserve">array of ints</doc>
-          <type name="gint" c:type="gint*"/>
-        </parameter>
-      </parameters>
-    </callback>
-    <callback name="ForeachFunc" c:type="AnnotationForeachFunc">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="object" transfer-ownership="none">
-          <type name="Object" c:type="AnnotationObject*"/>
-        </parameter>
-        <parameter name="item" transfer-ownership="none">
-          <type name="utf8" c:type="char*"/>
-        </parameter>
-        <parameter name="user_data" transfer-ownership="none" closure="2">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-      </parameters>
-    </callback>
-    <callback name="ListCallback" c:type="AnnotationListCallback">
-      <doc xml:whitespace="preserve">This is a callback taking a list.</doc>
-      <return-value transfer-ownership="container">
-        <doc xml:whitespace="preserve">list of strings</doc>
-        <type name="GLib.List" c:type="GList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <doc xml:whitespace="preserve">list of strings</doc>
-          <type name="GLib.List" c:type="GList*">
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </callback>
-    <callback name="NotifyFunc" c:type="AnnotationNotifyFunc">
-      <doc xml:whitespace="preserve">This is a callback with a 'closure' argument that is not named
-'user_data' and hence has to be annotated.</doc>
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="data" transfer-ownership="none" closure="0">
-          <doc xml:whitespace="preserve">The user data</doc>
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-      </parameters>
-    </callback>
-    <class name="Object"
-           c:symbol-prefix="object"
-           c:type="AnnotationObject"
-           parent="GObject.Object"
-           glib:type-name="AnnotationObject"
-           glib:get-type="annotation_object_get_type"
-           glib:type-struct="ObjectClass">
-      <attribute name="org.example.Test" value="cows"/>
-      <doc xml:whitespace="preserve">This is an object used to test annotations.</doc>
-      <method name="allow_none" c:identifier="annotation_object_allow_none">
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">%NULL always</doc>
-          <type name="GObject.Object" c:type="GObject*"/>
-        </return-value>
-        <parameters>
-          <parameter name="somearg" transfer-ownership="none" allow-none="1">
-            <type name="utf8" c:type="gchar*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="calleeowns" c:identifier="annotation_object_calleeowns">
-        <doc xml:whitespace="preserve">This is a test for out arguments; GObject defaults to transfer</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">an int</doc>
-          <type name="gint" c:type="gint"/>
-        </return-value>
-        <parameters>
-          <parameter name="toown"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <doc xml:whitespace="preserve">a #GObject</doc>
-            <type name="GObject.Object" c:type="GObject**"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="calleesowns" c:identifier="annotation_object_calleesowns">
-        <doc xml:whitespace="preserve">This is a test for out arguments, one transferred, other not</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">an int</doc>
-          <type name="gint" c:type="gint"/>
-        </return-value>
-        <parameters>
-          <parameter name="toown1"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <doc xml:whitespace="preserve">a #GObject</doc>
-            <type name="GObject.Object" c:type="GObject**"/>
-          </parameter>
-          <parameter name="toown2"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="none">
-            <doc xml:whitespace="preserve">a #GObject</doc>
-            <type name="GObject.Object" c:type="GObject**"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="compute_sum" c:identifier="annotation_object_compute_sum">
-        <doc xml:whitespace="preserve">Test taking a zero-terminated array</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="nums" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Sequence of numbers</doc>
-            <array c:type="int*">
-              <type name="gint"/>
-            </array>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="compute_sum_n"
-              c:identifier="annotation_object_compute_sum_n">
-        <doc xml:whitespace="preserve">Test taking an array with length parameter</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="nums" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Sequence of numbers that are zero-terminated</doc>
-            <array length="1" zero-terminated="0" c:type="int*">
-              <type name="gint"/>
-            </array>
-          </parameter>
-          <parameter name="n_nums" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Length of number array</doc>
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="compute_sum_nz"
-              c:identifier="annotation_object_compute_sum_nz">
-        <doc xml:whitespace="preserve">Test taking a zero-terminated array with length parameter</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="nums" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Sequence of numbers that are zero-terminated</doc>
-            <array length="1" c:type="int*">
-              <type name="gint"/>
-            </array>
-          </parameter>
-          <parameter name="n_nums" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Length of number array</doc>
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="create_object"
-              c:identifier="annotation_object_create_object">
-        <doc xml:whitespace="preserve">Test returning a caller-owned object</doc>
-        <return-value transfer-ownership="full">
-          <doc xml:whitespace="preserve">The object</doc>
-          <type name="GObject.Object" c:type="GObject*"/>
-        </return-value>
-      </method>
-      <method name="do_not_use"
-              c:identifier="annotation_object_do_not_use"
-              deprecated="Use annotation_object_create_object() instead."
-              deprecated-version="0.12">
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">%NULL always</doc>
-          <type name="GObject.Object" c:type="GObject*"/>
-        </return-value>
-      </method>
-      <method name="extra_annos" c:identifier="annotation_object_extra_annos">
-        <attribute name="org.foobar" value="testvalue"/>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-      <method name="foreach" c:identifier="annotation_object_foreach">
-        <doc xml:whitespace="preserve">Test taking a call-scoped callback</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="func"
-                     transfer-ownership="none"
-                     scope="call"
-                     closure="1">
-            <doc xml:whitespace="preserve">Callback to invoke</doc>
-            <type name="ForeachFunc" c:type="AnnotationForeachFunc"/>
-          </parameter>
-          <parameter name="user_data" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Callback user data</doc>
-            <type name="gpointer" c:type="gpointer"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="get_hash" c:identifier="annotation_object_get_hash">
-        <doc xml:whitespace="preserve">This is a test for returning a hash table mapping strings to
-objects.</doc>
-        <return-value transfer-ownership="full">
-          <doc xml:whitespace="preserve">hash table</doc>
-          <type name="GLib.HashTable" c:type="GHashTable*">
-            <type name="utf8"/>
-            <type name="GObject.Object"/>
-          </type>
-        </return-value>
-      </method>
-      <method name="get_objects" c:identifier="annotation_object_get_objects">
-        <doc xml:whitespace="preserve">This is a test for returning a list of objects.
-The list itself should be freed, but not the internal objects,
-intentionally similar example to gtk_container_get_children</doc>
-        <return-value transfer-ownership="container">
-          <doc xml:whitespace="preserve">list of objects</doc>
-          <type name="GLib.SList" c:type="GSList*">
-            <type name="Object"/>
-          </type>
-        </return-value>
-      </method>
-      <method name="get_strings" c:identifier="annotation_object_get_strings">
-        <doc xml:whitespace="preserve">This is a test for returning a list of strings, where
-each string needs to be freed.</doc>
-        <return-value transfer-ownership="full">
-          <doc xml:whitespace="preserve">list of strings</doc>
-          <type name="GLib.List" c:type="GList*">
-            <type name="utf8"/>
-          </type>
-        </return-value>
-      </method>
-      <method name="hidden_self" c:identifier="annotation_object_hidden_self">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-      <method name="in" c:identifier="annotation_object_in">
-        <doc xml:whitespace="preserve">This is a test for in arguments</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">an int</doc>
-          <type name="gint" c:type="gint"/>
-        </return-value>
-        <parameters>
-          <parameter name="inarg" transfer-ownership="none">
-            <doc xml:whitespace="preserve">This is an argument test</doc>
-            <type name="gint" c:type="int*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="inout" c:identifier="annotation_object_inout">
-        <doc xml:whitespace="preserve">This is a test for out arguments</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">an int</doc>
-          <type name="gint" c:type="gint"/>
-        </return-value>
-        <parameters>
-          <parameter name="inoutarg"
-                     direction="inout"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <doc xml:whitespace="preserve">This is an argument test</doc>
-            <type name="gint" c:type="int*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="inout2" c:identifier="annotation_object_inout2">
-        <doc xml:whitespace="preserve">This is a second test for out arguments</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">an int</doc>
-          <type name="gint" c:type="gint"/>
-        </return-value>
-        <parameters>
-          <parameter name="inoutarg"
-                     direction="inout"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <doc xml:whitespace="preserve">This is an argument test</doc>
-            <type name="gint" c:type="int*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="inout3" c:identifier="annotation_object_inout3">
-        <doc xml:whitespace="preserve">This is a 3th test for out arguments</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">an int</doc>
-          <type name="gint" c:type="gint"/>
-        </return-value>
-        <parameters>
-          <parameter name="inoutarg"
-                     direction="inout"
-                     caller-allocates="0"
-                     transfer-ownership="full"
-                     allow-none="1">
-            <doc xml:whitespace="preserve">This is an argument test</doc>
-            <type name="gint" c:type="int*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="method" c:identifier="annotation_object_method">
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">an int</doc>
-          <type name="gint" c:type="gint"/>
-        </return-value>
-      </method>
-      <method name="notrans" c:identifier="annotation_object_notrans">
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">An object, not referenced</doc>
-          <type name="GObject.Object" c:type="GObject*"/>
-        </return-value>
-      </method>
-      <method name="out" c:identifier="annotation_object_out">
-        <doc xml:whitespace="preserve">This is a test for out arguments</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">an int</doc>
-          <type name="gint" c:type="gint"/>
-        </return-value>
-        <parameters>
-          <parameter name="outarg"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <doc xml:whitespace="preserve">This is an argument test</doc>
-            <type name="gint" c:type="int*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="parse_args" c:identifier="annotation_object_parse_args">
-        <doc xml:whitespace="preserve">Test taking a zero-terminated array with length parameter</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="argc"
-                     direction="inout"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <doc xml:whitespace="preserve">Length of the argument vector</doc>
-            <type name="gint" c:type="int*"/>
-          </parameter>
-          <parameter name="argv"
-                     direction="inout"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <doc xml:whitespace="preserve">Argument vector</doc>
-            <array length="0" c:type="char***">
-              <type name="utf8"/>
-            </array>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="set_data" c:identifier="annotation_object_set_data">
-        <doc xml:whitespace="preserve">Test taking a guchar * with a length.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="data" transfer-ownership="none">
-            <doc xml:whitespace="preserve">The data</doc>
-            <array length="1" c:type="guchar*">
-              <type name="guint8"/>
-            </array>
-          </parameter>
-          <parameter name="length" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Length of the data</doc>
-            <type name="gulong" c:type="gsize"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="set_data2" c:identifier="annotation_object_set_data2">
-        <doc xml:whitespace="preserve">Test taking a gchar * with a length.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="data" transfer-ownership="none">
-            <doc xml:whitespace="preserve">The data</doc>
-            <array length="1" c:type="gchar*">
-              <type name="gint8"/>
-            </array>
-          </parameter>
-          <parameter name="length" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Length of the data</doc>
-            <type name="gulong" c:type="gsize"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="set_data3" c:identifier="annotation_object_set_data3">
-        <doc xml:whitespace="preserve">Test taking a gchar * with a length, overriding the array element
-type.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="data" transfer-ownership="none">
-            <doc xml:whitespace="preserve">The data</doc>
-            <array length="1" c:type="gpointer">
-              <type name="guint8"/>
-            </array>
-          </parameter>
-          <parameter name="length" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Length of the data</doc>
-            <type name="gulong" c:type="gsize"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="string_out" c:identifier="annotation_object_string_out">
-        <doc xml:whitespace="preserve">Test returning a string as an out parameter</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">some boolean</doc>
-          <type name="gboolean" c:type="gboolean"/>
-        </return-value>
-        <parameters>
-          <parameter name="str_out"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <doc xml:whitespace="preserve">string return value</doc>
-            <type name="utf8" c:type="char**"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="use_buffer" c:identifier="annotation_object_use_buffer">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="bytes" transfer-ownership="none">
-            <type name="guint8" c:type="guchar*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="watch"
-              c:identifier="annotation_object_watch"
-              shadowed-by="watch_full"
-              introspectable="0">
-        <doc xml:whitespace="preserve">This is here just for the sake of being overriden by its
-annotation_object_watch_full().</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="func" transfer-ownership="none" closure="1">
-            <doc xml:whitespace="preserve">The callback</doc>
-            <type name="ForeachFunc" c:type="AnnotationForeachFunc"/>
-          </parameter>
-          <parameter name="user_data" transfer-ownership="none">
-            <doc xml:whitespace="preserve">The callback data</doc>
-            <type name="gpointer" c:type="gpointer"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="watch_full"
-              c:identifier="annotation_object_watch_full"
-              shadows="watch">
-        <doc xml:whitespace="preserve">Test overriding via the "Rename To" annotation.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="func"
-                     transfer-ownership="none"
-                     scope="notified"
-                     closure="1"
-                     destroy="2">
-            <doc xml:whitespace="preserve">The callback</doc>
-            <type name="ForeachFunc" c:type="AnnotationForeachFunc"/>
-          </parameter>
-          <parameter name="user_data" transfer-ownership="none">
-            <doc xml:whitespace="preserve">The callback data</doc>
-            <type name="gpointer" c:type="gpointer"/>
-          </parameter>
-          <parameter name="destroy" transfer-ownership="none" scope="async">
-            <doc xml:whitespace="preserve">Destroy notification</doc>
-            <type name="GLib.DestroyNotify" c:type="GDestroyNotify"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="with_voidp" c:identifier="annotation_object_with_voidp">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="data" transfer-ownership="none">
-            <type name="gpointer" c:type="void*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <property name="function-property"
-                writable="1"
-                construct="1"
-                transfer-ownership="none">
-        <type name="Callback"/>
-      </property>
-      <property name="string-property"
-                version="1.0"
-                deprecated="Use better-string-property instead"
-                deprecated-version="1.2"
-                writable="1"
-                construct="1"
-                transfer-ownership="none">
-        <doc xml:whitespace="preserve">This is a property which is a string</doc>
-        <type name="utf8"/>
-      </property>
-      <field name="parent_instance">
-        <type name="GObject.Object" c:type="GObject"/>
-      </field>
-      <glib:signal name="attribute-signal">
-        <doc xml:whitespace="preserve">This signal tests a signal with attributes.</doc>
-        <return-value transfer-ownership="full">
-          <attribute name="some.annotation.foo3" value="val3"/>
-          <doc xml:whitespace="preserve">the return value</doc>
-          <type name="utf8"/>
-        </return-value>
-        <parameters>
-          <parameter name="arg1" transfer-ownership="none">
-            <attribute name="some.annotation.foo1" value="val1"/>
-            <doc xml:whitespace="preserve">a value</doc>
-            <type name="utf8"/>
-          </parameter>
-          <parameter name="arg2" transfer-ownership="none">
-            <attribute name="some.annotation.foo2" value="val2"/>
-            <doc xml:whitespace="preserve">another value</doc>
-            <type name="utf8"/>
-          </parameter>
-        </parameters>
-      </glib:signal>
-      <glib:signal name="doc-empty-arg-parsing">
-        <doc xml:whitespace="preserve">This signal tests an empty document argument (@arg1)</doc>
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-        <parameters>
-          <parameter name="object" transfer-ownership="none">
-            <type name="gpointer"/>
-          </parameter>
-        </parameters>
-      </glib:signal>
-      <glib:signal name="list-signal">
-        <doc xml:whitespace="preserve">This is a signal which takes a list of strings, but it's not
-known by GObject as it's only marked as G_TYPE_POINTER</doc>
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-        <parameters>
-          <parameter name="list" transfer-ownership="container">
-            <doc xml:whitespace="preserve">a list of strings</doc>
-            <type name="GLib.List">
-              <type name="utf8"/>
-            </type>
-          </parameter>
-        </parameters>
-      </glib:signal>
-      <glib:signal name="string-signal"
-                   version="1.0"
-                   deprecated="Use other-signal instead"
-                   deprecated-version="1.2">
-        <doc xml:whitespace="preserve">This is a signal which has a broken signal handler,
-it says it's pointer but it's actually a string.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-        <parameters>
-          <parameter name="string" transfer-ownership="none">
-            <doc xml:whitespace="preserve">a string</doc>
-            <type name="utf8"/>
-          </parameter>
-        </parameters>
-      </glib:signal>
-    </class>
-    <record name="ObjectClass"
-            c:type="AnnotationObjectClass"
-            glib:is-gtype-struct-for="Object">
-      <field name="parent_class">
-        <type name="GObject.ObjectClass" c:type="GObjectClass"/>
-      </field>
-    </record>
-    <record name="Struct" c:type="AnnotationStruct">
-      <doc xml:whitespace="preserve">This is a test of an array of object in an field of a struct.</doc>
-      <field name="objects" writable="1">
-        <array zero-terminated="0" c:type="AnnotationObject" fixed-size="10">
-          <type name="Object" c:type="AnnotationObject*"/>
-        </array>
-      </field>
-    </record>
-    <function name="attribute_func" c:identifier="annotation_attribute_func">
-      <return-value transfer-ownership="none">
-        <attribute name="some.other.annotation" value="value2"/>
-        <attribute name="yet.another.annotation" value="another_value"/>
-        <doc xml:whitespace="preserve">The return value.</doc>
-        <type name="gint" c:type="gint"/>
-      </return-value>
-      <parameters>
-        <parameter name="object" transfer-ownership="none">
-          <doc xml:whitespace="preserve">A #AnnotationObject.</doc>
-          <type name="Object" c:type="AnnotationObject*"/>
-        </parameter>
-        <parameter name="data" transfer-ownership="none">
-          <attribute name="some.annotation" value="value"/>
-          <attribute name="another.annotation" value="blahvalue"/>
-          <doc xml:whitespace="preserve">Some data.</doc>
-          <type name="utf8" c:type="gchar*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="custom_destroy" c:identifier="annotation_custom_destroy">
-      <doc xml:whitespace="preserve">Test messing up the heuristic of closure/destroy-notification
-detection, and fixing it via annotations.</doc>
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback"
-                   transfer-ownership="none"
-                   scope="notified"
-                   closure="2"
-                   destroy="1">
-          <doc xml:whitespace="preserve">Destroy notification</doc>
-          <type name="Callback" c:type="AnnotationCallback"/>
-        </parameter>
-        <parameter name="destroy"
-                   transfer-ownership="none"
-                   scope="notified"
-                   closure="2">
-          <type name="NotifyFunc" c:type="AnnotationNotifyFunc"/>
-        </parameter>
-        <parameter name="data" transfer-ownership="none">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="get_source_file" c:identifier="annotation_get_source_file">
-      <return-value transfer-ownership="full">
-        <doc xml:whitespace="preserve">Source file</doc>
-        <type name="filename"/>
-      </return-value>
-    </function>
-    <function name="init" c:identifier="annotation_init">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="argc"
-                   direction="inout"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">The number of args.</doc>
-          <type name="gint" c:type="int*"/>
-        </parameter>
-        <parameter name="argv"
-                   direction="inout"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">The arguments.</doc>
-          <array length="0" c:type="char***">
-            <type name="utf8"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="invalid_annotation"
-              c:identifier="annotation_invalid_annotation">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="foo" transfer-ownership="none">
-          <doc xml:whitespace="preserve">some text (e.g. example) or else</doc>
-          <type name="gint" c:type="int"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="ptr_array"
-              c:identifier="annotation_ptr_array"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="array" transfer-ownership="none">
-          <doc xml:whitespace="preserve">the array</doc>
-          <array name="GLib.PtrArray" c:type="GPtrArray*">
-            <type name="GLib.Value"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="return_array" c:identifier="annotation_return_array">
-      <return-value transfer-ownership="full">
-        <doc xml:whitespace="preserve">The return value</doc>
-        <array length="0" c:type="char**">
-          <type name="utf8"/>
-        </array>
-      </return-value>
-      <parameters>
-        <parameter name="length"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">Number of return values</doc>
-          <type name="gint" c:type="int*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="set_source_file" c:identifier="annotation_set_source_file">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="fname" transfer-ownership="none">
-          <doc xml:whitespace="preserve">Source file</doc>
-          <type name="filename"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="space_after_comment_bug631690"
-              c:identifier="annotation_space_after_comment_bug631690">
-      <doc xml:whitespace="preserve">Explicitly test having a space after the ** here.</doc>
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-    </function>
-    <function name="string_array_length"
-              c:identifier="annotation_string_array_length">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_properties" transfer-ownership="none">
-          <type name="guint" c:type="guint"/>
-        </parameter>
-        <parameter name="properties" transfer-ownership="none">
-          <array length="0" c:type="gchar*">
-            <type name="utf8"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="string_zero_terminated"
-              c:identifier="annotation_string_zero_terminated">
-      <return-value transfer-ownership="full">
-        <doc xml:whitespace="preserve">The return value</doc>
-        <array c:type="char**">
-          <type name="utf8"/>
-        </array>
-      </return-value>
-    </function>
-    <function name="string_zero_terminated_out"
-              c:identifier="annotation_string_zero_terminated_out">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="out"
-                   direction="inout"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <array c:type="char***">
-            <type name="utf8"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_parsing_bug630862"
-              c:identifier="annotation_test_parsing_bug630862">
-      <doc xml:whitespace="preserve">See https://bugzilla.gnome.org/show_bug.cgi?id=630862</doc>
-      <return-value transfer-ownership="none">
-        <doc xml:whitespace="preserve">An object, note the colon:in here</doc>
-        <type name="GObject.Object" c:type="GObject*"/>
-      </return-value>
-    </function>
-    <function name="versioned"
-              c:identifier="annotation_versioned"
-              version="0.6">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-    </function>
-  </namespace>
-</repository>

=== removed file '.pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Foo-1.0-expected.gir'
--- .pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Foo-1.0-expected.gir	2011-01-21 11:20:57 +0000
+++ .pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Foo-1.0-expected.gir	1970-01-01 00:00:00 +0000
@@ -1,1170 +0,0 @@
-<?xml version="1.0"?>
-<!-- This file was automatically generated from C sources - DO NOT EDIT!
-To affect the contents of this file, edit the original C definitions,
-and/or use gtk-doc annotations.  -->
-<repository version="1.2"
-            xmlns="http://www.gtk.org/introspection/core/1.0"
-            xmlns:c="http://www.gtk.org/introspection/c/1.0"
-            xmlns:glib="http://www.gtk.org/introspection/glib/1.0">
-  <include name="GLib" version="2.0"/>
-  <include name="GObject" version="2.0"/>
-  <include name="Gio" version="2.0"/>
-  <include name="Utility" version="1.0"/>
-  <package name="gobject-2.0"/>
-  <c:include name="foo.h"/>
-  <namespace name="Foo"
-             version="1.0"
-             shared-library="libfoo.so"
-             c:identifier-prefixes="Foo"
-             c:symbol-prefixes="foo">
-    <alias name="ObjectCookie" c:type="FooObjectCookie">
-      <type name="gpointer" c:type="gpointer"/>
-    </alias>
-    <alias name="XEvent" c:type="FooXEvent">
-      <type name="gpointer" c:type="gpointer"/>
-    </alias>
-    <enumeration name="ASingle" c:type="FooASingle">
-      <member name="some_single_enum"
-              value="0"
-              c:identifier="FOO_SOME_SINGLE_ENUM"/>
-    </enumeration>
-    <enumeration name="AddressType" c:type="FooAddressType">
-      <member name="invalid" value="0" c:identifier="FOO_ADDRESS_INVALID"/>
-      <member name="ipv4" value="1" c:identifier="FOO_ADDRESS_IPV4"/>
-      <member name="ipv6" value="2" c:identifier="FOO_ADDRESS_IPV6"/>
-    </enumeration>
-    <record name="BRect"
-            c:type="FooBRect"
-            glib:type-name="FooBRect"
-            glib:get-type="foo_brect_get_type"
-            c:symbol-prefix="brect">
-      <field name="x" writable="1">
-        <type name="gdouble" c:type="double"/>
-      </field>
-      <field name="y" writable="1">
-        <type name="gdouble" c:type="double"/>
-      </field>
-      <constructor name="new" c:identifier="foo_brect_new">
-        <return-value transfer-ownership="full">
-          <type name="BRect" c:type="FooBRect*"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gdouble" c:type="double"/>
-          </parameter>
-          <parameter name="y" transfer-ownership="none">
-            <type name="gdouble" c:type="double"/>
-          </parameter>
-        </parameters>
-      </constructor>
-      <method name="add" c:identifier="foo_brect_add">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="b2" transfer-ownership="none">
-            <type name="BRect" c:type="FooBRect*"/>
-          </parameter>
-        </parameters>
-      </method>
-    </record>
-    <union name="BUnion"
-           c:type="FooBUnion"
-           glib:type-name="FooBUnion"
-           glib:get-type="foo_bunion_get_type"
-           c:symbol-prefix="bunion">
-      <field name="type" writable="1">
-        <type name="gint" c:type="int"/>
-      </field>
-      <field name="v" writable="1">
-        <type name="gdouble" c:type="double"/>
-      </field>
-      <field name="rect" writable="1">
-        <type name="BRect" c:type="FooBRect*"/>
-      </field>
-      <constructor name="new" c:identifier="foo_bunion_new">
-        <return-value transfer-ownership="full">
-          <type name="BUnion" c:type="FooBUnion*"/>
-        </return-value>
-      </constructor>
-      <method name="get_contained_type"
-              c:identifier="foo_bunion_get_contained_type">
-        <return-value transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </return-value>
-      </method>
-    </union>
-    <record name="Boxed"
-            c:type="FooBoxed"
-            glib:type-name="FooBoxed"
-            glib:get-type="foo_boxed_get_type"
-            c:symbol-prefix="boxed">
-      <constructor name="new" c:identifier="foo_boxed_new">
-        <return-value transfer-ownership="full">
-          <type name="Boxed" c:type="FooBoxed*"/>
-        </return-value>
-      </constructor>
-      <method name="method" c:identifier="foo_boxed_method">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-    </record>
-    <class name="Buffer"
-           c:symbol-prefix="buffer"
-           c:type="FooBuffer"
-           parent="Object"
-           glib:type-name="FooBuffer"
-           glib:get-type="foo_buffer_get_type"
-           glib:type-struct="BufferClass">
-      <implements name="Interface"/>
-      <method name="some_method" c:identifier="foo_buffer_some_method">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-    </class>
-    <record name="BufferClass"
-            c:type="FooBufferClass"
-            disguised="1"
-            glib:is-gtype-struct-for="Buffer">
-    </record>
-    <callback name="Callback" c:type="FooCallback">
-      <return-value transfer-ownership="none">
-        <type name="gboolean" c:type="gboolean"/>
-      </return-value>
-      <parameters>
-        <parameter name="foo" transfer-ownership="none">
-          <type name="Object" c:type="FooObject*"/>
-        </parameter>
-        <parameter name="b" transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </parameter>
-        <parameter name="data" transfer-ownership="none">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-      </parameters>
-    </callback>
-    <record name="DBusData"
-            c:type="FooDBusData"
-            glib:type-name="FooDBusData"
-            glib:get-type="foo_dbus_data_get_type"
-            c:symbol-prefix="dbus_data">
-      <method name="method" c:identifier="foo_dbus_data_method">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-    </record>
-    <constant name="DEFINE_SHOULD_BE_EXPOSED" value="should be exposed">
-      <type name="utf8" c:type="gchar*"/>
-    </constant>
-    <enumeration name="EnumFullname" c:type="FooEnumFullname">
-      <member name="one" value="1" c:identifier="FOO_ENUM_FULLNAME_ONE"/>
-      <member name="two" value="2" c:identifier="FOO_ENUM_FULLNAME_TWO"/>
-      <member name="three" value="3" c:identifier="FOO_ENUM_FULLNAME_THREE"/>
-    </enumeration>
-    <enumeration name="EnumNoType" c:type="FooEnumNoType">
-      <member name="un" value="1" c:identifier="FOO_ENUM_UN"/>
-      <member name="deux" value="2" c:identifier="FOO_ENUM_DEUX"/>
-      <member name="trois" value="3" c:identifier="FOO_ENUM_TROIS"/>
-      <member name="neuf" value="9" c:identifier="FOO_ENUM_NEUF"/>
-    </enumeration>
-    <enumeration name="EnumType"
-                 glib:type-name="FooEnumType"
-                 glib:get-type="foo_enum_type_get_type"
-                 c:type="FooEnumType">
-      <member name="alpha"
-              value="0"
-              c:identifier="FOO_ENUM_ALPHA"
-              glib:nick="alpha"/>
-      <member name="beta"
-              value="1"
-              c:identifier="FOO_ENUM_BETA"
-              glib:nick="beta"/>
-      <member name="delta"
-              value="2"
-              c:identifier="FOO_ENUM_DELTA"
-              glib:nick="delta"/>
-    </enumeration>
-    <enumeration name="Error"
-                 glib:type-name="FooError"
-                 glib:get-type="foo_error_get_type"
-                 c:type="FooError"
-                 glib:error-quark="foo_error_quark">
-      <member name="good"
-              value="0"
-              c:identifier="FOO_ERROR_GOOD"
-              glib:nick="good"/>
-      <member name="bad"
-              value="1"
-              c:identifier="FOO_ERROR_BAD"
-              glib:nick="bad"/>
-      <member name="ugly"
-              value="2"
-              c:identifier="FOO_ERROR_UGLY"
-              glib:nick="ugly"/>
-    </enumeration>
-    <union name="Event" c:type="FooEvent">
-      <field name="type" writable="1">
-        <type name="gint" c:type="int"/>
-      </field>
-      <field name="any" writable="1">
-        <type name="EventAny" c:type="FooEventAny"/>
-      </field>
-      <field name="expose" writable="1">
-        <type name="EventExpose" c:type="FooEventExpose"/>
-      </field>
-    </union>
-    <record name="EventAny" c:type="FooEventAny">
-      <field name="send_event" writable="1">
-        <type name="gint8" c:type="gint8"/>
-      </field>
-    </record>
-    <record name="EventExpose" c:type="FooEventExpose">
-      <field name="send_event" writable="1">
-        <type name="gint8" c:type="gint8"/>
-      </field>
-      <field name="count" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-    </record>
-    <bitfield name="FlagsNoType" c:type="FooFlagsNoType">
-      <member name="ett" value="1" c:identifier="FOO_FLAGS_ETT"/>
-      <member name="tva" value="2" c:identifier="FOO_FLAGS_TVA"/>
-      <member name="fyra" value="4" c:identifier="FOO_FLAGS_FYRA"/>
-    </bitfield>
-    <bitfield name="FlagsType"
-              glib:type-name="FooFlagsType"
-              glib:get-type="foo_flags_type_get_type"
-              c:type="FooFlagsType">
-      <member name="first"
-              value="1"
-              c:identifier="FOO_FLAGS_FIRST"
-              glib:nick="first"/>
-      <member name="second"
-              value="2"
-              c:identifier="FOO_FLAGS_SECOND"
-              glib:nick="second"/>
-      <member name="third"
-              value="4"
-              c:identifier="FOO_FLAGS_THIRD"
-              glib:nick="third"/>
-    </bitfield>
-    <record name="ForeignStruct" c:type="FooForeignStruct" foreign="1">
-      <field name="foo" writable="1">
-        <type name="gint" c:type="int"/>
-      </field>
-      <constructor name="new" c:identifier="foo_foreign_struct_new">
-        <return-value transfer-ownership="full">
-          <type name="ForeignStruct" c:type="FooForeignStruct*"/>
-        </return-value>
-      </constructor>
-      <method name="copy" c:identifier="foo_foreign_struct_copy">
-        <return-value transfer-ownership="full">
-          <type name="ForeignStruct" c:type="FooForeignStruct*"/>
-        </return-value>
-      </method>
-    </record>
-    <interface name="Interface"
-               c:symbol-prefix="interface"
-               c:type="FooInterface"
-               glib:type-name="FooInterface"
-               glib:get-type="foo_interface_get_type"
-               glib:type-struct="InterfaceIface">
-      <virtual-method name="do_foo" invoker="do_foo">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </virtual-method>
-      <method name="do_foo" c:identifier="foo_interface_do_foo">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </method>
-    </interface>
-    <record name="InterfaceIface"
-            c:type="FooInterfaceIface"
-            glib:is-gtype-struct-for="Interface">
-      <field name="parent_iface">
-        <type name="GObject.TypeInterface" c:type="GTypeInterface"/>
-      </field>
-      <field name="do_foo">
-        <callback name="do_foo">
-          <return-value transfer-ownership="none">
-            <type name="none" c:type="void"/>
-          </return-value>
-          <parameters>
-            <parameter name="self" transfer-ownership="none">
-              <type name="Interface" c:type="FooInterface*"/>
-            </parameter>
-            <parameter name="x" transfer-ownership="none">
-              <type name="gint" c:type="int"/>
-            </parameter>
-          </parameters>
-        </callback>
-      </field>
-    </record>
-    <class name="Object"
-           c:symbol-prefix="object"
-           c:type="FooObject"
-           parent="GObject.Object"
-           glib:type-name="FooObject"
-           glib:get-type="foo_object_get_type"
-           glib:type-struct="ObjectClass">
-      <implements name="Interface"/>
-      <constructor name="new" c:identifier="foo_object_new">
-        <return-value transfer-ownership="full">
-          <type name="Object" c:type="FooObject*"/>
-        </return-value>
-      </constructor>
-      <function name="a_global_method"
-                c:identifier="foo_object_a_global_method">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="obj" transfer-ownership="none">
-            <type name="Utility.Object" c:type="UtilityObject*"/>
-          </parameter>
-        </parameters>
-      </function>
-      <function name="get_default" c:identifier="foo_object_get_default">
-        <doc xml:whitespace="preserve">This function is intended to match clutter_stage_get_default which
-uses a C sugar return type.</doc>
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">The global #FooSubobject</doc>
-          <type name="Subobject"/>
-        </return-value>
-      </function>
-      <function name="static_meth" c:identifier="foo_object_static_meth">
-        <return-value transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </return-value>
-      </function>
-      <virtual-method name="read_fn" invoker="read">
-        <doc xml:whitespace="preserve">Read some stuff.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="offset" transfer-ownership="none">
-            <doc xml:whitespace="preserve">offset</doc>
-            <type name="gint" c:type="int"/>
-          </parameter>
-          <parameter name="length" transfer-ownership="none">
-            <doc xml:whitespace="preserve">length</doc>
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </virtual-method>
-      <virtual-method name="virtual_method" invoker="virtual_method">
-        <return-value transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </return-value>
-        <parameters>
-          <parameter name="first_param" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </virtual-method>
-      <method name="append_new_stack_layer"
-              c:identifier="foo_object_append_new_stack_layer">
-        <doc xml:whitespace="preserve">This shouldn't be scanned as a constructor.</doc>
-        <return-value transfer-ownership="none">
-          <type name="OtherObject" c:type="FooOtherObject*"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="dup_name" c:identifier="foo_object_dup_name">
-        <return-value transfer-ownership="full">
-          <type name="utf8" c:type="char*"/>
-        </return-value>
-      </method>
-      <method name="external_type" c:identifier="foo_object_external_type">
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">%NULL always</doc>
-          <type name="Utility.Object" c:type="UtilityObject*"/>
-        </return-value>
-      </method>
-      <method name="get_name" c:identifier="foo_object_get_name">
-        <return-value transfer-ownership="none">
-          <type name="utf8" c:type="char*"/>
-        </return-value>
-      </method>
-      <method name="handle_glyph" c:identifier="foo_object_handle_glyph">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="glyph" transfer-ownership="none">
-            <type name="Utility.Glyph" c:type="UtilityGlyph"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="is_it_time_yet" c:identifier="foo_object_is_it_time_yet">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="time" transfer-ownership="none">
-            <type name="glong" c:type="time_t"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="new_cookie"
-              c:identifier="foo_object_new_cookie"
-              introspectable="0">
-        <doc xml:whitespace="preserve">Not sure why this test is here...</doc>
-        <return-value>
-          <type name="ObjectCookie" c:type="FooObjectCookie"/>
-        </return-value>
-        <parameters>
-          <parameter name="target" transfer-ownership="none">
-            <type name="utf8" c:type="char*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="read" c:identifier="foo_object_read">
-        <doc xml:whitespace="preserve">Read some stuff.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="offset" transfer-ownership="none">
-            <doc xml:whitespace="preserve">offset</doc>
-            <type name="gint" c:type="int"/>
-          </parameter>
-          <parameter name="length" transfer-ownership="none">
-            <doc xml:whitespace="preserve">length</doc>
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="skipped_method"
-              c:identifier="foo_object_skipped_method"
-              introspectable="0">
-        <doc xml:whitespace="preserve">This is only useful from C.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-      <method name="take_all"
-              c:identifier="foo_object_take_all"
-              introspectable="0">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-          <parameter transfer-ownership="none">
-            <varargs>
-            </varargs>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="various" c:identifier="foo_object_various">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="data" transfer-ownership="none">
-            <type name="gpointer" c:type="void*"/>
-          </parameter>
-          <parameter name="some_type" transfer-ownership="none">
-            <type name="GType" c:type="GType"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="virtual_method" c:identifier="foo_object_virtual_method">
-        <return-value transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </return-value>
-        <parameters>
-          <parameter name="first_param" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </method>
-      <property name="hidden"
-                introspectable="0"
-                writable="1"
-                construct-only="1"
-                transfer-ownership="none">
-        <type/>
-      </property>
-      <property name="string"
-                writable="1"
-                construct="1"
-                transfer-ownership="none">
-        <type name="utf8"/>
-      </property>
-      <field name="parent_instance">
-        <type name="GObject.Object" c:type="GObject"/>
-      </field>
-      <field name="some_int">
-        <type name="gint" c:type="int"/>
-      </field>
-      <glib:signal name="signal">
-        <return-value transfer-ownership="full">
-          <type name="utf8"/>
-        </return-value>
-        <parameters>
-          <parameter name="object" transfer-ownership="none">
-            <type name="GObject.Object"/>
-          </parameter>
-          <parameter name="p0" transfer-ownership="none">
-            <type name="gpointer"/>
-          </parameter>
-        </parameters>
-      </glib:signal>
-    </class>
-    <record name="ObjectClass"
-            c:type="FooObjectClass"
-            glib:is-gtype-struct-for="Object">
-      <field name="parent_class">
-        <type name="GObject.ObjectClass" c:type="GObjectClass"/>
-      </field>
-      <field name="virtual_method">
-        <callback name="virtual_method">
-          <return-value transfer-ownership="none">
-            <type name="gboolean" c:type="gboolean"/>
-          </return-value>
-          <parameters>
-            <parameter name="object" transfer-ownership="none">
-              <type name="Object" c:type="FooObject*"/>
-            </parameter>
-            <parameter name="first_param" transfer-ownership="none">
-              <type name="gint" c:type="int"/>
-            </parameter>
-          </parameters>
-        </callback>
-      </field>
-      <field name="read_fn">
-        <callback name="read_fn">
-          <return-value transfer-ownership="none">
-            <type name="none" c:type="void"/>
-          </return-value>
-          <parameters>
-            <parameter name="object" transfer-ownership="none">
-              <type name="Object" c:type="FooObject*"/>
-            </parameter>
-            <parameter name="offset" transfer-ownership="none">
-              <doc xml:whitespace="preserve">offset</doc>
-              <type name="gint" c:type="int"/>
-            </parameter>
-            <parameter name="length" transfer-ownership="none">
-              <doc xml:whitespace="preserve">length</doc>
-              <type name="gint" c:type="int"/>
-            </parameter>
-          </parameters>
-        </callback>
-      </field>
-      <field name="_reserved">
-        <array zero-terminated="0" c:type="GCallback" fixed-size="4">
-          <type name="GObject.Callback" c:type="GCallback"/>
-        </array>
-      </field>
-    </record>
-    <class name="OtherObject"
-           c:symbol-prefix="other_object"
-           c:type="FooOtherObject"
-           parent="GObject.Object"
-           glib:type-name="FooOtherObject"
-           glib:get-type="foo_other_object_get_type"
-           glib:type-struct="OtherObjectClass">
-    </class>
-    <record name="OtherObjectClass"
-            c:type="FooOtherObjectClass"
-            disguised="1"
-            glib:is-gtype-struct-for="OtherObject">
-    </record>
-    <constant name="PIE_IS_TASTY" value="3.141590">
-      <type name="gdouble" c:type="gdouble"/>
-    </constant>
-    <record name="Rectangle" c:type="FooRectangle">
-      <field name="x" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="y" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="width" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="height" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <method name="add" c:identifier="foo_rectangle_add">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="r2" transfer-ownership="none">
-            <doc xml:whitespace="preserve">source rectangle</doc>
-            <type name="Rectangle" c:type="FooRectangle*"/>
-          </parameter>
-        </parameters>
-      </method>
-    </record>
-    <constant name="SUCCESS_INT" value="4408">
-      <type name="gint" c:type="gint"/>
-    </constant>
-    <enumeration name="Skippable" introspectable="0" c:type="FooSkippable">
-      <doc xml:whitespace="preserve">Some type that is only interesting from C and should not be
-exposed to language bindings.</doc>
-      <member name="one" value="0" c:identifier="FOO_SKIPPABLE_ONE"/>
-      <member name="two" value="1" c:identifier="FOO_SKIPPABLE_TWO"/>
-    </enumeration>
-    <enumeration name="StackLayer" c:type="FooStackLayer">
-      <member name="desktop" value="0" c:identifier="FOO_LAYER_DESKTOP"/>
-      <member name="bottom" value="1" c:identifier="FOO_LAYER_BOTTOM"/>
-      <member name="normal" value="2" c:identifier="FOO_LAYER_NORMAL"/>
-      <member name="top" value="4" c:identifier="FOO_LAYER_TOP"/>
-      <member name="dock" value="4" c:identifier="FOO_LAYER_DOCK"/>
-      <member name="fullscreen" value="5" c:identifier="FOO_LAYER_FULLSCREEN"/>
-      <member name="focused_window"
-              value="6"
-              c:identifier="FOO_LAYER_FOCUSED_WINDOW"/>
-      <member name="override_redirect"
-              value="7"
-              c:identifier="FOO_LAYER_OVERRIDE_REDIRECT"/>
-      <member name="last" value="8" c:identifier="FOO_LAYER_LAST"/>
-    </enumeration>
-    <record name="Struct" c:type="FooStruct">
-      <field name="priv" writable="1">
-        <type name="StructPrivate" c:type="FooStructPrivate*"/>
-      </field>
-      <field name="member" writable="1">
-        <type name="gint" c:type="int"/>
-      </field>
-    </record>
-    <record name="StructPrivate" c:type="FooStructPrivate" disguised="1">
-    </record>
-    <interface name="SubInterface"
-               c:symbol-prefix="sub_interface"
-               c:type="FooSubInterface"
-               glib:type-name="FooSubInterface"
-               glib:get-type="foo_sub_interface_get_type"
-               glib:type-struct="SubInterfaceIface">
-      <prerequisite name="Interface"/>
-      <virtual-method name="destroy_event">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </virtual-method>
-      <virtual-method name="do_bar" invoker="do_bar">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </virtual-method>
-      <virtual-method name="do_baz" invoker="do_baz">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="callback"
-                     transfer-ownership="none"
-                     scope="call"
-                     closure="1">
-            <type name="GObject.Callback" c:type="GCallback"/>
-          </parameter>
-          <parameter name="data" transfer-ownership="none">
-            <type name="gpointer" c:type="gpointer"/>
-          </parameter>
-        </parameters>
-      </virtual-method>
-      <virtual-method name="do_moo" invoker="do_moo">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-          <parameter transfer-ownership="none">
-            <type name="gpointer" c:type="gpointer"/>
-          </parameter>
-        </parameters>
-      </virtual-method>
-      <method name="do_bar" c:identifier="foo_sub_interface_do_bar">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-      <method name="do_baz" c:identifier="foo_sub_interface_do_baz">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="callback"
-                     transfer-ownership="none"
-                     scope="call"
-                     closure="1">
-            <type name="GObject.Callback" c:type="GCallback"/>
-          </parameter>
-          <parameter name="data" transfer-ownership="none">
-            <type name="gpointer" c:type="gpointer"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="do_moo" c:identifier="foo_sub_interface_do_moo">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-          <parameter transfer-ownership="none">
-            <type name="gpointer" c:type="gpointer"/>
-          </parameter>
-        </parameters>
-      </method>
-      <glib:signal name="destroy-event">
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-      </glib:signal>
-    </interface>
-    <record name="SubInterfaceIface"
-            c:type="FooSubInterfaceIface"
-            glib:is-gtype-struct-for="SubInterface">
-      <field name="parent_iface">
-        <type name="GObject.TypeInterface" c:type="GTypeInterface"/>
-      </field>
-      <field name="destroy_event">
-        <callback name="destroy_event">
-          <return-value transfer-ownership="none">
-            <type name="none" c:type="void"/>
-          </return-value>
-          <parameters>
-            <parameter name="self" transfer-ownership="none">
-              <type name="SubInterface" c:type="FooSubInterface*"/>
-            </parameter>
-          </parameters>
-        </callback>
-      </field>
-      <field name="do_bar">
-        <callback name="do_bar">
-          <return-value transfer-ownership="none">
-            <type name="none" c:type="void"/>
-          </return-value>
-          <parameters>
-            <parameter name="self" transfer-ownership="none">
-              <type name="SubInterface" c:type="FooSubInterface*"/>
-            </parameter>
-          </parameters>
-        </callback>
-      </field>
-      <field name="do_moo">
-        <callback name="do_moo">
-          <return-value transfer-ownership="none">
-            <type name="none" c:type="void"/>
-          </return-value>
-          <parameters>
-            <parameter name="self" transfer-ownership="none">
-              <type name="SubInterface" c:type="FooSubInterface*"/>
-            </parameter>
-            <parameter transfer-ownership="none">
-              <type name="gint" c:type="int"/>
-            </parameter>
-            <parameter transfer-ownership="none">
-              <type name="gpointer" c:type="gpointer"/>
-            </parameter>
-          </parameters>
-        </callback>
-      </field>
-      <field name="do_baz">
-        <callback name="do_baz">
-          <return-value transfer-ownership="none">
-            <type name="none" c:type="void"/>
-          </return-value>
-          <parameters>
-            <parameter name="self" transfer-ownership="none">
-              <type name="SubInterface" c:type="FooSubInterface*"/>
-            </parameter>
-            <parameter name="callback"
-                       transfer-ownership="none"
-                       scope="call"
-                       closure="2">
-              <type name="GObject.Callback" c:type="GCallback"/>
-            </parameter>
-            <parameter name="data" transfer-ownership="none">
-              <type name="gpointer" c:type="gpointer"/>
-            </parameter>
-          </parameters>
-        </callback>
-      </field>
-    </record>
-    <class name="Subobject"
-           c:symbol-prefix="subobject"
-           c:type="FooSubobject"
-           parent="Object"
-           abstract="1"
-           glib:type-name="FooSubobject"
-           glib:get-type="foo_subobject_get_type"
-           glib:type-struct="SubobjectClass">
-      <implements name="Interface"/>
-      <constructor name="new" c:identifier="foo_subobject_new">
-        <return-value transfer-ownership="full">
-          <type name="Subobject" c:type="FooSubobject*"/>
-        </return-value>
-      </constructor>
-      <field name="parent_instance">
-        <type name="Object" c:type="FooObject"/>
-      </field>
-    </class>
-    <record name="SubobjectClass"
-            c:type="FooSubobjectClass"
-            glib:is-gtype-struct-for="Subobject">
-      <field name="parent_class">
-        <type name="ObjectClass" c:type="FooObjectClass"/>
-      </field>
-    </record>
-    <record name="ThingWithArray" c:type="FooThingWithArray">
-      <field name="x" writable="1">
-        <type name="gint" c:type="int"/>
-      </field>
-      <field name="y" writable="1">
-        <type name="gint" c:type="int"/>
-      </field>
-      <field name="lines" writable="1">
-        <array zero-terminated="0" c:type="gchar" fixed-size="80">
-          <type name="gchar" c:type="char"/>
-        </array>
-      </field>
-      <field name="data" writable="1">
-        <type name="guint8" c:type="guchar*"/>
-      </field>
-    </record>
-    <union name="Union" c:type="FooUnion">
-      <field name="foo" writable="1">
-        <type name="gint" c:type="int"/>
-      </field>
-    </union>
-    <record name="UtilityStruct" c:type="FooUtilityStruct">
-      <field name="bar" writable="1">
-        <type name="Utility.Struct" c:type="UtilityStruct"/>
-      </field>
-    </record>
-    <callback name="VarargsCallback"
-              c:type="FooVarargsCallback"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="param" transfer-ownership="none">
-          <type name="utf8" c:type="char*"/>
-        </parameter>
-        <parameter transfer-ownership="none">
-          <varargs>
-          </varargs>
-        </parameter>
-      </parameters>
-    </callback>
-    <function name="async_ready_callback"
-              c:identifier="foo_async_ready_callback">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="cancellable" transfer-ownership="none" allow-none="1">
-          <type name="Gio.Cancellable" c:type="GCancellable*"/>
-        </parameter>
-        <parameter name="callback"
-                   transfer-ownership="none"
-                   scope="async"
-                   closure="2">
-          <type name="Gio.AsyncReadyCallback" c:type="GAsyncReadyCallback"/>
-        </parameter>
-        <parameter name="user_data" transfer-ownership="none">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="destroy_notify_callback"
-              c:identifier="foo_destroy_notify_callback">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback"
-                   transfer-ownership="none"
-                   scope="notified"
-                   closure="1"
-                   destroy="2">
-          <type name="Callback" c:type="FooCallback"/>
-        </parameter>
-        <parameter name="data" transfer-ownership="none">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-        <parameter name="destroy" transfer-ownership="none" scope="async">
-          <type name="GLib.DestroyNotify" c:type="GDestroyNotify"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="enum_type_method" c:identifier="foo_enum_type_method">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="foo_enum" transfer-ownership="none">
-          <type name="EnumType" c:type="FooEnumType"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="enum_type_returnv" c:identifier="foo_enum_type_returnv">
-      <return-value transfer-ownership="none">
-        <type name="EnumType" c:type="FooEnumType"/>
-      </return-value>
-      <parameters>
-        <parameter name="x" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="error_quark" c:identifier="foo_error_quark">
-      <return-value transfer-ownership="none">
-        <type name="GLib.Quark" c:type="GQuark"/>
-      </return-value>
-    </function>
-    <function name="init" c:identifier="foo_init">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="gint"/>
-      </return-value>
-    </function>
-    <function name="method_external_references"
-              c:identifier="foo_method_external_references">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="object" transfer-ownership="none">
-          <type name="Utility.Object" c:type="UtilityObject*"/>
-        </parameter>
-        <parameter name="e" transfer-ownership="none">
-          <type name="Utility.EnumType" c:type="UtilityEnumType"/>
-        </parameter>
-        <parameter name="f" transfer-ownership="none">
-          <type name="Utility.FlagType" c:type="UtilityFlagType"/>
-        </parameter>
-        <parameter name="s" transfer-ownership="none">
-          <type name="Utility.Struct" c:type="UtilityStruct"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="rectangle_new"
-              c:identifier="foo_rectangle_new"
-              introspectable="0">
-      <doc xml:whitespace="preserve">This is a C convenience constructor; we have to (skip)
-it because it's not a boxed type.</doc>
-      <return-value>
-        <type name="Rectangle" c:type="FooRectangle*"/>
-      </return-value>
-      <parameters>
-        <parameter name="x" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="y" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="width" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="height" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="skip_me" c:identifier="foo_skip_me" introspectable="0">
-      <doc xml:whitespace="preserve">Does something that's only interesting from C and should not be
-exposed to language bindings.</doc>
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="fs" transfer-ownership="none">
-          <doc xml:whitespace="preserve">a #FooSkippable</doc>
-          <type name="Skippable" c:type="FooSkippable"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="some_variant"
-              c:identifier="foo_some_variant"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="x" transfer-ownership="none">
-          <type name="guint" c:type="guint"/>
-        </parameter>
-        <parameter name="args" transfer-ownership="none">
-          <type name="va_list" c:type="va_list"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="some_variant_ptr"
-              c:identifier="foo_some_variant_ptr"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="x" transfer-ownership="none">
-          <type name="guint" c:type="guint"/>
-        </parameter>
-        <parameter name="args" transfer-ownership="none">
-          <type name="va_list" c:type="va_list*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array" c:identifier="foo_test_array">
-      <return-value transfer-ownership="container">
-        <array name="GLib.Array" c:type="GArray*">
-          <type name="utf8"/>
-        </array>
-      </return-value>
-    </function>
-    <function name="test_const_char_param"
-              c:identifier="foo_test_const_char_param">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="param" transfer-ownership="none">
-          <type name="utf8" c:type="char*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_const_char_retval"
-              c:identifier="foo_test_const_char_retval">
-      <return-value transfer-ownership="none">
-        <type name="utf8" c:type="char*"/>
-      </return-value>
-    </function>
-    <function name="test_const_struct_param"
-              c:identifier="foo_test_const_struct_param">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="param" transfer-ownership="none">
-          <type name="Struct" c:type="FooStruct*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_const_struct_retval"
-              c:identifier="foo_test_const_struct_retval">
-      <return-value transfer-ownership="none">
-        <type name="Struct" c:type="FooStruct*"/>
-      </return-value>
-    </function>
-    <function name="test_string_array" c:identifier="foo_test_string_array">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="array" transfer-ownership="none">
-          <array c:type="char**">
-            <type name="utf8"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_string_array_with_g"
-              c:identifier="foo_test_string_array_with_g">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="array" transfer-ownership="none">
-          <array c:type="gchar**">
-            <type name="utf8"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_unsigned_qualifier"
-              c:identifier="foo_test_unsigned_qualifier">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="unsigned_param" transfer-ownership="none">
-          <type name="guint" c:type="unsigned int"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_unsigned_type" c:identifier="foo_test_unsigned_type">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="unsigned_param" transfer-ownership="none">
-          <type name="guint" c:type="unsigned"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_varargs_callback"
-              c:identifier="foo_test_varargs_callback"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="i" transfer-ownership="none">
-          <type name="gint" c:type="gint"/>
-        </parameter>
-        <parameter name="callback" transfer-ownership="none">
-          <type name="VarargsCallback" c:type="FooVarargsCallback"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_varargs_callback2"
-              c:identifier="foo_test_varargs_callback2"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback" transfer-ownership="none">
-          <type name="VarargsCallback" c:type="FooVarargsCallback"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_varargs_callback3"
-              c:identifier="foo_test_varargs_callback3"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback" transfer-ownership="none">
-          <type name="VarargsCallback" c:type="FooVarargsCallback"/>
-        </parameter>
-        <parameter name="callback2" transfer-ownership="none">
-          <type name="VarargsCallback" c:type="FooVarargsCallback"/>
-        </parameter>
-      </parameters>
-    </function>
-  </namespace>
-</repository>

=== removed file '.pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Regress-1.0-expected.gir'
--- .pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Regress-1.0-expected.gir	2011-01-21 11:20:57 +0000
+++ .pc/0001-Preserve-the-c-type-of-array-elements.patch/tests/scanner/Regress-1.0-expected.gir	1970-01-01 00:00:00 +0000
@@ -1,2497 +0,0 @@
-<?xml version="1.0"?>
-<!-- This file was automatically generated from C sources - DO NOT EDIT!
-To affect the contents of this file, edit the original C definitions,
-and/or use gtk-doc annotations.  -->
-<repository version="1.2"
-            xmlns="http://www.gtk.org/introspection/core/1.0"
-            xmlns:c="http://www.gtk.org/introspection/c/1.0"
-            xmlns:glib="http://www.gtk.org/introspection/glib/1.0">
-  <include name="GLib" version="2.0"/>
-  <include name="GObject" version="2.0"/>
-  <include name="Gio" version="2.0"/>
-  <include name="cairo" version="1.0"/>
-  <c:include name="regress.h"/>
-  <namespace name="Regress"
-             version="1.0"
-             shared-library="libregress.so"
-             c:identifier-prefixes="Regress"
-             c:symbol-prefixes="regress">
-    <alias name="IntSet" c:type="RegressIntSet" introspectable="0">
-      <doc xml:whitespace="preserve">Compatibility typedef, like telepathy-glib's TpIntSet</doc>
-      <type name="Intset" c:type="RegressIntset"/>
-    </alias>
-    <alias name="PtrArrayAlias" c:type="RegressPtrArrayAlias">
-      <doc xml:whitespace="preserve">Typedef'd GPtrArray for some reason</doc>
-      <type name="GLib.PtrArray" c:type="GPtrArray"/>
-    </alias>
-    <alias name="VaListAlias" c:type="RegressVaListAlias" introspectable="0">
-      <doc xml:whitespace="preserve">Typedef'd va_list for additional reasons</doc>
-      <type name="va_list" c:type="va_list"/>
-    </alias>
-    <constant name="DOUBLE_CONSTANT" value="44.220000">
-      <type name="gdouble" c:type="gdouble"/>
-    </constant>
-    <constant name="INT_CONSTANT" value="4422">
-      <type name="gint" c:type="gint"/>
-    </constant>
-    <record name="Intset" c:type="RegressIntset" disguised="1">
-      <doc xml:whitespace="preserve">Like telepathy-glib's TpIntset.</doc>
-    </record>
-    <constant name="Mixed_Case_Constant" value="4423">
-      <type name="gint" c:type="gint"/>
-    </constant>
-    <constant name="STRING_CONSTANT" value="Some String">
-      <type name="utf8" c:type="gchar*"/>
-    </constant>
-    <record name="SkippedStructure"
-            c:type="RegressSkippedStructure"
-            introspectable="0">
-      <doc xml:whitespace="preserve">This should be skipped, and moreover, all function which
-use it should be.</doc>
-      <field name="x" writable="1">
-        <type name="gint" c:type="int"/>
-      </field>
-      <field name="v" writable="1">
-        <type name="gdouble" c:type="double"/>
-      </field>
-    </record>
-    <record name="TestBoxed"
-            c:type="RegressTestBoxed"
-            glib:type-name="RegressTestBoxed"
-            glib:get-type="regress_test_boxed_get_type"
-            c:symbol-prefix="test_boxed">
-      <field name="some_int8" writable="1">
-        <type name="gint8" c:type="gint8"/>
-      </field>
-      <field name="nested_a" writable="1">
-        <type name="TestSimpleBoxedA" c:type="RegressTestSimpleBoxedA"/>
-      </field>
-      <field name="priv" writable="1">
-        <type name="TestBoxedPrivate" c:type="RegressTestBoxedPrivate*"/>
-      </field>
-      <constructor name="new" c:identifier="regress_test_boxed_new">
-        <return-value transfer-ownership="full">
-          <type name="TestBoxed" c:type="RegressTestBoxed*"/>
-        </return-value>
-      </constructor>
-      <constructor name="new_alternative_constructor1"
-                   c:identifier="regress_test_boxed_new_alternative_constructor1">
-        <return-value transfer-ownership="full">
-          <type name="TestBoxed" c:type="RegressTestBoxed*"/>
-        </return-value>
-        <parameters>
-          <parameter name="i" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </constructor>
-      <constructor name="new_alternative_constructor2"
-                   c:identifier="regress_test_boxed_new_alternative_constructor2">
-        <return-value transfer-ownership="full">
-          <type name="TestBoxed" c:type="RegressTestBoxed*"/>
-        </return-value>
-        <parameters>
-          <parameter name="i" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-          <parameter name="j" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </constructor>
-      <constructor name="new_alternative_constructor3"
-                   c:identifier="regress_test_boxed_new_alternative_constructor3">
-        <return-value transfer-ownership="full">
-          <type name="TestBoxed" c:type="RegressTestBoxed*"/>
-        </return-value>
-        <parameters>
-          <parameter name="s" transfer-ownership="none">
-            <type name="utf8" c:type="char*"/>
-          </parameter>
-        </parameters>
-      </constructor>
-      <method name="copy" c:identifier="regress_test_boxed_copy">
-        <return-value transfer-ownership="full">
-          <type name="TestBoxed" c:type="RegressTestBoxed*"/>
-        </return-value>
-      </method>
-      <method name="equals" c:identifier="regress_test_boxed_equals">
-        <return-value transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </return-value>
-        <parameters>
-          <parameter name="other" transfer-ownership="none">
-            <type name="TestBoxed" c:type="RegressTestBoxed*"/>
-          </parameter>
-        </parameters>
-      </method>
-    </record>
-    <record name="TestBoxedPrivate"
-            c:type="RegressTestBoxedPrivate"
-            disguised="1">
-    </record>
-    <callback name="TestCallback" c:type="RegressTestCallback">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-    </callback>
-    <callback name="TestCallbackFull" c:type="RegressTestCallbackFull">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="foo" transfer-ownership="none">
-          <doc xml:whitespace="preserve">the investment rate</doc>
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="bar" transfer-ownership="none">
-          <doc xml:whitespace="preserve">how much money</doc>
-          <type name="gdouble" c:type="double"/>
-        </parameter>
-        <parameter name="path" transfer-ownership="none">
-          <doc xml:whitespace="preserve">Path to file</doc>
-          <type name="filename"/>
-        </parameter>
-      </parameters>
-    </callback>
-    <callback name="TestCallbackUserData" c:type="RegressTestCallbackUserData">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="user_data" transfer-ownership="none" closure="0">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-      </parameters>
-    </callback>
-    <enumeration name="TestEnum"
-                 glib:type-name="RegressTestEnum"
-                 glib:get-type="regress_test_enum_get_type"
-                 c:type="RegressTestEnum">
-      <member name="value1"
-              value="0"
-              c:identifier="REGRESS_TEST_VALUE1"
-              glib:nick="value1"/>
-      <member name="value2"
-              value="1"
-              c:identifier="REGRESS_TEST_VALUE2"
-              glib:nick="value2"/>
-      <member name="value3"
-              value="-1"
-              c:identifier="REGRESS_TEST_VALUE3"
-              glib:nick="value3"/>
-    </enumeration>
-    <enumeration name="TestEnumUnsigned"
-                 glib:type-name="RegressTestEnumUnsigned"
-                 glib:get-type="regress_test_enum_unsigned_get_type"
-                 c:type="RegressTestEnumUnsigned">
-      <member name="value1"
-              value="1"
-              c:identifier="REGRESS_TEST_UNSIGNED_VALUE1"
-              glib:nick="value1"/>
-      <member name="value2"
-              value="2147483648"
-              c:identifier="REGRESS_TEST_UNSIGNED_VALUE2"
-              glib:nick="value2"/>
-    </enumeration>
-    <bitfield name="TestFlags"
-              glib:type-name="RegressTestFlags"
-              glib:get-type="regress_test_flags_get_type"
-              c:type="RegressTestFlags">
-      <member name="flag1"
-              value="1"
-              c:identifier="TEST_FLAG1"
-              glib:nick="flag1"/>
-      <member name="flag2"
-              value="2"
-              c:identifier="TEST_FLAG2"
-              glib:nick="flag2"/>
-      <member name="flag3"
-              value="4"
-              c:identifier="TEST_FLAG3"
-              glib:nick="flag3"/>
-    </bitfield>
-    <class name="TestFloating"
-           c:symbol-prefix="test_floating"
-           c:type="RegressTestFloating"
-           parent="GObject.InitiallyUnowned"
-           glib:type-name="RegressTestFloating"
-           glib:get-type="regress_test_floating_get_type"
-           glib:type-struct="TestFloatingClass">
-      <constructor name="new" c:identifier="regress_test_floating_new">
-        <return-value transfer-ownership="none">
-          <doc xml:whitespace="preserve">A new floating #RegressTestFloating</doc>
-          <type name="TestFloating" c:type="RegressTestFloating*"/>
-        </return-value>
-      </constructor>
-      <field name="parent_instance">
-        <type name="GObject.InitiallyUnowned" c:type="GInitiallyUnowned"/>
-      </field>
-    </class>
-    <record name="TestFloatingClass"
-            c:type="RegressTestFloatingClass"
-            glib:is-gtype-struct-for="TestFloating">
-      <field name="parent_class">
-        <type name="GObject.InitiallyUnownedClass"
-              c:type="GInitiallyUnownedClass"/>
-      </field>
-    </record>
-    <class name="TestFundamentalObject"
-           c:symbol-prefix="test_fundamental_object"
-           c:type="RegressTestFundamentalObject"
-           abstract="1"
-           glib:type-name="RegressTestFundamentalObject"
-           glib:get-type="regress_test_fundamental_object_get_type"
-           glib:type-struct="TestFundamentalObjectClass"
-           glib:fundamental="1"
-           glib:ref-func="regress_test_fundamental_object_ref"
-           glib:unref-func="regress_test_fundamental_object_unref"
-           glib:set-value-func="regress_test_value_set_fundamental_object"
-           glib:get-value-func="regress_test_value_get_fundamental_object">
-      <method name="ref" c:identifier="regress_test_fundamental_object_ref">
-        <return-value transfer-ownership="full">
-          <doc xml:whitespace="preserve">A new #RegressTestFundamentalObject</doc>
-          <type name="TestFundamentalObject"
-                c:type="RegressTestFundamentalObject*"/>
-        </return-value>
-      </method>
-      <method name="unref"
-              c:identifier="regress_test_fundamental_object_unref">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-      <field name="instance">
-        <type name="GObject.TypeInstance" c:type="GTypeInstance"/>
-      </field>
-      <field name="refcount">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="flags">
-        <type name="guint" c:type="guint"/>
-      </field>
-    </class>
-    <record name="TestFundamentalObjectClass"
-            c:type="RegressTestFundamentalObjectClass"
-            glib:is-gtype-struct-for="TestFundamentalObject">
-      <field name="type_class">
-        <type name="GObject.TypeClass" c:type="GTypeClass"/>
-      </field>
-      <field name="copy">
-        <type name="TestFundamentalObjectCopyFunction"
-              c:type="RegressTestFundamentalObjectCopyFunction"/>
-      </field>
-      <field name="finalize">
-        <type name="TestFundamentalObjectFinalizeFunction"
-              c:type="RegressTestFundamentalObjectFinalizeFunction"/>
-      </field>
-    </record>
-    <callback name="TestFundamentalObjectCopyFunction"
-              c:type="RegressTestFundamentalObjectCopyFunction">
-      <return-value transfer-ownership="full">
-        <type name="TestFundamentalObject"
-              c:type="RegressTestFundamentalObject*"/>
-      </return-value>
-      <parameters>
-        <parameter name="obj" transfer-ownership="none">
-          <type name="TestFundamentalObject"
-                c:type="RegressTestFundamentalObject*"/>
-        </parameter>
-      </parameters>
-    </callback>
-    <callback name="TestFundamentalObjectFinalizeFunction"
-              c:type="RegressTestFundamentalObjectFinalizeFunction">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="obj" transfer-ownership="none">
-          <type name="TestFundamentalObject"
-                c:type="RegressTestFundamentalObject*"/>
-        </parameter>
-      </parameters>
-    </callback>
-    <class name="TestFundamentalSubObject"
-           c:symbol-prefix="test_fundamental_sub_object"
-           c:type="RegressTestFundamentalSubObject"
-           parent="TestFundamentalObject"
-           glib:type-name="RegressTestFundamentalSubObject"
-           glib:get-type="regress_test_fundamental_sub_object_get_type"
-           glib:type-struct="TestFundamentalSubObjectClass"
-           glib:fundamental="1">
-      <constructor name="new"
-                   c:identifier="regress_test_fundamental_sub_object_new">
-        <return-value transfer-ownership="full">
-          <type name="TestFundamentalSubObject"
-                c:type="RegressTestFundamentalSubObject*"/>
-        </return-value>
-        <parameters>
-          <parameter name="data" transfer-ownership="none">
-            <type name="utf8" c:type="char*"/>
-          </parameter>
-        </parameters>
-      </constructor>
-      <field name="fundamental_object">
-        <type name="TestFundamentalObject"
-              c:type="RegressTestFundamentalObject"/>
-      </field>
-      <field name="data">
-        <type name="utf8" c:type="char*"/>
-      </field>
-    </class>
-    <record name="TestFundamentalSubObjectClass"
-            c:type="RegressTestFundamentalSubObjectClass"
-            glib:is-gtype-struct-for="TestFundamentalSubObject">
-      <field name="fundamental_object_class">
-        <type name="TestFundamentalObjectClass"
-              c:type="RegressTestFundamentalObjectClass"/>
-      </field>
-    </record>
-    <interface name="TestInterface"
-               c:symbol-prefix="test_interface"
-               c:type="RegressTestInterface"
-               glib:type-name="RegressTestInterface"
-               glib:get-type="regress_test_interface_get_type"
-               glib:type-struct="TestInterfaceIface">
-    </interface>
-    <record name="TestInterfaceIface"
-            c:type="RegressTestInterfaceIface"
-            glib:is-gtype-struct-for="TestInterface">
-      <field name="base_iface">
-        <type name="GObject.TypeInterface" c:type="GTypeInterface"/>
-      </field>
-    </record>
-    <class name="TestObj"
-           c:symbol-prefix="test_obj"
-           c:type="RegressTestObj"
-           parent="GObject.Object"
-           glib:type-name="RegressTestObj"
-           glib:get-type="regress_test_obj_get_type"
-           glib:type-struct="TestObjClass">
-      <constructor name="new_callback"
-                   c:identifier="regress_test_obj_new_callback">
-        <return-value transfer-ownership="full">
-          <type name="TestObj" c:type="RegressTestObj*"/>
-        </return-value>
-        <parameters>
-          <parameter name="callback"
-                     transfer-ownership="none"
-                     scope="notified"
-                     closure="1"
-                     destroy="2">
-            <type name="TestCallbackUserData"
-                  c:type="RegressTestCallbackUserData"/>
-          </parameter>
-          <parameter name="user_data" transfer-ownership="none">
-            <type name="gpointer" c:type="gpointer"/>
-          </parameter>
-          <parameter name="notify" transfer-ownership="none" scope="async">
-            <type name="GLib.DestroyNotify" c:type="GDestroyNotify"/>
-          </parameter>
-        </parameters>
-      </constructor>
-      <constructor name="new_from_file"
-                   c:identifier="regress_test_obj_new_from_file"
-                   throws="1">
-        <return-value transfer-ownership="full">
-          <type name="TestObj" c:type="RegressTestObj*"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="utf8" c:type="char*"/>
-          </parameter>
-        </parameters>
-      </constructor>
-      <function name="null_out" c:identifier="regress_test_obj_null_out">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="obj"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full"
-                     allow-none="1">
-            <doc xml:whitespace="preserve">A #RegressTestObj</doc>
-            <type name="TestObj" c:type="RegressTestObj**"/>
-          </parameter>
-        </parameters>
-      </function>
-      <function name="static_method"
-                c:identifier="regress_test_obj_static_method">
-        <return-value transfer-ownership="none">
-          <type name="gdouble" c:type="double"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </function>
-      <function name="static_method_callback"
-                c:identifier="regress_test_obj_static_method_callback">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="callback"
-                     transfer-ownership="none"
-                     allow-none="1"
-                     scope="call">
-            <type name="TestCallback" c:type="RegressTestCallback"/>
-          </parameter>
-        </parameters>
-      </function>
-      <virtual-method name="matrix" invoker="do_matrix">
-        <doc xml:whitespace="preserve">This method is virtual.  Notably its name differs from the virtual
-slot name, which makes it useful for testing bindings handle this
-case.</doc>
-        <return-value transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </return-value>
-        <parameters>
-          <parameter name="somestr" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Meaningless string</doc>
-            <type name="utf8" c:type="char*"/>
-          </parameter>
-        </parameters>
-      </virtual-method>
-      <method name="do_matrix" c:identifier="regress_test_obj_do_matrix">
-        <doc xml:whitespace="preserve">This method is virtual.  Notably its name differs from the virtual
-slot name, which makes it useful for testing bindings handle this
-case.</doc>
-        <return-value transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </return-value>
-        <parameters>
-          <parameter name="somestr" transfer-ownership="none">
-            <doc xml:whitespace="preserve">Meaningless string</doc>
-            <type name="utf8" c:type="char*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="instance_method"
-              c:identifier="regress_test_obj_instance_method">
-        <return-value transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </return-value>
-      </method>
-      <method name="instance_method_callback"
-              c:identifier="regress_test_obj_instance_method_callback">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="callback"
-                     transfer-ownership="none"
-                     allow-none="1"
-                     scope="call">
-            <type name="TestCallback" c:type="RegressTestCallback"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="set_bare" c:identifier="regress_test_obj_set_bare">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="bare" transfer-ownership="none" allow-none="1">
-            <type name="GObject.Object" c:type="GObject*"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="torture_signature_0"
-              c:identifier="regress_test_obj_torture_signature_0">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-          <parameter name="y"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <type name="gdouble" c:type="double*"/>
-          </parameter>
-          <parameter name="z"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <type name="gint" c:type="int*"/>
-          </parameter>
-          <parameter name="foo" transfer-ownership="none">
-            <type name="utf8" c:type="char*"/>
-          </parameter>
-          <parameter name="q"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <type name="gint" c:type="int*"/>
-          </parameter>
-          <parameter name="m" transfer-ownership="none">
-            <type name="guint" c:type="guint"/>
-          </parameter>
-        </parameters>
-      </method>
-      <method name="torture_signature_1"
-              c:identifier="regress_test_obj_torture_signature_1"
-              throws="1">
-        <doc xml:whitespace="preserve">This function throws an error if m is odd.</doc>
-        <return-value transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-          <parameter name="y"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <type name="gdouble" c:type="double*"/>
-          </parameter>
-          <parameter name="z"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <type name="gint" c:type="int*"/>
-          </parameter>
-          <parameter name="foo" transfer-ownership="none">
-            <type name="utf8" c:type="char*"/>
-          </parameter>
-          <parameter name="q"
-                     direction="out"
-                     caller-allocates="0"
-                     transfer-ownership="full">
-            <type name="gint" c:type="int*"/>
-          </parameter>
-          <parameter name="m" transfer-ownership="none">
-            <type name="guint" c:type="guint"/>
-          </parameter>
-        </parameters>
-      </method>
-      <property name="bare" writable="1" transfer-ownership="none">
-        <type name="GObject.Object"/>
-      </property>
-      <property name="boxed" writable="1" transfer-ownership="none">
-        <type name="TestBoxed"/>
-      </property>
-      <property name="double" writable="1" transfer-ownership="none">
-        <type name="gdouble"/>
-      </property>
-      <property name="float" writable="1" transfer-ownership="none">
-        <type name="gfloat"/>
-      </property>
-      <property name="hash-table" writable="1" transfer-ownership="container">
-        <type name="GLib.HashTable">
-          <type name="utf8"/>
-          <type name="gint8"/>
-        </type>
-      </property>
-      <property name="int" writable="1" transfer-ownership="none">
-        <type name="gint"/>
-      </property>
-      <property name="list" writable="1" transfer-ownership="none">
-        <type name="GLib.List">
-          <type name="utf8"/>
-        </type>
-      </property>
-      <property name="string" writable="1" transfer-ownership="none">
-        <type name="utf8"/>
-      </property>
-      <field name="parent_instance">
-        <type name="GObject.Object" c:type="GObject"/>
-      </field>
-      <field name="bare">
-        <type name="GObject.Object" c:type="GObject*"/>
-      </field>
-      <field name="boxed">
-        <type name="TestBoxed" c:type="RegressTestBoxed*"/>
-      </field>
-      <field name="hash_table">
-        <type name="GLib.HashTable" c:type="GHashTable*">
-          <type name="gpointer" c:type="gpointer"/>
-          <type name="gpointer" c:type="gpointer"/>
-        </type>
-      </field>
-      <field name="list">
-        <type name="GLib.List" c:type="GList*">
-          <type name="gpointer" c:type="gpointer"/>
-        </type>
-      </field>
-      <field name="some_int8">
-        <type name="gint8" c:type="gint8"/>
-      </field>
-      <field name="some_float">
-        <type name="gfloat" c:type="float"/>
-      </field>
-      <field name="some_double">
-        <type name="gdouble" c:type="double"/>
-      </field>
-      <field name="string">
-        <type name="utf8" c:type="char*"/>
-      </field>
-      <glib:signal name="sig-with-array-prop">
-        <doc xml:whitespace="preserve">This test signal is like TelepathyGlib's</doc>
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-        <parameters>
-          <parameter name="arr" transfer-ownership="none">
-            <doc xml:whitespace="preserve">numbers</doc>
-            <array name="GLib.Array">
-              <type name="guint"/>
-            </array>
-          </parameter>
-        </parameters>
-      </glib:signal>
-      <glib:signal name="sig-with-hash-prop">
-        <doc xml:whitespace="preserve">This test signal is like TelepathyGlib's
-TpAccount::status-changed</doc>
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-        <parameters>
-          <parameter name="hash" transfer-ownership="none">
-            <type name="GLib.HashTable">
-              <type name="utf8"/>
-              <type name="GObject.Value"/>
-            </type>
-          </parameter>
-        </parameters>
-      </glib:signal>
-      <glib:signal name="sig-with-strv">
-        <doc xml:whitespace="preserve">Test GStrv as a param.</doc>
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-        <parameters>
-          <parameter name="strs" transfer-ownership="none">
-            <doc xml:whitespace="preserve">strings</doc>
-            <array>
-              <type name="utf8"/>
-            </array>
-          </parameter>
-        </parameters>
-      </glib:signal>
-      <glib:signal name="test">
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-      </glib:signal>
-      <glib:signal name="test-with-static-scope-arg">
-        <return-value transfer-ownership="none">
-          <type name="none"/>
-        </return-value>
-        <parameters>
-          <parameter name="object" transfer-ownership="none">
-            <type name="TestSimpleBoxedA"/>
-          </parameter>
-        </parameters>
-      </glib:signal>
-    </class>
-    <record name="TestObjClass"
-            c:type="RegressTestObjClass"
-            glib:is-gtype-struct-for="TestObj">
-      <field name="parent_class">
-        <type name="GObject.ObjectClass" c:type="GObjectClass"/>
-      </field>
-      <field name="matrix">
-        <callback name="matrix">
-          <return-value transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </return-value>
-          <parameters>
-            <parameter name="obj" transfer-ownership="none">
-              <type name="TestObj" c:type="RegressTestObj*"/>
-            </parameter>
-            <parameter name="somestr" transfer-ownership="none">
-              <doc xml:whitespace="preserve">Meaningless string</doc>
-              <type name="utf8" c:type="char*"/>
-            </parameter>
-          </parameters>
-        </callback>
-      </field>
-      <field name="test_signal">
-        <type name="guint" c:type="guint"/>
-      </field>
-      <field name="test_signal_with_static_scope_arg">
-        <type name="guint" c:type="guint"/>
-      </field>
-      <field name="_regress_reserved1" introspectable="0">
-        <callback name="_regress_reserved1">
-          <return-value transfer-ownership="none">
-            <type name="none" c:type="void"/>
-          </return-value>
-        </callback>
-      </field>
-      <field name="_regress_reserved2" introspectable="0">
-        <callback name="_regress_reserved2">
-          <return-value transfer-ownership="none">
-            <type name="none" c:type="void"/>
-          </return-value>
-        </callback>
-      </field>
-    </record>
-    <bitfield name="TestPrivateEnum" c:type="RegressTestPrivateEnum">
-      <member name="public_enum_before"
-              value="1"
-              c:identifier="REGRESS_TEST_PUBLIC_ENUM_BEFORE"/>
-      <member name="public_enum_after"
-              value="4"
-              c:identifier="REGRESS_TEST_PUBLIC_ENUM_AFTER"/>
-    </bitfield>
-    <record name="TestPrivateStruct" c:type="RegressTestPrivateStruct">
-      <field name="this_is_public_before" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="this_is_private" readable="0" private="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="this_is_public_after" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-    </record>
-    <record name="TestSimpleBoxedA"
-            c:type="RegressTestSimpleBoxedA"
-            glib:type-name="RegressTestSimpleBoxedA"
-            glib:get-type="regress_test_simple_boxed_a_get_type"
-            c:symbol-prefix="test_simple_boxed_a">
-      <field name="some_int" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="some_int8" writable="1">
-        <type name="gint8" c:type="gint8"/>
-      </field>
-      <field name="some_double" writable="1">
-        <type name="gdouble" c:type="gdouble"/>
-      </field>
-      <field name="some_enum" writable="1">
-        <type name="TestEnum" c:type="RegressTestEnum"/>
-      </field>
-      <method name="copy" c:identifier="regress_test_simple_boxed_a_copy">
-        <return-value transfer-ownership="full">
-          <type name="TestSimpleBoxedA" c:type="RegressTestSimpleBoxedA*"/>
-        </return-value>
-      </method>
-      <method name="equals" c:identifier="regress_test_simple_boxed_a_equals">
-        <return-value transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </return-value>
-        <parameters>
-          <parameter name="other_a" transfer-ownership="none">
-            <type name="TestSimpleBoxedA" c:type="RegressTestSimpleBoxedA*"/>
-          </parameter>
-        </parameters>
-      </method>
-    </record>
-    <record name="TestSimpleBoxedB"
-            c:type="RegressTestSimpleBoxedB"
-            glib:type-name="RegressTestSimpleBoxedB"
-            glib:get-type="regress_test_simple_boxed_b_get_type"
-            c:symbol-prefix="test_simple_boxed_b">
-      <field name="some_int8" writable="1">
-        <type name="gint8" c:type="gint8"/>
-      </field>
-      <field name="nested_a" writable="1">
-        <type name="TestSimpleBoxedA" c:type="RegressTestSimpleBoxedA"/>
-      </field>
-      <method name="copy" c:identifier="regress_test_simple_boxed_b_copy">
-        <return-value transfer-ownership="full">
-          <type name="TestSimpleBoxedB" c:type="RegressTestSimpleBoxedB*"/>
-        </return-value>
-      </method>
-    </record>
-    <callback name="TestSimpleCallback" c:type="RegressTestSimpleCallback">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-    </callback>
-    <record name="TestStructA" c:type="RegressTestStructA">
-      <field name="some_int" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="some_int8" writable="1">
-        <type name="gint8" c:type="gint8"/>
-      </field>
-      <field name="some_double" writable="1">
-        <type name="gdouble" c:type="gdouble"/>
-      </field>
-      <field name="some_enum" writable="1">
-        <type name="TestEnum" c:type="RegressTestEnum"/>
-      </field>
-      <method name="clone" c:identifier="regress_test_struct_a_clone">
-        <doc xml:whitespace="preserve">Make a copy of a RegressTestStructA</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="a_out"
-                     direction="out"
-                     caller-allocates="1"
-                     transfer-ownership="none">
-            <doc xml:whitespace="preserve">the cloned structure</doc>
-            <type name="TestStructA" c:type="RegressTestStructA*"/>
-          </parameter>
-        </parameters>
-      </method>
-    </record>
-    <record name="TestStructB" c:type="RegressTestStructB">
-      <field name="some_int8" writable="1">
-        <type name="gint8" c:type="gint8"/>
-      </field>
-      <field name="nested_a" writable="1">
-        <type name="TestStructA" c:type="RegressTestStructA"/>
-      </field>
-      <method name="clone" c:identifier="regress_test_struct_b_clone">
-        <doc xml:whitespace="preserve">Make a copy of a RegressTestStructB</doc>
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="b_out"
-                     direction="out"
-                     caller-allocates="1"
-                     transfer-ownership="none">
-            <doc xml:whitespace="preserve">the cloned structure</doc>
-            <type name="TestStructB" c:type="RegressTestStructB*"/>
-          </parameter>
-        </parameters>
-      </method>
-    </record>
-    <class name="TestSubObj"
-           c:symbol-prefix="test_sub_obj"
-           c:type="RegressTestSubObj"
-           parent="TestObj"
-           glib:type-name="RegressTestSubObj"
-           glib:get-type="regress_test_sub_obj_get_type"
-           glib:type-struct="TestSubObjClass">
-      <constructor name="new" c:identifier="regress_test_sub_obj_new">
-        <return-value transfer-ownership="full">
-          <type name="TestObj" c:type="RegressTestObj*"/>
-        </return-value>
-      </constructor>
-      <method name="instance_method"
-              c:identifier="regress_test_sub_obj_instance_method">
-        <return-value transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </return-value>
-      </method>
-      <method name="unset_bare" c:identifier="regress_test_sub_obj_unset_bare">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-      </method>
-      <field name="parent_instance">
-        <type name="TestObj" c:type="RegressTestObj"/>
-      </field>
-    </class>
-    <record name="TestSubObjClass"
-            c:type="RegressTestSubObjClass"
-            glib:is-gtype-struct-for="TestSubObj">
-      <field name="parent_class">
-        <type name="TestObjClass" c:type="RegressTestObjClass"/>
-      </field>
-    </record>
-    <class name="TestWi8021x"
-           c:symbol-prefix="test_wi_802_1x"
-           c:type="RegressTestWi8021x"
-           parent="GObject.Object"
-           glib:type-name="RegressTestWi8021x"
-           glib:get-type="regress_test_wi_802_1x_get_type"
-           glib:type-struct="TestWi8021xClass">
-      <constructor name="new" c:identifier="regress_test_wi_802_1x_new">
-        <return-value transfer-ownership="full">
-          <type name="TestWi8021x" c:type="RegressTestWi8021x*"/>
-        </return-value>
-      </constructor>
-      <function name="static_method"
-                c:identifier="regress_test_wi_802_1x_static_method">
-        <return-value transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </return-value>
-        <parameters>
-          <parameter name="x" transfer-ownership="none">
-            <type name="gint" c:type="int"/>
-          </parameter>
-        </parameters>
-      </function>
-      <method name="get_testbool"
-              c:identifier="regress_test_wi_802_1x_get_testbool">
-        <return-value transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </return-value>
-      </method>
-      <method name="set_testbool"
-              c:identifier="regress_test_wi_802_1x_set_testbool">
-        <return-value transfer-ownership="none">
-          <type name="none" c:type="void"/>
-        </return-value>
-        <parameters>
-          <parameter name="v" transfer-ownership="none">
-            <type name="gboolean" c:type="gboolean"/>
-          </parameter>
-        </parameters>
-      </method>
-      <property name="testbool" writable="1" transfer-ownership="none">
-        <type name="gboolean"/>
-      </property>
-      <field name="parent_instance">
-        <type name="GObject.Object" c:type="GObject"/>
-      </field>
-      <field name="testbool">
-        <type name="gboolean" c:type="gboolean"/>
-      </field>
-    </class>
-    <record name="TestWi8021xClass"
-            c:type="RegressTestWi8021xClass"
-            glib:is-gtype-struct-for="TestWi8021x">
-      <field name="parent_class">
-        <type name="GObject.ObjectClass" c:type="GObjectClass"/>
-      </field>
-    </record>
-    <constant name="UTF8_CONSTANT" value="const ♥ utf8">
-      <type name="utf8" c:type="gchar*"/>
-    </constant>
-    <record name="_TestStructC" c:type="_RegressTestStructC">
-      <field name="another_int" writable="1">
-        <type name="gint" c:type="gint"/>
-      </field>
-      <field name="obj" writable="1">
-        <type name="GObject.Object" c:type="GObject*"/>
-      </field>
-    </record>
-    <function name="func_obj_null_in" c:identifier="regress_func_obj_null_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="obj" transfer-ownership="none" allow-none="1">
-          <doc xml:whitespace="preserve">A #RegressTestObj</doc>
-          <type name="TestObj" c:type="RegressTestObj*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="global_get_flags_out"
-              c:identifier="regress_global_get_flags_out">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="v"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">A flags value</doc>
-          <type name="TestFlags" c:type="RegressTestFlags*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="introspectable_via_alias"
-              c:identifier="regress_introspectable_via_alias">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="data" transfer-ownership="none">
-          <type name="PtrArrayAlias" c:type="RegressPtrArrayAlias*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="not_introspectable_via_alias"
-              c:identifier="regress_not_introspectable_via_alias"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="ok" transfer-ownership="none">
-          <type name="VaListAlias" c:type="RegressVaListAlias"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="random_function_with_skipped_structure"
-              c:identifier="regress_random_function_with_skipped_structure"
-              introspectable="0">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="x" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="foo" transfer-ownership="none">
-          <type name="SkippedStructure" c:type="RegressSkippedStructure*"/>
-        </parameter>
-        <parameter name="v" transfer-ownership="none">
-          <type name="gdouble" c:type="double"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="set_abort_on_error"
-              c:identifier="regress_set_abort_on_error">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="abort_on_error" transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_fixed_size_int_in"
-              c:identifier="regress_test_array_fixed_size_int_in">
-      <return-value transfer-ownership="none">
-        <doc xml:whitespace="preserve">the sum of the items in @ints</doc>
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="ints" transfer-ownership="none">
-          <doc xml:whitespace="preserve">a list of 5 integers</doc>
-          <array c:type="int*" fixed-size="5">
-            <type name="gint"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_fixed_size_int_out"
-              c:identifier="regress_test_array_fixed_size_int_out">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="ints"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">a list of 5 integers ranging from 0 to 4</doc>
-          <array c:type="int**" fixed-size="5">
-            <type name="gint"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_fixed_size_int_return"
-              c:identifier="regress_test_array_fixed_size_int_return">
-      <return-value transfer-ownership="full">
-        <doc xml:whitespace="preserve">a list of 5 integers ranging from 0 to 4</doc>
-        <array c:type="int*" fixed-size="5">
-          <type name="gint"/>
-        </array>
-      </return-value>
-    </function>
-    <function name="test_array_gint16_in"
-              c:identifier="regress_test_array_gint16_in">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_ints" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="ints" transfer-ownership="none">
-          <doc xml:whitespace="preserve">List of ints</doc>
-          <array length="0" c:type="gint16*">
-            <type name="gint16"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_gint32_in"
-              c:identifier="regress_test_array_gint32_in">
-      <return-value transfer-ownership="none">
-        <type name="gint32" c:type="gint32"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_ints" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="ints" transfer-ownership="none">
-          <doc xml:whitespace="preserve">List of ints</doc>
-          <array length="0" c:type="gint32*">
-            <type name="gint32"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_gint64_in"
-              c:identifier="regress_test_array_gint64_in">
-      <return-value transfer-ownership="none">
-        <type name="gint64" c:type="gint64"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_ints" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="ints" transfer-ownership="none">
-          <doc xml:whitespace="preserve">List of ints</doc>
-          <array length="0" c:type="gint64*">
-            <type name="gint64"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_gint8_in"
-              c:identifier="regress_test_array_gint8_in">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_ints" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="ints" transfer-ownership="none">
-          <doc xml:whitespace="preserve">List of ints</doc>
-          <array length="0" c:type="gint8*">
-            <type name="gint8"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_gtype_in"
-              c:identifier="regress_test_array_gtype_in">
-      <return-value transfer-ownership="full">
-        <doc xml:whitespace="preserve">string representation of provided types</doc>
-        <type name="utf8" c:type="char*"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_types" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="types" transfer-ownership="none">
-          <doc xml:whitespace="preserve">List of types</doc>
-          <array length="0" c:type="GType*">
-            <type name="GType"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_int_full_out"
-              c:identifier="regress_test_array_int_full_out">
-      <return-value transfer-ownership="full">
-        <doc xml:whitespace="preserve">a new array of integers.</doc>
-        <array length="0" c:type="int*">
-          <type name="gint"/>
-        </array>
-      </return-value>
-      <parameters>
-        <parameter name="len"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">length of the returned array.</doc>
-          <type name="gint" c:type="int*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_int_in"
-              c:identifier="regress_test_array_int_in">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_ints" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-        <parameter name="ints" transfer-ownership="none">
-          <doc xml:whitespace="preserve">List of ints</doc>
-          <array length="0" c:type="int*">
-            <type name="gint"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_int_inout"
-              c:identifier="regress_test_array_int_inout">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_ints"
-                   direction="inout"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">the length of @ints</doc>
-          <type name="gint" c:type="int*"/>
-        </parameter>
-        <parameter name="ints"
-                   direction="inout"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">a list of integers whose items will be increased by 1, except the first that will be dropped</doc>
-          <array length="0" c:type="int**">
-            <type name="gint"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_int_none_out"
-              c:identifier="regress_test_array_int_none_out">
-      <return-value transfer-ownership="none">
-        <doc xml:whitespace="preserve">a static array of integers.</doc>
-        <array length="0" c:type="int*">
-          <type name="gint"/>
-        </array>
-      </return-value>
-      <parameters>
-        <parameter name="len"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">length of the returned array.</doc>
-          <type name="gint" c:type="int*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_int_null_in"
-              c:identifier="regress_test_array_int_null_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="arr" transfer-ownership="none" allow-none="1">
-          <array length="1" c:type="int*">
-            <type name="gint"/>
-          </array>
-        </parameter>
-        <parameter name="len" transfer-ownership="none">
-          <doc xml:whitespace="preserve">length</doc>
-          <type name="gint" c:type="int"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_int_null_out"
-              c:identifier="regress_test_array_int_null_out">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="arr"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full"
-                   allow-none="1">
-          <array length="1" c:type="int**">
-            <type name="gint"/>
-          </array>
-        </parameter>
-        <parameter name="len"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">length</doc>
-          <type name="gint" c:type="int*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_array_int_out"
-              c:identifier="regress_test_array_int_out">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="n_ints"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">the length of @ints</doc>
-          <type name="gint" c:type="int*"/>
-        </parameter>
-        <parameter name="ints"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <doc xml:whitespace="preserve">a list of 5 integers, from 0 to 4 in consecutive order</doc>
-          <array length="0" c:type="int**">
-            <type name="gint"/>
-          </array>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_async_ready_callback"
-              c:identifier="regress_test_async_ready_callback">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback" transfer-ownership="none" scope="async">
-          <type name="Gio.AsyncReadyCallback" c:type="GAsyncReadyCallback"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_boolean" c:identifier="regress_test_boolean">
-      <return-value transfer-ownership="none">
-        <type name="gboolean" c:type="gboolean"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_boolean_false"
-              c:identifier="regress_test_boolean_false">
-      <return-value transfer-ownership="none">
-        <type name="gboolean" c:type="gboolean"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_boolean_true"
-              c:identifier="regress_test_boolean_true">
-      <return-value transfer-ownership="none">
-        <type name="gboolean" c:type="gboolean"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="gboolean" c:type="gboolean"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_cairo_context_full_return"
-              c:identifier="regress_test_cairo_context_full_return">
-      <return-value transfer-ownership="full">
-        <type name="cairo.Context" c:type="cairo_t*"/>
-      </return-value>
-    </function>
-    <function name="test_cairo_context_none_in"
-              c:identifier="regress_test_cairo_context_none_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="context" transfer-ownership="none">
-          <type name="cairo.Context" c:type="cairo_t*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_cairo_surface_full_out"
-              c:identifier="regress_test_cairo_surface_full_out">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="surface"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full">
-          <type name="cairo.Surface" c:type="cairo_surface_t**"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_cairo_surface_full_return"
-              c:identifier="regress_test_cairo_surface_full_return">
-      <return-value transfer-ownership="full">
-        <type name="cairo.Surface" c:type="cairo_surface_t*"/>
-      </return-value>
-    </function>
-    <function name="test_cairo_surface_none_in"
-              c:identifier="regress_test_cairo_surface_none_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="surface" transfer-ownership="none">
-          <type name="cairo.Surface" c:type="cairo_surface_t*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_cairo_surface_none_return"
-              c:identifier="regress_test_cairo_surface_none_return">
-      <return-value transfer-ownership="none">
-        <type name="cairo.Surface" c:type="cairo_surface_t*"/>
-      </return-value>
-    </function>
-    <function name="test_callback" c:identifier="regress_test_callback">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback"
-                   transfer-ownership="none"
-                   allow-none="1"
-                   scope="call">
-          <type name="TestCallback" c:type="RegressTestCallback"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_callback_async"
-              c:identifier="regress_test_callback_async">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback"
-                   transfer-ownership="none"
-                   scope="async"
-                   closure="1">
-          <type name="TestCallbackUserData"
-                c:type="RegressTestCallbackUserData"/>
-        </parameter>
-        <parameter name="user_data" transfer-ownership="none">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_callback_destroy_notify"
-              c:identifier="regress_test_callback_destroy_notify">
-      <doc xml:whitespace="preserve">Notified - callback persists until a DestroyNotify delegate
-is invoked.</doc>
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback"
-                   transfer-ownership="none"
-                   scope="notified"
-                   closure="1"
-                   destroy="2">
-          <type name="TestCallbackUserData"
-                c:type="RegressTestCallbackUserData"/>
-        </parameter>
-        <parameter name="user_data" transfer-ownership="none">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-        <parameter name="notify" transfer-ownership="none" scope="async">
-          <type name="GLib.DestroyNotify" c:type="GDestroyNotify"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_callback_thaw_async"
-              c:identifier="regress_test_callback_thaw_async">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-    </function>
-    <function name="test_callback_thaw_notifications"
-              c:identifier="regress_test_callback_thaw_notifications">
-      <doc xml:whitespace="preserve">Invokes all callbacks installed by #test_callback_destroy_notify(),
-adding up their return values, and removes them, invoking the
-corresponding destroy notfications.</doc>
-      <return-value transfer-ownership="none">
-        <doc xml:whitespace="preserve">Sum of the return values of the invoked callbacks.</doc>
-        <type name="gint" c:type="int"/>
-      </return-value>
-    </function>
-    <function name="test_callback_user_data"
-              c:identifier="regress_test_callback_user_data">
-      <doc xml:whitespace="preserve">Call - callback parameter persists for the duration of the method
-call and can be released on return.</doc>
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="callback"
-                   transfer-ownership="none"
-                   scope="call"
-                   closure="1">
-          <type name="TestCallbackUserData"
-                c:type="RegressTestCallbackUserData"/>
-        </parameter>
-        <parameter name="user_data" transfer-ownership="none">
-          <type name="gpointer" c:type="gpointer"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_closure" c:identifier="regress_test_closure">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="closure" transfer-ownership="none">
-          <type name="GObject.Closure" c:type="GClosure*"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_closure_one_arg"
-              c:identifier="regress_test_closure_one_arg">
-      <return-value transfer-ownership="none">
-        <type name="gint" c:type="int"/>
-      </return-value>
-      <parameters>
-        <parameter name="closure" transfer-ownership="none">
-          <type name="GObject.Closure" c:type="GClosure*"/>
-        </parameter>
-        <parameter name="arg" transfer-ownership="none">
-          <type name="gint" c:type="int"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_date_in_gvalue"
-              c:identifier="regress_test_date_in_gvalue">
-      <return-value transfer-ownership="full">
-        <type name="GObject.Value" c:type="GValue*"/>
-      </return-value>
-    </function>
-    <function name="test_double" c:identifier="regress_test_double">
-      <return-value transfer-ownership="none">
-        <type name="gdouble" c:type="gdouble"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="gdouble" c:type="gdouble"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_enum_param" c:identifier="regress_test_enum_param">
-      <return-value transfer-ownership="none">
-        <type name="utf8" c:type="gchar*"/>
-      </return-value>
-      <parameters>
-        <parameter name="e" transfer-ownership="none">
-          <type name="TestEnum" c:type="RegressTestEnum"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_filename_return"
-              c:identifier="regress_test_filename_return">
-      <return-value transfer-ownership="full">
-        <doc xml:whitespace="preserve">list of strings</doc>
-        <type name="GLib.SList" c:type="GSList*">
-          <type name="filename"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_float" c:identifier="regress_test_float">
-      <return-value transfer-ownership="none">
-        <type name="gfloat" c:type="gfloat"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="gfloat" c:type="gfloat"/>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_ghash_container_return"
-              c:identifier="regress_test_ghash_container_return">
-      <return-value transfer-ownership="container">
-        <type name="GLib.HashTable" c:type="GHashTable*">
-          <type name="utf8"/>
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_ghash_everything_return"
-              c:identifier="regress_test_ghash_everything_return">
-      <return-value transfer-ownership="full">
-        <type name="GLib.HashTable" c:type="GHashTable*">
-          <type name="utf8"/>
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_ghash_nested_everything_return"
-              c:identifier="regress_test_ghash_nested_everything_return">
-      <doc xml:whitespace="preserve">Specify nested parameterized types directly with the (type ) annotation.</doc>
-      <return-value transfer-ownership="full">
-        <type name="GLib.HashTable">
-          <type name="utf8"/>
-          <type name="GLib.HashTable">
-            <type name="utf8"/>
-            <type name="utf8"/>
-          </type>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_ghash_nested_everything_return2"
-              c:identifier="regress_test_ghash_nested_everything_return2">
-      <doc xml:whitespace="preserve">element-type annotation.</doc>
-      <return-value transfer-ownership="full">
-        <type name="GLib.HashTable" c:type="GHashTable*">
-          <type name="utf8"/>
-          <type name="GLib.HashTable">
-            <type name="utf8"/>
-            <type name="utf8"/>
-          </type>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_ghash_nothing_in"
-              c:identifier="regress_test_ghash_nothing_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="GLib.HashTable" c:type="GHashTable*">
-            <type name="utf8"/>
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_ghash_nothing_in2"
-              c:identifier="regress_test_ghash_nothing_in2">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="GLib.HashTable" c:type="GHashTable*">
-            <type name="utf8"/>
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_ghash_nothing_return"
-              c:identifier="regress_test_ghash_nothing_return">
-      <return-value transfer-ownership="none">
-        <type name="GLib.HashTable" c:type="GHashTable*">
-          <type name="utf8"/>
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_ghash_nothing_return2"
-              c:identifier="regress_test_ghash_nothing_return2">
-      <return-value transfer-ownership="none">
-        <type name="GLib.HashTable" c:type="GHashTable*">
-          <type name="utf8"/>
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_ghash_null_in"
-              c:identifier="regress_test_ghash_null_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none" allow-none="1">
-          <type name="GLib.HashTable" c:type="GHashTable*">
-            <type name="utf8"/>
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_ghash_null_out"
-              c:identifier="regress_test_ghash_null_out">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="out"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full"
-                   allow-none="1">
-          <type name="GLib.HashTable" c:type="GHashTable**">
-            <type name="utf8"/>
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_ghash_null_return"
-              c:identifier="regress_test_ghash_null_return">
-      <return-value transfer-ownership="none">
-        <type name="GLib.HashTable" c:type="GHashTable*">
-          <type name="utf8"/>
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_glist_container_return"
-              c:identifier="regress_test_glist_container_return">
-      <return-value transfer-ownership="container">
-        <type name="GLib.List" c:type="GList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_glist_everything_return"
-              c:identifier="regress_test_glist_everything_return">
-      <return-value transfer-ownership="full">
-        <type name="GLib.List" c:type="GList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_glist_nothing_in"
-              c:identifier="regress_test_glist_nothing_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="GLib.List" c:type="GList*">
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_glist_nothing_in2"
-              c:identifier="regress_test_glist_nothing_in2">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="GLib.List" c:type="GList*">
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_glist_nothing_return"
-              c:identifier="regress_test_glist_nothing_return">
-      <return-value transfer-ownership="none">
-        <type name="GLib.List" c:type="GList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_glist_nothing_return2"
-              c:identifier="regress_test_glist_nothing_return2">
-      <return-value transfer-ownership="none">
-        <type name="GLib.List" c:type="GList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_glist_null_in"
-              c:identifier="regress_test_glist_null_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none" allow-none="1">
-          <type name="GLib.SList" c:type="GSList*">
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_glist_null_out"
-              c:identifier="regress_test_glist_null_out">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="out_list"
-                   direction="out"
-                   caller-allocates="0"
-                   transfer-ownership="full"
-                   allow-none="1">
-          <type name="GLib.SList" c:type="GSList**">
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_gslist_container_return"
-              c:identifier="regress_test_gslist_container_return">
-      <return-value transfer-ownership="container">
-        <type name="GLib.SList" c:type="GSList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_gslist_everything_return"
-              c:identifier="regress_test_gslist_everything_return">
-      <return-value transfer-ownership="full">
-        <type name="GLib.SList" c:type="GSList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_gslist_nothing_in"
-              c:identifier="regress_test_gslist_nothing_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="GLib.SList" c:type="GSList*">
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_gslist_nothing_in2"
-              c:identifier="regress_test_gslist_nothing_in2">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none">
-          <type name="GLib.SList" c:type="GSList*">
-            <type name="utf8"/>
-          </type>
-        </parameter>
-      </parameters>
-    </function>
-    <function name="test_gslist_nothing_return"
-              c:identifier="regress_test_gslist_nothing_return">
-      <return-value transfer-ownership="none">
-        <type name="GLib.SList" c:type="GSList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_gslist_nothing_return2"
-              c:identifier="regress_test_gslist_nothing_return2">
-      <return-value transfer-ownership="none">
-        <type name="GLib.SList" c:type="GSList*">
-          <type name="utf8"/>
-        </type>
-      </return-value>
-    </function>
-    <function name="test_gslist_null_in"
-              c:identifier="regress_test_gslist_null_in">
-      <return-value transfer-ownership="none">
-        <type name="none" c:type="void"/>
-      </return-value>
-      <parameters>
-        <parameter name="in" transfer-ownership="none" allow-none="1">
-          <type name="GLib.SList" c:type="GSList*">
-            <type name="utf8"/>
-          </type>