gobject-introspection 2.2.0-x86-mingw32 → 2.2.1-x86-mingw32

data/vendor/local/lib/gobject-introspection/giscanner/maintransformer.py

@@ -21,20 +21,17 @@ 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, TAG_VALUE, TAG_TRANSFER,
-                               TAG_STABILITY)
-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,
-                               OPT_CONSTRUCTOR, OPT_METHOD,
-                               OPT_TRANSFER_NONE, OPT_TRANSFER_FLOATING)
+from .annotationparser import (TAG_DEPRECATED, TAG_SINCE, TAG_STABILITY, TAG_RETURNS)
+from .annotationparser import (ANN_ALLOW_NONE, ANN_ARRAY, ANN_ATTRIBUTES, ANN_CLOSURE,
+                               ANN_CONSTRUCTOR, ANN_DESTROY, ANN_ELEMENT_TYPE, ANN_FOREIGN,
+                               ANN_GET_VALUE_FUNC, ANN_IN, ANN_INOUT, ANN_METHOD, ANN_OUT,
+                               ANN_REF_FUNC, ANN_RENAME_TO, ANN_SCOPE, ANN_SET_VALUE_FUNC,
+                               ANN_SKIP, ANN_TRANSFER, ANN_TYPE, ANN_UNREF_FUNC, ANN_VALUE,
+                               ANN_VFUNC, ANN_NULLABLE, ANN_OPTIONAL)
+from .annotationparser import (OPT_ARRAY_FIXED_SIZE, OPT_ARRAY_LENGTH, OPT_ARRAY_ZERO_TERMINATED,
+                               OPT_OUT_CALLEE_ALLOCATES, OPT_OUT_CALLER_ALLOCATES,
+                               OPT_TRANSFER_FLOATING, OPT_TRANSFER_NONE)
+
 from .utils import to_underscores_noprefix
 
 
@@ -110,6 +107,7 @@ class MainTransformer(object):
         if isinstance(node, (ast.Class, ast.Interface, ast.Record, ast.Union)):
             for field in node.fields:
                 if (field
+                and field.name is not None
                 and field.name.startswith('_')
                 and field.anonymous_node is not None
                 and isinstance(field.anonymous_node, ast.Callback)):
@@ -133,30 +131,43 @@ class MainTransformer(object):
 
         return param.argname
 
+    def _get_validate_field_name(self, parent, field_name, origin):
+        try:
+            field = parent.get_field(field_name)
+        except ValueError:
+            field = None
+        if field is None:
+            origin_name = 'field %s' % (origin.name, )
+            message.log_node(
+                message.FATAL, parent,
+                "can't find field %s referenced by %s of %r"
+                % (field_name, origin_name, parent.name))
+
+        return field.name
+
     def _apply_annotation_rename_to(self, node, chain, block):
         if not block:
             return
-        rename_to = block.tags.get(TAG_RENAME_TO)
+        rename_to = block.annotations.get(ANN_RENAME_TO)
         if not rename_to:
             return
-        rename_to = rename_to.value
+        rename_to = rename_to[0]
         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, ))
+                "Can't find symbol %r referenced by \"rename-to\" 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))
+                "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))
+                "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
@@ -216,10 +227,10 @@ class MainTransformer(object):
             for field in node.fields:
                 self._apply_annotations_field(node, block, field)
             name = self._get_annotation_name(node)
-            section_name = 'SECTION:' + name.lower()
+            section_name = 'SECTION:%s' % (name.lower(), )
             block = self._blocks.get(section_name)
-            if block:
-                node.doc = block.comment if block.comment else ''
+            if block and block.description:
+                node.doc = block.description
         if isinstance(node, (ast.Class, ast.Interface)):
             for prop in node.properties:
                 self._apply_annotations_property(node, prop)
@@ -228,29 +239,26 @@ class MainTransformer(object):
         if isinstance(node, ast.Class):
             block = self._get_block(node)
             if block:
-                tag = block.tags.get(TAG_UNREF_FUNC)
-                node.unref_func = tag.value if tag else None
-                tag = block.tags.get(TAG_REF_FUNC)
-                node.ref_func = tag.value if tag else None
-                tag = block.tags.get(TAG_SET_VALUE_FUNC)
-                node.set_value_func = tag.value if tag else None
-                tag = block.tags.get(TAG_GET_VALUE_FUNC)
-                node.get_value_func = tag.value if tag else None
+                annotation = block.annotations.get(ANN_UNREF_FUNC)
+                node.unref_func = annotation[0] if annotation else None
+                annotation = block.annotations.get(ANN_REF_FUNC)
+                node.ref_func = annotation[0] if annotation else None
+                annotation = block.annotations.get(ANN_SET_VALUE_FUNC)
+                node.set_value_func = annotation[0] if annotation else None
+                annotation = block.annotations.get(ANN_GET_VALUE_FUNC)
+                node.get_value_func = annotation[0] if annotation else None
         if isinstance(node, ast.Constant):
             self._apply_annotations_constant(node)
         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 _adjust_container_type(self, parent, node, annotations):
+        if ANN_ARRAY in annotations:
+            self._apply_annotations_array(parent, node, annotations)
+        elif ANN_ELEMENT_TYPE in annotations:
+            self._apply_annotations_element_type(parent, node, annotations)
 
         if isinstance(node.type, ast.Array):
-            self._check_array_element_type(node.type, options)
+            self._check_array_element_type(node.type, annotations)
 
     def _resolve(self, type_str, type_node=None, node=None, parent=None):
         def grab_one(type_str, resolver, top_combiner, combiner):
@@ -279,7 +287,10 @@ class MainTransformer(object):
                 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:
+            elif isinstance(base, ast.Array) and len(rest) == 1:
+                base.element_type = rest[0]
+                return base
+            elif isinstance(base, ast.Map) and len(rest) == 2:
                 return ast.Map(*rest)
             message.warn(
                 "Too many parameters in type specification %r" % (type_str, ))
@@ -319,18 +330,18 @@ class MainTransformer(object):
         block = self._blocks.get(func.symbol)
         if block:
             if isinstance(param, ast.Parameter):
-                tag = block.params.get(param.argname)
+                part = block.params.get(param.argname)
             elif isinstance(param, ast.Return):
-                tag = block.tags.get(TAG_RETURNS)
+                part = block.tags.get(TAG_RETURNS)
             else:
-                tag = None
+                part = None
 
-            if tag.position:
-                return tag.position
+            if part.position:
+                return part.position
 
         return block.position
 
-    def _check_array_element_type(self, array, options):
+    def _check_array_element_type(self, array, annotations):
         array_type = array.array_type
         element_type = array.element_type
 
@@ -341,7 +352,7 @@ class MainTransformer(object):
             if ((element_type in ast.BASIC_GIR_TYPES and not element_type in ast.POINTER_TYPES)
             or isinstance(element_type, (ast.Enum, ast.Bitfield))):
                 message.warn("invalid (element-type) for a GPtrArray, "
-                             "must be a pointer", options.position)
+                             "must be a pointer", annotations.position)
 
         # GByteArrays have (element-type) guint8 by default
         if array_type == ast.Array.GLIB_BYTEARRAY:
@@ -350,18 +361,12 @@ class MainTransformer(object):
             elif not element_type in [ast.TYPE_UINT8, ast.TYPE_INT8, ast.TYPE_CHAR]:
                 message.warn("invalid (element-type) for a GByteArray, "
                              "must be one of guint8, gint8 or gchar",
-                             options.position)
+                             annotations.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(),
+    def _apply_annotations_array(self, parent, node, annotations):
+        element_type_options = annotations.get(ANN_ELEMENT_TYPE)
+        if element_type_options:
+            element_type_node = self._resolve(element_type_options[0],
                                               node.type, node, parent)
         elif isinstance(node.type, ast.Array):
             element_type_node = node.type.element_type
@@ -370,82 +375,82 @@ class MainTransformer(object):
             # and no (element-type) means array of Foo
             element_type_node = node.type.clone()
             # The element's ctype is the array's dereferenced
-            if element_type_node.ctype is not None and \
-                    element_type_node.ctype.endswith('*'):
+            if element_type_node.ctype is not None and element_type_node.ctype.endswith('*'):
                 element_type_node.ctype = element_type_node.ctype[:-1]
 
         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'
+
+        array_options = annotations.get(ANN_ARRAY)
+        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_options:
+            container_type.zeroterminated = array_options.get(OPT_ARRAY_ZERO_TERMINATED) == '1'
         else:
             container_type.zeroterminated = False
-        length = array_values.get(OPT_ARRAY_LENGTH)
-        if length is not None:
-            paramname = self._get_validate_parameter_name(parent, length, node)
+
+        length = array_options.get(OPT_ARRAY_LENGTH)
+        if length:
+            if isinstance(parent, ast.Compound):
+                paramname = self._get_validate_field_name(parent, length, node)
+            else:
+                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
             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)
+                container_type.length_param_name = paramname
+        fixed = array_options.get(OPT_ARRAY_FIXED_SIZE)
         if fixed:
             try:
                 container_type.size = int(fixed)
-            except ValueError:
+            except (TypeError, 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)
+    def _apply_annotations_element_type(self, parent, node, annotations):
+        element_type_options = annotations.get(ANN_ELEMENT_TYPE)
+        if element_type_options is None:
             return
 
         if isinstance(node.type, ast.List):
-            if element_type_opt.length() != 1:
+            if len(element_type_options) != 1:
                 message.warn(
-                    'element-type annotation for a list must have exactly '
-                    'one option, not %d options' % (element_type_opt.length(), ),
-                    options.position)
+                    '"element-type" annotation for a list must have exactly '
+                    'one option, not %d options' % (len(element_type_options), ),
+                    annotations.position)
                 return
-            node.type.element_type = self._resolve(element_type_opt.one(),
+            node.type.element_type = self._resolve(element_type_options[0],
                                                    node.type, node, parent)
         elif isinstance(node.type, ast.Map):
-            if element_type_opt.length() != 2:
+            if len(element_type_options) != 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)
+                    '"element-type" annotation for a hash table must have exactly '
+                    'two options, not %d option(s)' % (len(element_type_options), ),
+                    annotations.position)
                 return
-            element_type = element_type_opt.flat()
-            node.type.key_type = self._resolve(element_type[0],
+            node.type.key_type = self._resolve(element_type_options[0],
                                                node.type, node, parent)
-            node.type.value_type = self._resolve(element_type[1],
+            node.type.value_type = self._resolve(element_type_options[1],
                                                  node.type, node, parent)
         elif isinstance(node.type, ast.Array):
-            if element_type_opt.length() != 1:
+            if len(element_type_options) != 1:
                 message.warn(
-                    'element-type annotation for an array must have exactly '
-                    'one option, not %d options' % (element_type_opt.length(), ),
-                    options.position)
+                    '"element-type" annotation for an array must have exactly '
+                    'one option, not %d options' % (len(element_type_options), ),
+                    annotations.position)
                 return
-            node.type.element_type = self._resolve(element_type_opt.one(),
+            node.type.element_type = self._resolve(element_type_options[0],
                                                    node.type, node, parent)
         else:
-            message.warn_node(parent,
-                "Unknown container %r for element-type annotation" % (node.type, ))
+            message.warn(
+                "Unknown container %r for element-type annotation" % (node.type, ),
+                annotations.position)
 
     def _get_transfer_default_param(self, parent, node):
         if node.direction in [ast.PARAM_DIRECTION_INOUT,
@@ -529,23 +534,22 @@ class MainTransformer(object):
             raise AssertionError(node)
 
     def _apply_annotations_param_ret_common(self, parent, node, tag):
-        options = getattr(tag, 'options', {})
+        annotations = tag.annotations if tag else {}
 
-        param_type = options.get(OPT_TYPE)
-        if param_type:
-            node.type = self._resolve_toplevel(param_type.one(),
+        type_annotation = annotations.get(ANN_TYPE)
+        if type_annotation:
+            node.type = self._resolve_toplevel(type_annotation[0],
                                                node.type, node, parent)
 
         caller_allocates = False
         annotated_direction = None
-        if (OPT_INOUT in options or OPT_INOUT_ALT in options):
+        if ANN_INOUT in annotations:
             annotated_direction = ast.PARAM_DIRECTION_INOUT
-        elif OPT_OUT in options:
-            subtype = options[OPT_OUT]
-            if subtype is not None:
-                subtype = subtype.one()
+        elif ANN_OUT in annotations:
             annotated_direction = ast.PARAM_DIRECTION_OUT
-            if subtype in (None, ''):
+
+            options = annotations[ANN_OUT]
+            if len(options) == 0:
                 if node.type.target_giname and node.type.ctype:
                     target = self._transformer.lookup_giname(node.type.target_giname)
                     target = self._transformer.resolve_aliases(target)
@@ -554,11 +558,13 @@ class MainTransformer(object):
                     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:
+            else:
+                option = options[0]
+                if option == OPT_OUT_CALLER_ALLOCATES:
+                    caller_allocates = True
+                elif option == OPT_OUT_CALLEE_ALLOCATES:
+                    caller_allocates = False
+        elif ANN_IN in annotations:
             annotated_direction = ast.PARAM_DIRECTION_IN
 
         if (annotated_direction is not None) and (annotated_direction != node.direction):
@@ -567,79 +573,89 @@ class MainTransformer(object):
             # 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:
-            transfer = transfer_tag.one()
+        transfer_annotation = annotations.get(ANN_TRANSFER)
+        if transfer_annotation and len(transfer_annotation) == 1:
+            transfer = transfer_annotation[0]
             if transfer == OPT_TRANSFER_FLOATING:
                 transfer = OPT_TRANSFER_NONE
             node.transfer = transfer
 
-        self._adjust_container_type(parent, node, options)
+        self._adjust_container_type(parent, node, annotations)
+
+        if ANN_NULLABLE in annotations:
+            node.nullable = True
 
-        if (OPT_ALLOW_NONE in options
-        or node.type.target_giname == 'Gio.AsyncReadyCallback'
-        or node.type.target_giname == 'Gio.Cancellable'):
-            node.allow_none = True
+        if ANN_OPTIONAL in annotations:
+            node.optional = True
 
-        if tag is not None and tag.comment is not None:
-            node.doc = tag.comment
+        if ANN_ALLOW_NONE in annotations:
+            if node.direction == ast.PARAM_DIRECTION_OUT:
+                node.optional = True
+            else:
+                node.nullable = True
+
+        if (node.direction != ast.PARAM_DIRECTION_OUT and
+                (node.type.target_giname == 'Gio.AsyncReadyCallback' or
+                 node.type.target_giname == 'Gio.Cancellable')):
+            node.nullable = True
 
-        if OPT_SKIP in options:
+        if tag and tag.description:
+            node.doc = tag.description
+
+        if ANN_SKIP in annotations:
             node.skip = True
 
-        if options:
-            for attribute in options.getall(OPT_ATTRIBUTE):
-                node.attributes.append(attribute.flat())
+        if annotations:
+            attributes_annotation = annotations.get(ANN_ATTRIBUTES)
+            if attributes_annotation is not None:
+                for key, value in attributes_annotation.items():
+                    if value:
+                        node.attributes[key] = value
 
     def _apply_annotations_annotated(self, node, block):
         if block is None:
             return
 
-        node.doc = block.comment if block.comment else ''
+        if block.description:
+            node.doc = block.description
 
         since_tag = block.tags.get(TAG_SINCE)
         if since_tag is not None:
-            node.version = since_tag.value
+            if since_tag.value:
+                node.version = since_tag.value
+            if since_tag.description:
+                node.version_doc = since_tag.description
 
         deprecated_tag = block.tags.get(TAG_DEPRECATED)
         if deprecated_tag is not None:
-            value = deprecated_tag.value
-            if ': ' in value:
-                colon = value.find(': ')
-                version = value[:colon]
-                desc = value[colon + 2:]
-            else:
-                desc = value
-                version = None
-            node.deprecated = desc
-            if version is not None:
-                node.deprecated_version = version
+            if deprecated_tag.value:
+                node.deprecated = deprecated_tag.value
+            if deprecated_tag.description:
+                node.deprecated_doc = deprecated_tag.description
 
         stability_tag = block.tags.get(TAG_STABILITY)
         if stability_tag is not None:
-            stability = stability_tag.value.capitalize()
-            if stability in ["Stable", "Unstable", "Private", "Internal"]:
-                node.stability = stability
-            else:
-                message.warn('unknown value "%s" for Stability tag' % (
-                    stability_tag.value), stability_tag.position)
-
-        annos_tag = block.tags.get(TAG_ATTRIBUTES)
-        if annos_tag is not None:
-            for key, value in annos_tag.options.items():
+            if stability_tag.value:
+                node.stability = stability_tag.value
+            if stability_tag.description:
+                node.stability_doc = stability_tag.description
+
+        attributes_annotation = block.annotations.get(ANN_ATTRIBUTES)
+        if attributes_annotation is not None:
+            for key, value in attributes_annotation.items():
                 if value:
-                    node.attributes.append((key, value.one()))
+                    node.attributes[key] = value
 
-        if OPT_SKIP in block.options:
+        if ANN_SKIP in block.annotations:
             node.skip = True
 
-        if OPT_FOREIGN in block.options:
+        if ANN_FOREIGN in block.annotations:
             node.foreign = True
 
-        if OPT_CONSTRUCTOR in block.options and isinstance(node, ast.Function):
+        if ANN_CONSTRUCTOR in block.annotations and isinstance(node, ast.Function):
             node.is_constructor = True
 
-        if OPT_METHOD in block.options:
+        if ANN_METHOD in block.annotations:
             node.is_method = True
 
     def _apply_annotations_alias(self, node, chain):
@@ -647,20 +663,18 @@ class MainTransformer(object):
         self._apply_annotations_annotated(node, block)
 
     def _apply_annotations_param(self, parent, param, tag):
-        if tag:
-            options = tag.options
-        else:
-            options = {}
+        annotations = tag.annotations if tag else {}
+
         if isinstance(parent, (ast.Function, ast.VFunction)):
-            scope = options.get(OPT_SCOPE)
-            if scope and scope.length() == 1:
-                param.scope = scope.one()
+            scope_annotation = annotations.get(ANN_SCOPE)
+            if scope_annotation and len(scope_annotation) == 1:
+                param.scope = scope_annotation[0]
                 param.transfer = ast.PARAM_TRANSFER_NONE
 
-            destroy = options.get(OPT_DESTROY)
-            if destroy:
+            destroy_annotation = annotations.get(ANN_DESTROY)
+            if destroy_annotation:
                 param.destroy_name = self._get_validate_parameter_name(parent,
-                                                                       destroy.one(),
+                                                                       destroy_annotation[0],
                                                                        param)
                 if param.destroy_name is not None:
                     param.scope = ast.PARAM_SCOPE_NOTIFIED
@@ -669,13 +683,14 @@ class MainTransformer(object):
                     # 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:
+
+            closure_annotation = annotations.get(ANN_CLOSURE)
+            if closure_annotation and len(closure_annotation) == 1:
                 param.closure_name = self._get_validate_parameter_name(parent,
-                                                                       closure.one(),
-                                                                       param)
+                                                                   closure_annotation[0],
+                                                                   param)
         elif isinstance(parent, ast.Callback):
-            if OPT_CLOSURE in options:
+            if ANN_CLOSURE in annotations:
                 # 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
@@ -694,13 +709,19 @@ class MainTransformer(object):
     def _apply_annotations_params(self, parent, params, block):
         declparams = set([])
         if parent.instance_parameter:
+            if block:
+                doc_param = block.params.get(parent.instance_parameter.argname)
+            else:
+                doc_param = None
+            self._apply_annotations_param(parent, parent.instance_parameter, doc_param)
             declparams.add(parent.instance_parameter.argname)
+
         for param in params:
             if block:
-                tag = block.params.get(param.argname)
+                doc_param = block.params.get(param.argname)
             else:
-                tag = None
-            self._apply_annotations_param(parent, param, tag)
+                doc_param = None
+            self._apply_annotations_param(parent, param, doc_param)
             declparams.add(param.argname)
 
         if not block:
@@ -711,9 +732,6 @@ class MainTransformer(object):
         unused = declparams - docparams
 
         for doc_name in unknown:
-            # Skip varargs, see #629759
-            if doc_name.lower() in ['...', 'varargs', TAG_RETURNS]:
-                continue
             if len(unused) == 0:
                 text = ''
             elif len(unused) == 1:
@@ -722,45 +740,30 @@ class MainTransformer(object):
             else:
                 text = ', should be one of %s' % (', '.join(repr(p) for p in unused), )
 
-            tag = block.params.get(doc_name)
-            message.warn(
-                '%s: unknown parameter %r in documentation comment%s' % (
-                block.name, doc_name, text),
-                tag.position)
+            param = block.params.get(doc_name)
+            message.warn('%s: unknown parameter %r in documentation '
+                         'comment%s' % (block.name, doc_name, text),
+                param.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.params.get(field.name)
         if not tag:
             return
-        t = tag.options.get(OPT_TYPE)
-        if t:
-            field.type = self._transformer.create_type_from_user_string(t.one())
-
+        type_annotation = tag.annotations.get(ANN_TYPE)
+        if type_annotation:
+            field.type = self._transformer.create_type_from_user_string(type_annotation[0])
+        field.doc = tag.description
         try:
-            self._adjust_container_type(parent, field, tag.options)
-        except AttributeError:
-            pass
+            self._adjust_container_type(parent, field, tag.annotations)
+        except AttributeError as ex:
+            print ex
 
     def _apply_annotations_property(self, parent, prop):
         prefix = self._get_annotation_name(parent)
@@ -768,17 +771,17 @@ class MainTransformer(object):
         self._apply_annotations_annotated(prop, block)
         if not block:
             return
-        transfer_tag = block.tags.get(TAG_TRANSFER)
-        if transfer_tag is not None:
-            transfer = transfer_tag.value
+        transfer_annotation = block.annotations.get(ANN_TRANSFER)
+        if transfer_annotation is not None:
+            transfer = transfer_annotation[0]
             if transfer == OPT_TRANSFER_FLOATING:
                 transfer = OPT_TRANSFER_NONE
             prop.transfer = transfer
         else:
             prop.transfer = self._get_transfer_default(parent, prop)
-        type_tag = block.tags.get(TAG_TYPE)
-        if type_tag:
-            prop.type = self._resolve_toplevel(type_tag.value, prop.type, prop, parent)
+        type_annotation = block.annotations.get(ANN_TYPE)
+        if type_annotation:
+            prop.type = self._resolve_toplevel(type_annotation[0], prop.type, prop, parent)
 
     def _apply_annotations_signal(self, parent, signal):
         names = []
@@ -806,11 +809,11 @@ class MainTransformer(object):
         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_toplevel(param_type.one(), param.type,
-                                                        param, parent)
+                if tag:
+                    type_annotation = tag.annotations.get(ANN_TYPE)
+                    if type_annotation:
+                        param.type = self._resolve_toplevel(type_annotation[0], param.type,
+                                                            param, parent)
             else:
                 tag = None
             self._apply_annotations_param(signal, param, tag)
@@ -823,18 +826,18 @@ class MainTransformer(object):
 
         self._apply_annotations_annotated(node, block)
 
-        tag = block.tags.get(TAG_VALUE)
-        if tag:
-            node.value = tag.value
+        value_annotation = block.annotations.get(ANN_VALUE)
+        if value_annotation:
+            node.value = value_annotation[0]
 
     def _apply_annotations_enum_members(self, node, block):
         if block is None:
             return
 
         for m in node.members:
-            tag = block.params.get(m.symbol, None)
-            if tag is not None:
-                m.doc = tag.comment
+            param = block.params.get(m.symbol, None)
+            if param and param.description:
+                m.doc = param.description
 
     def _pass_read_annotations2(self, node, chain):
         if isinstance(node, ast.Function):
@@ -845,9 +848,9 @@ class MainTransformer(object):
             # Handle virtual invokers
             parent = chain[-1] if chain else None
             if (block and parent):
-                virtual_annotation = block.tags.get(TAG_VFUNC)
+                virtual_annotation = block.annotations.get(ANN_VFUNC)
                 if virtual_annotation:
-                    invoker_name = virtual_annotation.value
+                    invoker_name = virtual_annotation[0]
                     matched = False
                     for vfunc in parent.virtual_methods:
                         if vfunc.name == invoker_name:
@@ -859,7 +862,7 @@ class MainTransformer(object):
                     if not matched:
                         message.warn_node(node,
                             "Virtual slot %r not found for %r annotation" % (invoker_name,
-                                                                             TAG_VFUNC))
+                                                                             ANN_VFUNC))
         return True
 
     def _resolve_and_filter_type_list(self, typelist):
@@ -1035,15 +1038,35 @@ method or constructor of some type."""
         uscored_prefix = self._get_uscored_prefix(func, subsymbol)
         target = self._transformer.lookup_typenode(func.parameters[0].type)
 
-        func.instance_parameter = func.parameters.pop(0)
-        self._namespace.float(func)
-
-        if not func.is_method:
+        if not func.is_method and not subsymbol.startswith(uscored_prefix + '_'):
+            # Uh oh! This function starts with uscored_prefix, but not
+            # uscored_prefix + '_', so if we split, we're splitting on something
+            # which is not _
+            # Examples of this are g_resources_register() (splits as
+            # g_resource + _register) and gdk_events_get_angle() (splits as
+            # gdk_event + _get_angle).
+            # As the C name suggests, these are not methods, but for backward
+            # compatibility reasons we need to create a method with the old
+            # name, and a moved-to annotation pointing to the new variant.
+
+            newfunc = func.clone()
+            newfunc.moved_to = func.name
+            newfunc.instance_parameter = newfunc.parameters.pop(0)
             subsym_idx = func.symbol.find(subsymbol)
-            func.name = func.symbol[(subsym_idx + len(uscored_prefix) + 1):]
-            func.is_method = True
+            newfunc.name = func.symbol[(subsym_idx + len(uscored_prefix) + 1):]
+            newfunc.is_method = True
+
+            target.methods.append(newfunc)
+        else:
+            func.instance_parameter = func.parameters.pop(0)
+            self._namespace.float(func)
 
-        target.methods.append(func)
+            if not func.is_method:
+                subsym_idx = func.symbol.find(subsymbol)
+                func.name = func.symbol[(subsym_idx + len(uscored_prefix) + 1):]
+                func.is_method = True
+
+            target.methods.append(func)
 
     def _get_uscored_prefix(self, func, subsymbol):
         # Here we check both the c_symbol_prefix and (if that fails),
@@ -1201,20 +1224,20 @@ method or constructor of some type."""
                     parent = None
                 if parent is None:
                     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 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)))
+                                  "Constructor return type mismatch symbol=%r "
+                                  "constructed=%r return=%r" %
+                                  (func.symbol,
+                                   str(origin_node.create_type()),
+                                   str(func.retval.type)))
                 return False
 
         return True
@@ -1237,16 +1260,24 @@ method or constructor of some type."""
                 field.writable = False
 
         for field in class_struct.fields:
-            if not isinstance(field.anonymous_node, ast.Callback):
+            callback = None
+
+            if isinstance(field.anonymous_node, ast.Callback):
+                callback = field.anonymous_node
+            elif field.type is not None:
+                callback = self._transformer.lookup_typenode(field.type)
+                if not isinstance(callback, ast.Callback):
+                    continue
+            else:
                 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 = ast.VFunction.from_callback(field.name, callback)
             vfunc.instance_parameter = callback.parameters[0]
             vfunc.inherit_file_positions(callback)
 
@@ -1266,7 +1297,7 @@ method or constructor of some type."""
                     continue
                 if len(method.parameters) != len(vfunc.parameters):
                     continue
-                for i in xrange(len(method.parameters)):
+                for i in range(len(method.parameters)):
                     m_type = method.parameters[i].type
                     v_type = vfunc.parameters[i].type
                     if m_type != v_type: