gobject-introspection 3.0.7-x64-mingw32 → 3.0.8-x64-mingw32

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

@@ -18,6 +18,11 @@
 # Boston, MA 02111-1307, USA.
 #
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
 import os
 import sys
 import tempfile
@@ -84,12 +89,12 @@ class GDumpParser(object):
         """
 
         # First pass: parsing
-        for node in self._namespace.itervalues():
+        for node in self._namespace.values():
             if isinstance(node, ast.Function):
                 self._initparse_function(node)
 
         if self._namespace.name == 'GObject' or self._namespace.name == 'GLib':
-            for node in self._namespace.itervalues():
+            for node in self._namespace.values():
                 if isinstance(node, ast.Record):
                     self._initparse_gobject_record(node)
 
@@ -116,16 +121,16 @@ class GDumpParser(object):
                 self._introspect_type(child)
 
         # Pair up boxed types and class records
-        for name, boxed in self._boxed_types.iteritems():
+        for name, boxed in self._boxed_types.items():
             self._pair_boxed_type(boxed)
-        for node in self._namespace.itervalues():
+        for node in self._namespace.values():
             if isinstance(node, (ast.Class, ast.Interface)):
                 self._find_class_record(node)
 
         # Clear the _get_type functions out of the namespace;
         # Anyone who wants them can get them from the ast.Class/Interface/Boxed
         to_remove = []
-        for name, node in self._namespace.iteritems():
+        for name, node in self._namespace.items():
             if isinstance(node, ast.Registered) and node.get_type is not None:
                 get_type_name = node.get_type
                 if get_type_name == 'intern':
@@ -145,19 +150,24 @@ class GDumpParser(object):
         """Load the library (or executable), returning an XML
 blob containing data gleaned from GObject's primitive introspection."""
         in_path = os.path.join(self._binary.tmpdir, 'functions.txt')
-        f = open(in_path, 'w')
-        for func in self._get_type_functions:
-            f.write('get-type:')
-            f.write(func)
-            f.write('\n')
-        for func in self._error_quark_functions:
-            f.write('error-quark:')
-            f.write(func)
-            f.write('\n')
-        f.close()
+        with open(in_path, 'w') as f:
+            for func in self._get_type_functions:
+                f.write('get-type:')
+                f.write(func)
+                f.write('\n')
+            for func in self._error_quark_functions:
+                f.write('error-quark:')
+                f.write(func)
+                f.write('\n')
         out_path = os.path.join(self._binary.tmpdir, 'dump.xml')
 
         args = []
+
+        # Prepend the launcher command and arguments, if defined
+        launcher = os.environ.get('GI_CROSS_LAUNCHER')
+        if launcher:
+            args.extend(launcher.split())
+
         args.extend(self._binary.args)
         args.append('--introspect-dump=%s,%s' % (in_path, out_path))
 
@@ -203,7 +213,7 @@ blob containing data gleaned from GObject's primitive introspection."""
 
     def _initparse_gobject_record(self, record):
         if (record.name.startswith('ParamSpec')
-        and not record.name in ('ParamSpecPool', 'ParamSpecClass', 'ParamSpecTypeInfo')):
+        and record.name not in ('ParamSpecPool', 'ParamSpecClass', 'ParamSpecTypeInfo')):
             parent = None
             if record.name != 'ParamSpec':
                 parent = ast.Type(target_giname='GObject.ParamSpec')
@@ -297,7 +307,7 @@ blob containing data gleaned from GObject's primitive introspection."""
         (ns, name) = self._transformer.split_csymbol(get_type)
         assert ns is self._namespace
         if name in ('get_type', '_get_gtype'):
-            message.fatal("""The GObject name %r isn't compatible
+            message.fatal("""The GObject name '%s' isn't compatible
 with the configured identifier prefixes:
   %r
 The class would have no name.  Most likely you want to specify a
@@ -350,7 +360,7 @@ different --identifier-prefix.""" % (xmlnode.attrib['name'], self._namespace.ide
         if isinstance(record, ast.Record):
             node.ctype = record.ctype
         else:
-            message.warn_node(node, "Couldn't find associated structure for '%r'" % (node.name, ))
+            message.warn_node(node, "Couldn't find associated structure for '%s'" % (node.name, ))
 
         # GtkFileChooserEmbed is an example of a private interface, we
         # just filter them out
@@ -359,7 +369,7 @@ different --identifier-prefix.""" % (xmlnode.attrib['name'], self._namespace.ide
         else:
             self._namespace.append(node, replace=True)
 
-    ## WORKAROUND ##
+    # WORKAROUND
     # https://bugzilla.gnome.org/show_bug.cgi?id=550616
     def _introspect_boxed_gstreamer_workaround(self, xmlnode):
         node = ast.Boxed('ParamSpecMiniObject', gtype_name='GParamSpecMiniObject',
@@ -439,8 +449,8 @@ different --identifier-prefix.""" % (xmlnode.attrib['name'], self._namespace.ide
     def _parse_parents(self, xmlnode, node):
         parents_str = xmlnode.attrib.get('parents', '')
         if parents_str != '':
-            parent_types = map(lambda s: ast.Type.create_from_gtype_name(s),
-                               parents_str.split(','))
+            parent_types = list(map(lambda s: ast.Type.create_from_gtype_name(s),
+                                    parents_str.split(',')))
         else:
             parent_types = []
         node.parent_chain = parent_types

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

@@ -18,6 +18,11 @@
 # Boston, MA 02111-1307, USA.
 #
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
 import os
 
 from xml.etree.cElementTree import parse
@@ -313,7 +318,7 @@ class GIRParser(object):
             raise ValueError('node %r has no return-value' % (name, ))
         transfer = returnnode.attrib.get('transfer-ownership')
         nullable = returnnode.attrib.get('nullable') == '1'
-        retval = ast.Return(self._parse_type(returnnode), nullable, transfer)
+        retval = ast.Return(self._parse_type(returnnode), nullable, False, transfer)
         self._parse_generic_attribs(returnnode, retval)
         parameters = []
 
@@ -366,6 +371,9 @@ class GIRParser(object):
 
         self._parse_type_array_length(parameters, returnnode, retval.type)
 
+        # Re-set the function's parameters to notify it of changes to the list.
+        func.parameters = parameters
+
         self._parse_generic_attribs(node, func)
 
         self._namespace.track(func)
@@ -455,8 +463,8 @@ class GIRParser(object):
                 return ast.Type(ctype=ctype)
             elif name in ['GLib.List', 'GLib.SList']:
                 subchild = self._find_first_child(typenode,
-                                                  map(_corens, ('callback', 'array',
-                                                                'varargs', 'type')))
+                                                  list(map(_corens, ('callback', 'array',
+                                                                '    varargs', 'type'))))
                 if subchild is not None:
                     element_type = self._parse_type(typenode)
                 else:
@@ -464,7 +472,7 @@ class GIRParser(object):
                 return ast.List(name, element_type, ctype=ctype)
             elif name == 'GLib.HashTable':
                 subchildren = self._find_children(typenode, _corens('type'))
-                subchildren_types = map(self._parse_type_simple, subchildren)
+                subchildren_types = list(map(self._parse_type_simple, subchildren))
                 while len(subchildren_types) < 2:
                     subchildren_types.append(ast.TYPE_ANY)
                 return ast.Map(subchildren_types[0], subchildren_types[1], ctype=ctype)
@@ -489,7 +497,7 @@ class GIRParser(object):
         lenidx = typenode.attrib.get('length')
         if lenidx is not None:
             idx = int(lenidx)
-            assert idx < len(siblings), "%r %d >= %d" % (parent, idx, len(siblings))
+            assert idx < len(siblings), "%r %d >= %d" % (siblings, idx, len(siblings))
             if isinstance(siblings[idx], ast.Field):
                 typeval.length_param_name = siblings[idx].name
             else:

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

@@ -20,6 +20,10 @@
 #
 
 from __future__ import with_statement
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 
 from . import ast
 from .xmlwriter import XMLWriter
@@ -78,17 +82,12 @@ class GIRWriter(XMLWriter):
             # We define a custom sorting function here because
             # we want aliases to be first.  They're a bit
             # special because the typelib compiler expands them.
-            def nscmp(a, b):
-                if isinstance(a, ast.Alias):
-                    if isinstance(b, ast.Alias):
-                        return cmp(a.name, b.name)
-                    else:
-                        return -1
-                elif isinstance(b, ast.Alias):
-                    return 1
+            def nscmp(val):
+                if isinstance(val, ast.Alias):
+                    return 0, val
                 else:
-                    return cmp(a, b)
-            for node in sorted(namespace.itervalues(), cmp=nscmp):
+                    return 1, val
+            for node in sorted(namespace.values(), key=nscmp):
                 self._write_node(node)
 
     def _write_node(self, node):
@@ -116,7 +115,7 @@ class GIRWriter(XMLWriter):
         elif isinstance(node, ast.Constant):
             self._write_constant(node)
         else:
-            print 'WRITER: Unhandled node', node
+            print('WRITER: Unhandled node', node)
 
     def _append_version(self, node, attrs):
         if node.version:
@@ -215,7 +214,7 @@ class GIRWriter(XMLWriter):
             attrs.append(('transfer-ownership', return_.transfer))
         if return_.skip:
             attrs.append(('skip', '1'))
-        if return_.nullable:
+        if return_.nullable and not return_.not_nullable:
             attrs.append(('nullable', '1'))
         with self.tagcontext('return-value', attrs):
             self._write_generic(return_)
@@ -241,7 +240,7 @@ class GIRWriter(XMLWriter):
         if parameter.transfer:
             attrs.append(('transfer-ownership',
                           parameter.transfer))
-        if parameter.nullable:
+        if parameter.nullable and not parameter.not_nullable:
             attrs.append(('nullable', '1'))
             if parameter.direction != ast.PARAM_DIRECTION_OUT:
                 attrs.append(('allow-none', '1'))

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

@@ -16,6 +16,10 @@
 # Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 # Boston, MA 02111-1307, USA.
 #
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 
 from . import ast
 from . import message
@@ -96,7 +100,7 @@ class IntrospectablePass(object):
 
         if (is_parameter
         and isinstance(target, ast.Callback)
-        and not node.type.target_giname in ('GLib.DestroyNotify', 'Gio.AsyncReadyCallback')
+        and node.type.target_giname not in ('GLib.DestroyNotify', 'Gio.AsyncReadyCallback')
         and node.scope is None):
             self._parameter_warning(
                 parent,

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

@@ -18,9 +18,13 @@
 # Boston, MA 02111-1307, USA.
 #
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
 import imp
 import os
-import platform
 import sys
 
 from .utils import extract_libtool
@@ -54,16 +58,14 @@ class LibtoolImporter(object):
 
     def load_module(self, name):
         realpath = extract_libtool(self.path)
-        platform_system = platform.system()
 
-        if platform_system == 'Darwin':
-            extension = '.dylib'
-        elif platform_system == 'Windows':
-            extension = '.dll'
-        else:
-            extension = '.so'
+        # The first item of the suffix tuple (which can be, depending on platform,
+        # one or more valid filename extensions used to name c extension modules)
+        # is ignored by imp.load_module(). Thus, there is no use in pretending it
+        # is important and we set it to an empty string.
+        suffix = ('', 'rb', imp.C_EXTENSION)
 
-        mod = imp.load_module(name, open(realpath), realpath, (extension, 'rb', 3))
+        mod = imp.load_module(name, open(realpath), realpath, suffix)
         mod.__loader__ = self
         return mod
 

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

@@ -17,6 +17,11 @@
 # Boston, MA 02111-1307, USA.
 #
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
 import re
 
 from . import ast
@@ -27,10 +32,11 @@ from .annotationparser import (ANN_ALLOW_NONE, ANN_ARRAY, ANN_ATTRIBUTES, ANN_CL
                                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)
+                               ANN_VFUNC, ANN_NULLABLE, ANN_OPTIONAL, ANN_NOT)
 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)
+                               OPT_TRANSFER_CONTAINER, OPT_TRANSFER_FLOATING, OPT_TRANSFER_NONE,
+                               OPT_NOT_NULLABLE)
 
 from .utils import to_underscores_noprefix
 
@@ -74,14 +80,14 @@ class MainTransformer(object):
         self._namespace.walk(self._pass_type_resolution)
 
         # Generate a reverse mapping "bar_baz" -> BarBaz
-        for node in self._namespace.itervalues():
+        for node in self._namespace.values():
             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()):
+        for node in list(self._namespace.values()):
             if isinstance(node, ast.Function):
                 # Discover which toplevel functions are actually methods
                 self._pair_function(node)
@@ -126,7 +132,7 @@ class MainTransformer(object):
                 origin_name = 'return value'
             message.log_node(
                 message.FATAL, parent,
-                "can't find parameter %s referenced by %s of %r"
+                "can't find parameter %s referenced by %s of '%s'"
                 % (param_name, origin_name, parent.name))
 
         return param.argname
@@ -140,7 +146,7 @@ class MainTransformer(object):
             origin_name = 'field %s' % (origin.name, )
             message.log_node(
                 message.FATAL, parent,
-                "can't find field %s referenced by %s of %r"
+                "can't find field %s referenced by %s of '%s'"
                 % (field_name, origin_name, parent.name))
 
         return field.name
@@ -155,17 +161,17 @@ class MainTransformer(object):
         target = self._namespace.get_by_symbol(rename_to)
         if not target:
             message.warn_node(node,
-                "Can't find symbol %r referenced by \"rename-to\" annotation" % (rename_to, ))
+                "Can't find symbol '%s' 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,
+                "Function '%s' already shadowed by '%s', can't overwrite "
+                "with '%s'" % (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,
+                "Function '%s' already shadows '%s', can't multiply shadow "
+                "with '%s'" % (target.symbol,
                              target.shadows,
                              rename_to))
         else:
@@ -203,7 +209,7 @@ class MainTransformer(object):
             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, ))
+        raise AssertionError("Unhandled node '%s'" % (node, ))
 
     def _get_block(self, node):
         return self._blocks.get(self._get_annotation_name(node))
@@ -293,7 +299,7 @@ class MainTransformer(object):
             elif isinstance(base, ast.Map) and len(rest) == 2:
                 return ast.Map(*rest)
             message.warn(
-                "Too many parameters in type specification %r" % (type_str, ))
+                "Too many parameters in type specification '%s'" % (type_str, ))
             return base
 
         def top_combiner(base, *rest):
@@ -303,7 +309,7 @@ class MainTransformer(object):
 
         result, rest = grab_one(type_str, resolver, top_combiner, combiner)
         if rest:
-            message.warn("Trailing components in type specification %r" % (
+            message.warn("Trailing components in type specification '%s'" % (
                 type_str, ))
 
         if not result.resolved:
@@ -313,7 +319,7 @@ class MainTransformer(object):
                 position = self._get_position(parent, node)
             else:
                 text = type_str
-            message.warn_node(parent, "%s: Unknown type: %r" %
+            message.warn_node(parent, "%s: Unknown type: '%s'" %
                               (text, type_str), positions=position)
         return result
 
@@ -349,7 +355,7 @@ class MainTransformer(object):
         # (except enums and flags) or basic types that are
         # as big as a gpointer
         if array_type == ast.Array.GLIB_PTRARRAY:
-            if ((element_type in ast.BASIC_GIR_TYPES and not element_type in ast.POINTER_TYPES)
+            if ((element_type in ast.BASIC_GIR_TYPES and element_type not in ast.POINTER_TYPES)
             or isinstance(element_type, (ast.Enum, ast.Bitfield))):
                 message.warn("invalid (element-type) for a GPtrArray, "
                              "must be a pointer", annotations.position)
@@ -358,7 +364,7 @@ class MainTransformer(object):
         if array_type == ast.Array.GLIB_BYTEARRAY:
             if element_type == ast.TYPE_ANY:
                 array.element_type = ast.TYPE_UINT8
-            elif not element_type in [ast.TYPE_UINT8, ast.TYPE_INT8, ast.TYPE_CHAR]:
+            elif element_type not 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",
                              annotations.position)
@@ -467,7 +473,7 @@ class MainTransformer(object):
     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)):
+        or typeval.is_equiv((ast.TYPE_ANY, ast.TYPE_NONE))):
             return ast.PARAM_TRANSFER_NONE
         elif typeval.is_equiv(ast.TYPE_STRING):
             # Non-const strings default to FULL
@@ -508,7 +514,11 @@ class MainTransformer(object):
         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)
+                try:
+                    initially_unowned = self._transformer.lookup_typenode(initially_unowned_type)
+                except KeyError as e:
+                    message.error_node(node, "constructor found but GObject is not in includes")
+                    return None
                 if initially_unowned and self._is_gi_subclass(typeval, initially_unowned_type):
                     return ast.PARAM_TRANSFER_NONE
                 else:
@@ -537,6 +547,63 @@ class MainTransformer(object):
         else:
             raise AssertionError(node)
 
+    def _is_pointer_type(self, node, annotations):
+        if (not isinstance(node, ast.Return) and
+                node.direction in (ast.PARAM_DIRECTION_OUT,
+                                   ast.PARAM_DIRECTION_INOUT)):
+            return True
+
+        target = self._transformer.lookup_typenode(node.type)
+        target = self._transformer.resolve_aliases(target)
+        target = node.type if target is None else target
+
+        return (not isinstance(target, ast.Type) or
+                target not in ast.BASIC_TYPES or
+                target.ctype.endswith('*'))
+
+    def _apply_transfer_annotation(self, parent, node, annotations):
+        transfer_annotation = annotations.get(ANN_TRANSFER)
+        if not transfer_annotation or len(transfer_annotation) != 1:
+            return
+
+        transfer = transfer_annotation[0]
+
+        target = self._transformer.lookup_typenode(node.type)
+        target = self._transformer.resolve_aliases(target)
+        target = node.type if target is None else target
+        node_type = target if isinstance(target, ast.Type) else node.type
+
+        if transfer == OPT_TRANSFER_FLOATING:
+            transfer = OPT_TRANSFER_NONE
+
+            if (not isinstance(target, (ast.Class, ast.Interface))
+                    and node_type.target_giname != 'GLib.Variant'):
+                message.warn('invalid "transfer" annotation for {0}: '
+                             'only valid for object and GVariant types'.format(target),
+                             annotations.position)
+                return
+
+        elif transfer == OPT_TRANSFER_CONTAINER:
+            if (ANN_ARRAY not in annotations and
+                    not isinstance(target, (ast.Array, ast.List, ast.Map))):
+                message.warn('invalid "transfer" annotation for {0}: '
+                             'only valid for container types'.format(target),
+                             annotations.position)
+                return
+
+        elif (not self._is_pointer_type(node, annotations) and
+              node_type not in (ast.TYPE_STRING, ast.TYPE_FILENAME) and
+              not isinstance(target, (ast.Array, ast.List, ast.Map,
+                                      ast.Record, ast.Compound, ast.Boxed,
+                                      ast.Class, ast.Interface))):
+            message.warn('invalid "transfer" annotation for {0}: '
+                         'only valid for array, struct, union, boxed, '
+                         'object and interface types'.format(target),
+                         annotations.position)
+            return
+
+        node.transfer = transfer
+
     def _apply_annotations_param_ret_common(self, parent, node, tag):
         annotations = tag.annotations if tag else {}
 
@@ -577,32 +644,55 @@ class MainTransformer(object):
             # Also reset the transfer default if we're toggling direction
             node.transfer = self._get_transfer_default(parent, node)
 
-        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._apply_transfer_annotation(parent, node, annotations)
         self._adjust_container_type(parent, node, annotations)
 
-        if ANN_NULLABLE in annotations:
+        # gpointer parameters and return values are always nullable unless:
+        #  - annotated with (type) and not also with (nullable); or
+        #  - annotated with (element-type) and not also with (nullable); or
+        #  - annotated (not nullable)
+        # See: https://bugzilla.gnome.org/show_bug.cgi?id=719966#c22
+        if node.type.is_equiv(ast.TYPE_ANY):
             node.nullable = True
+        if ANN_NULLABLE in annotations:
+            if self._is_pointer_type(node, annotations):
+                node.nullable = True
+                node.not_nullable = False
+            else:
+                message.warn('invalid "nullable" annotation: '
+                             'only valid for pointer types and out parameters',
+                             annotations.position)
 
         if ANN_OPTIONAL in annotations:
-            node.optional = True
+            if (not isinstance(node, ast.Return) and
+                    node.direction == ast.PARAM_DIRECTION_OUT):
+                node.optional = True
+            else:
+                message.warn('invalid "optional" annotation: '
+                             'only valid for out parameters',
+                             annotations.position)
 
         if ANN_ALLOW_NONE in annotations:
-            if node.direction == ast.PARAM_DIRECTION_OUT:
+            if (node.direction == ast.PARAM_DIRECTION_OUT and
+                    not isinstance(node, ast.Return)):
                 node.optional = True
-            else:
+            elif self._is_pointer_type(node, annotations):
                 node.nullable = True
+            else:
+                message.warn('invalid "allow-none" annotation: '
+                             'only valid for pointer types and out parameters',
+                             annotations.position)
 
         if (node.direction != ast.PARAM_DIRECTION_OUT and
                 (node.type.target_giname == 'Gio.AsyncReadyCallback' or
                  node.type.target_giname == 'Gio.Cancellable')):
             node.nullable = True
 
+        # Final override for nullability
+        if ANN_NOT in annotations:
+            node.nullable = False
+            node.not_nullable = True
+
         if tag and tag.description:
             node.doc = tag.description
 
@@ -708,6 +798,12 @@ class MainTransformer(object):
             tag = block.tags.get(TAG_RETURNS)
         else:
             tag = None
+
+        if tag is not None and return_.type == ast.TYPE_NONE:
+            message.warn('%s: invalid return annotation' % (block.name,),
+                         tag.position)
+            tag = None
+
         self._apply_annotations_param_ret_common(parent, return_, tag)
 
     def _apply_annotations_params(self, parent, params, block):
@@ -740,13 +836,14 @@ class MainTransformer(object):
                 text = ''
             elif len(unused) == 1:
                 (param, ) = unused
-                text = ', should be %r' % (param, )
+                text = ", should be '%s'" % (param, )
             else:
-                text = ', should be one of %s' % (', '.join(repr(p) for p in unused), )
+                text = ", should be one of %s" % \
+                       (', '.join("'%s'" % p for p in sorted(unused)), )
 
             param = block.params.get(doc_name)
-            message.warn('%s: unknown parameter %r in documentation '
-                         'comment%s' % (block.name, doc_name, text),
+            message.warn("%s: unknown parameter '%s' in documentation "
+                         "comment%s" % (block.name, doc_name, text),
                 param.position)
 
     def _apply_annotations_callable(self, node, chain, block):
@@ -767,7 +864,7 @@ class MainTransformer(object):
         try:
             self._adjust_container_type(parent, field, tag.annotations)
         except AttributeError as ex:
-            print ex
+            print(ex)
 
     def _apply_annotations_property(self, parent, prop):
         prefix = self._get_annotation_name(parent)
@@ -794,7 +891,6 @@ class MainTransformer(object):
 
         if block:
             self._apply_annotations_annotated(signal, block)
-
             # We're only attempting to name the signal parameters if
             # the number of parameters (@foo) is the same or greater
             # than the number of signal parameters
@@ -865,7 +961,7 @@ class MainTransformer(object):
                             break
                     if not matched:
                         message.warn_node(node,
-                            "Virtual slot %r not found for %r annotation" % (invoker_name,
+                            "Virtual slot '%s' not found for '%s' annotation" % (invoker_name,
                                                                              ANN_VFUNC))
         return True
 
@@ -925,14 +1021,14 @@ the ones that failed to resolve removed."""
         # 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():
+        for enum in self._namespace.values():
             if not isinstance(enum, ast.Enum):
                 continue
             uscored = to_underscores_noprefix(enum.name).lower()
             uscore_enums[uscored] = enum
             uscore_enums[enum.name] = enum
 
-        for node in self._namespace.itervalues():
+        for node in self._namespace.values():
             if not isinstance(node, ast.ErrorQuarkFunction):
                 continue
             full = node.symbol[:-len('_quark')]
@@ -1196,7 +1292,7 @@ method or constructor of some type."""
             if func.is_constructor:
                 message.warn_node(
                     func,
-                    "Can't find matching type for constructor; symbol=%r" % (func.symbol, ))
+                    "Can't find matching type for constructor; symbol='%s'" % (func.symbol, ))
             return False
 
         # Some sanity checks; only objects and boxeds can have ctors
@@ -1229,7 +1325,7 @@ method or constructor of some type."""
                 if parent is None:
                     message.warn_node(func,
                                       "Return value is not superclass for constructor; "
-                                      "symbol=%r constructed=%r return=%r" %
+                                      "symbol='%s' constructed='%s' return='%s'" %
                                       (func.symbol,
                                        str(origin_node.create_type()),
                                        str(func.retval.type)))
@@ -1237,8 +1333,8 @@ method or constructor of some type."""
         else:
             if origin_node != target:
                 message.warn_node(func,
-                                  "Constructor return type mismatch symbol=%r "
-                                  "constructed=%r return=%r" %
+                                  "Constructor return type mismatch symbol='%s' "
+                                  "constructed='%s' return='%s'" %
                                   (func.symbol,
                                    str(origin_node.create_type()),
                                    str(func.retval.type)))
@@ -1250,8 +1346,8 @@ method or constructor of some type."""
         """Look for virtual methods from the class structure."""
         if not node.glib_type_struct:
             # https://bugzilla.gnome.org/show_bug.cgi?id=629080
-            #message.warn_node(node,
-            #    "Failed to find class structure for %r" % (node.name, ))
+            # message.warn_node(node,
+            #    "Failed to find class structure for '%s'" % (node.name, ))
             return
 
         node_type = node.create_type()
@@ -1357,6 +1453,15 @@ method or constructor of some type."""
                   param.argname.endswith('data')):
                 callback_param.closure_name = param.argname
 
+        for param in params:
+            # By convention, closure user_data parameters are always nullable.
+            if param.closure_name is not None:
+                idx = node.get_parameter_index(param.closure_name)
+                assert idx >= 0
+                closure_param = params[idx]
+                if not closure_param.not_nullable:
+                    closure_param.nullable = True
+
     def _pass3_callable_throws(self, node):
         """Check to see if we have anything that looks like a
         callback+user_data+GDestroyNotify set."""