Mention that a symbol can shadow another symbol, and that a symbol can be
shadowed by another symbol.

This information is mostly relevant to users of language bindings.

People using language bindings might end up in the C API reference, so it
would be nice to tell them that non-introspectable symbols might not be
available through bindings.

Arguments marked as in-out can also be nullable, which means they can be
set to NULL.

A nullable argument is, by definition, already a pointer argument; we
don't need to check for additional pointers.

When returning a GListModel, GTK annotates the element type held inside
the list model with:

    (attributes element-type=GtkWindow)

as the `(element-type)` annotation can only work for arrays, linked
lists, and hash tables.

We still want to indicate what is the expected type inside a GListModel,
as it's completely opaque otherwise.

Reword the generated content:

 - expand the "direction" using a proper explanation instead of in, out,
   or in-out
 - refer to argument or return value
 - structure the return value table like the arguments one
 - add style classes to the tables
 - check for array or list independently from the generated link

We also make sure that every callable template follows the same pattern
for the arguments and return value section.

The introspection data turns GError** arguments into a `throws`
attribute. We already add the argument when generating the declaration
of a method or function, so we also need to generate the corresponding
argument description.

Fixes: #86

Tweak the text for the generated rows.

The dot can be confused with actual syntax, so we should use something
else to separate the clickable elements of the heading.

Instead of hard coding the separator, we can use an empty <span> and
then use CSS to fill it out.

Fixes: #81

Use a "title" as a shortcut for people who already know what the
transfer annotation means.

Use the appropriate meta elements for the OpenGraph and Twitter, and
avoid duplication.

Put the site URL elements behind a configuration switch.

* Bad licenses:
* Deprecated licenses:
* Licenses without file extension:
* Missing licenses:
* Unused licenses:
* Used licenses: Apache-2.0, CC0-1.0, GPL-3.0-or-later, OFL-1.1
* Read errors: 0
* Files with copyright information: 90 / 90
* Files with license information: 90 / 90

Congratulations! Your project is compliant with version 3.0 of the REUSE
Specification :-)

We don't only need a base URL, but a pattern string to point to a
file/line tuple.

We're still using old style anchors.

Attributes are custom key/value annotations that are reported "as is" in
the XML. We can define a keys that library authors can use in their
annotations, and when we find them in the GIR, we can use them to
generate additional content.

For instance, if a property has an "org.gtk.Property.get" annotation
pointing to a getter function, we can generate the link in the property
documentation.

And add the library version while we're at it.

And linkify it, if possible.

If one is available, otherwise fall back to a plain C type.

Use the same structure for:

 - anchors
 - source links
 - sections
 - sidebars

Link the source location of the declaration, as well as the location of
the documentation. This should improve our chances at getting
documentation fixes.

There's no need to list more sections than the current one.

We're running them through syntax highlighting.

Another bit of documentation we can automatically fill out from the
introspection data, instead of having to manually type it out in the
description.

The stability and availability can be skipped, if they are unset or set
to their default values.

Instead of a tuple. Makes templates easier to read.

Expose stability, availability, and possible deprecation notices.

We also expose the free-form annotations; in the future we might want to
use them to influence the documentation's output as well.

Add collapsible sections, and make it a bit more nice.

We're doing a ton of string concatenation in a pre-processed
environment, where whitespace matters, so we cannot really use the
Jinja template conditionals inside a <pre> tag.

Generate an API reference for a given project using a template and the
introspection data for that project.

The basic template is still a work in progress.