meson.source_root() return the root of the main project, but in this
case we want the root of the gobject-introspection (sub)project.

The scanner is chocking on the `__float80` and `__float128` types that
are provided by GCC as extensions to ISO/IEC TS 18661-3:2015:

https://gcc.gnu.org/onlinedocs/gcc/Floating-Types.html

Fixes: #384

ccache is currently broken somehow. With 32bit Windows getting less and less
usage/testing it's a good idea to move to 64 bit anyway.

This resulted in duplicate module errors for me.

Because of skepticism I received in #224, I made this PR which keeps the
testsuite and CI improvements but doesn't add any new build options. I
hope this would be less controversial:

 - no new knobs
 - tests for those using existing build options
 - CI tests `build_introspection_data = false`

GLib upstream has renamed its `master` branch to `main`.

See https://gitlab.gnome.org/GNOME/glib/-/issues/2348

.

Signed-off-by: Philip Withnall <pwithnall@endlessos.org>

Use the depth= argument from Meson 0.52 to limit the clone depth of
subprojects to 1. This should make the CI images a little smaller, and
reduce the bandwidth required to build them (although that’s not so
important because it only happens once every few months).

Signed-off-by: Philip Withnall <pwithnall@endlessos.org>

Found by Coverity.

https://bugzilla.redhat.com/show_bug.cgi?id=1938731

Found by Coverity.

https://bugzilla.redhat.com/show_bug.cgi?id=1938731

Unref type before reusing it. Found by Coverity.

https://bugzilla.redhat.com/show_bug.cgi?id=1938731

Found by Coverity.

https://bugzilla.redhat.com/show_bug.cgi?id=1938731

Found by Coverity.

https://bugzilla.redhat.com/show_bug.cgi?id=1938731

Check for errors during g_file_open_tmp() and fdopen(). Make sure to
free tmp_name and error as needed.

Found with Coverity.

https://bugzilla.redhat.com/show_bug.cgi?id=1938731

Found by Coverity.

https://bugzilla.redhat.com/show_bug.cgi?id=1938731

Found by Coverity.

https://bugzilla.redhat.com/show_bug.cgi?id=1938731

Don't rely on runtime name, but on C header parsed symbol.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

This member will contain the string from the GEnumValue/GFlagsValue
'value_name' introspection dump.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Fedora 29 was EOL'ed in 2019.

Not every Linux distro ships with Docker, and Podman is nicer.

Don't call Ninja directly, and don't enter the build directory.

Also move shared options to environment variables, so we don't have to
copy and paste them everywhere.

Drop explicit `-Wall` and `-Wextra` from the compiler flags.

Meson adds `-Wall` with `warning_level=1`, and `-Wextra` with
`warning_level=2`.

Fixes: #319

Avoid a "maybe uninitialized" compiler warning.

Don't install them as part of the CI job. It's pointless repetition.

GLib dropped the internal libpcre copy, which means we end up with a
subproject inside a subproject.

Since libpcre is frozen, we can rely on using the installed copy.

GLib has dropped the internal copy libpcre, so we need to promote
libpcre's subproject to the top level.

Make the variable names intelligible, and include a bunch of built files
that are necessary to ensure that the generated GIR data actually
matches the GLib API.

The (out caller-allocates) and (out callee-allocates) annotations are
meant for structured or pointer types. Plain old data types are just
regular out parameters and don't need the annotation about who allocates
them.

See: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/2005

The GNOME developers documentation website has been updated, and we're
in the process of moving API references elsewhere. The old documentation
is still available under developer-old.gnome.org, so let's update the
URLs we have in our documentation.

This is so that GJS can use these variables in its own build files when
including gobject-introspection as a Meson subproject. Previously we
took the approach of using the files in their installed locations, but
that doesn't work as a subproject.

Up to the 2.69.1 tag.

We are going to introduce new API.

A "final" class is a leaf node in a derivable type hierarchy, and cannot
be derived any further.

This matches the changes in libgobject that introduced G_TYPE_FLAG_FINAL
to the type flags.

We need to check the container type before trying to obtain a
GIPropertyInfo for GIFunctionInfos that have a SETTER or a GETTER flag
set.

We introduce two new annotations:

  - (set-property PROPERTY_NAME)
  - (get-property PROPERTY_NAME)

These annotations are valid inside function blocks for methods on
objects and interfaces, and define whether a function is a property
accessor, e.g.:

    /**
     * gtk_widget_set_name: (set-property name)
     * @self: ...
     * @name: ...
     *
     * ...
     */

    /**
     * gtk_widget_get_name: (get-property name)
     * @self: ...
     *
     * ...
     *
     * Returns: ...
     */

The annotations are transformed into the GIR data as attributes:

 - glib:set-property="PROPERTY_NAME"
 - glib:get-property="PROPERTY_NAME"

The underlying typelib data has had flags for setter and getter
functions for a while, but they have never been plugged into the GIR
data or the introspection scanner. Now they are; you can retrieve the
GIPropertyInfo from a GIFunctionInfo that has the GI_FUNCTION_IS_SETTER
or GI_FUNCTION_IS_GETTER flags set.

Fixes: #13

Add an accessors pair to Regress.TestObj and annotate them.

Mention them in the annotations list, and add the new attributes to the
GIR schema.

A GObject property can be accessed generically through the GObject API,
e.g. g_object_set_property() and g_object_get_property(). Properties
typically also have public accessor functions, which are (according to
our own best practices) called through the generic API.

The introspection data is currently missing the relation between a
property and its public accessor functions. With this information, a
language binding could, for instance, avoid exposing the C API entirely,
thus minimizing the chances of collisions between property names and
accessor functions; alternatively, a binding could call the C API
directly instead of going through the generic GObject API, thus avoiding
the boxing and unboxing from a native type to a GIArgument and finally
into a GValue, and vice versa.

In the GIR, we add two new attributes to the `property` element:

  - setter="SYMBOL"
  - getter="SYMBOL"

where "symbol" is the C function identifier of the setter and getter
functions, respectively. The `setter` attribute is only applied to
writable, non-construct-only properties; the `getter` attribute is only
applied to readable properties.

We maintain the ABI compatibility of the typelib data by using 20 bits
of the 25 reserved bits inside the PropertyBlob structure. The data is
exposed through two new GIPropertyInfo methods:

  - g_property_info_get_setter()
  - g_property_info_get_getter()

which return the GIFunctionInfo for the setter and getter functions,
respectively.

We need new annotations to allow library developers to associate a
setter and a getter functions to a property definition.

Public accessor functions are the functions typically called through
g_object_set_property() and g_object_get_property().

The heuristic is pretty trivial: for any given non-construct-only,
writable property, we check if there's a `set_<property>` method; for
any given readable property, we check if there's a `get_<property>`
method.

If a property is boolean and read-only, the getter method can be the
same as the property name, for instance:

  - gtk_widget_has_focus()
  - gtk_media_stream_has_audio()

Easier to read than `0x3ff`.

The `set-property` and `get-property` identifier annotations only apply
to methods.

The `setter` and `getter` identifier annotations only apply to
properties.

If the (set-property) and (get-property) annotations on methods do not
round trip with the (setter) and (getter) annotations on the
corresponding property, we want to emit a warning.

Some readonly boolean properties in the form of 'has-foo' or 'is-bar'
expose a getter function in the form of `get_has_foo()` or
`get_is_bar()`, according to extant coding practices. We should ensure
we still check for those.

Use the parent type and the function symbol when erroring out if we
can't find a property accessor.

If a property is not introspectable we need to decouple it from its
accessors; the property data will not be compiled into the typelib,
and when the compiler will try to resolve the offsets into the binary
blob we'll get a fatal exception.

The "final" attribute is not namespaced. Like "abstract", the "final"
flag is shared across type systems, it's not strongly related to GObject
types.

For historical reasons, we have boxed types that do not follow the
typical conversion from CamelCase to snake_case when it comes to their
get_type function.

The introspection scanner will correctly detect that a type is matched
to that get_type function, but then it will default to tokenize the
get_type function to set the c_symbol_prefix of the given type.

The method pairing code in the main transformation path takes that
mismatch into consideration, but the constructor pairing code does not.
This leads to interesting cases, like GString.

GString is correctly detected as GLib.String, and correctly matched to
its `g_gstring_get_type()` type function, but its c_symbol_prefix is set
to `gstring` after the tokenization. While methods like
`g_string_append()` are correctly paired to the `GLib.String` node,
constructors like `g_string_new()` do not, and end up being turned into
function nodes, like `GLib.string_new`, even if they are annotated as
constructors.

I'm not entirely confident that changing the c_symbol_prefix
tokenization this late in the game is going to be free of regressions;
instead, we provide a way for pairing constructors if they are annotated
as such.

In other words: non-annotated constructors of types that have a
different symbol prefix than the one of the get_type function will stay
as they are today—a global function. To enforce the matching, we rely on
an explicit `(constructor)` annotation; at least, this should ensure
that we have explicit buy in from the maintainers of the API.

Fixes: #399

GLib 2.70 has just been released, so let's sync up the documentation and
annotations.

Fixes: #402