Merge pull request #8960 from mensinda/yamlDoc

Reference Manual 2.0

.github/workflows/website.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Install package
         run: |
           sudo apt-get -y install python3-pip ninja-build libjson-glib-dev
-          pip install meson hotdoc
+          pip install hotdoc chevron strictyaml
       - name: Setup SSH Keys and known_hosts
         env:
           SSH_AUTH_SOCK: /tmp/ssh_agent.sock
@@ -36,7 +36,7 @@ jobs:
           git config --global user.name "github-actions"
           git config --global user.email "github-actions@github.com"
           cd docs
-          meson setup _build
+          ../meson.py setup _build
           ninja -C _build
       - name: Update website
         env:

CODEOWNERS

@@ -8,3 +8,4 @@
 /mesonbuild/compilers/ @dcbaker
 /mesonbuild/linkers.py @dcbaker
 /mesonbuild/mtest.py @bonzini
+/docs/refman @mensinda

docs/extensions/refman_links.py

@@ -0,0 +1,108 @@
+from pathlib import Path
+from json import loads
+import re
+
+from hotdoc.core.exceptions import HotdocSourceException
+from hotdoc.core.extension import Extension
+from hotdoc.core.tree import Page
+from hotdoc.core.project import Project
+from hotdoc.run_hotdoc import Application
+from hotdoc.core.formatter import Formatter
+from hotdoc.utils.loggable import Logger, warn, info
+
+import typing as T
+
+if T.TYPE_CHECKING:
+    import argparse
+
+Logger.register_warning_code('unknown-refman-link', HotdocSourceException, 'refman-links')
+
+class RefmanLinksExtension(Extension):
+    extension_name = 'refman-links'
+    argument_prefix = 'refman'
+
+    def __init__(self, app: Application, project: Project):
+        self.project: Project
+        super().__init__(app, project)
+        self._data_file: T.Optional[Path] = None
+        self._data: T.Dict[str, str] = {}
+
+    @staticmethod
+    def add_arguments(parser: 'argparse.ArgumentParser'):
+        group = parser.add_argument_group(
+            'Refman links',
+            'Custom Meson extension',
+        )
+
+        # Add Arguments with `group.add_argument(...)`
+        group.add_argument(
+            f'--refman-data-file',
+            help="JSON file with the mappings to replace",
+            default=None,
+        )
+
+    def parse_config(self, config: T.Dict[str, T.Any]) -> None:
+        super().parse_config(config)
+        self._data_file = config.get('refman_data_file')
+
+    def _formatting_page_cb(self, formatter: Formatter, page: Page) -> None:
+        ''' Replace Meson refman tags
+
+        Links of the form [[function]] are automatically replaced
+        with valid links to the correct URL. To reference objects / types use the
+        [[@object]] syntax.
+        '''
+        link_regex = re.compile(r'\[\[#?@?([ \n\t]*[a-zA-Z0-9_]+[ \n\t]*\.)*[ \n\t]*[a-zA-Z0-9_]+[ \n\t]*\]\]', re.MULTILINE)
+        for m in link_regex.finditer(page.formatted_contents):
+            i = m.group()
+            obj_id: str = i[2:-2]
+            obj_id = re.sub(r'[ \n\t]', '', obj_id)  # Remove whitespaces
+
+            # Marked as inside a code block?
+            in_code_block = False
+            if obj_id.startswith('#'):
+                in_code_block = True
+                obj_id = obj_id[1:]
+
+            if obj_id not in self._data:
+                warn('unknown-refman-link', f'{Path(page.name).name}: Unknown Meson refman link: "{obj_id}"')
+                continue
+
+            # Just replaces [[!file.id]] paths with the page file (no fancy HTML)
+            if obj_id.startswith('!'):
+                page.formatted_contents = page.formatted_contents.replace(i, self._data[obj_id])
+                continue
+
+            # Fancy links for functions and methods
+            text = obj_id
+            if text.startswith('@'):
+                text = text[1:]
+            else:
+                text = text + '()'
+            if not in_code_block:
+                text = f'<code>{text}</code>'
+            link = f'<a href="{self._data[obj_id]}"><ins>{text}</ins></a>'
+            page.formatted_contents = page.formatted_contents.replace(i, link)
+
+    def setup(self) -> None:
+        super().setup()
+
+        if not self._data_file:
+            info('Meson refman extension DISABLED')
+            return
+
+        raw = Path(self._data_file).read_text(encoding='utf-8')
+        self._data = loads(raw)
+
+        # Register formater
+        for ext in self.project.extensions.values():
+            ext = T.cast(Extension, ext)
+            ext.formatter.formatting_page_signal.connect(self._formatting_page_cb)
+        info('Meson refman extension LOADED')
+
+    @staticmethod
+    def get_dependencies() -> T.List[T.Type[Extension]]:
+        return []  # In case this extension has dependencies on other extensions
+
+def get_extension_classes() -> T.List[T.Type[Extension]]:
+    return [RefmanLinksExtension]

docs/genrefman.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Hack to make relative imports to mlog possible
+from pathlib import Path
+import sys
+root = Path(__file__).absolute().parents[1]
+sys.path.insert(0, str(root))
+
+# Now run the actual code
+from refman.main import main
+
+if __name__ == '__main__':
+    raise SystemExit(main())

docs/markdown/Adding-arguments.md

@@ -22,7 +22,7 @@ This makes Meson add the define to all C compilations. Usually you
 would use this setting for flags for global settings. Note that for
 setting the C/C++ language standard (the `-std=c99` argument in GCC),
 you would probably want to use a default option of the `project()`
-function. For details see the [reference manual](Reference-manual.md).
+function. For details see the [reference manual](RefMan.md).
 
 Global arguments have certain limitations. They all have to be defined
 before any build targets are specified. This ensures that the global

docs/markdown/Build-options.md

@@ -76,18 +76,17 @@ This type is available since version 0.44.0
 A `feature` option has three states: `enabled`, `disabled` or `auto`.
 It is intended to be passed as value for the `required` keyword
 argument of most functions. Currently supported in
-[`dependency()`](Reference-manual.md#dependency),
-[`find_library()`](Reference-manual.md#compiler-object),
-[`find_program()`](Reference-manual.md#find_program) and
-[`add_languages()`](Reference-manual.md#add_languages) functions.
+[[dependency]],
+[[compiler.find_library]],
+[[find_program]] and
+[[add_languages]] functions.
 
 - `enabled` is the same as passing `required : true`.
 - `auto` is the same as passing `required : false`.
 - `disabled` do not look for the dependency and always return 'not-found'.
 
 When getting the value of this type of option using `get_option()`, a
-special [feature option
-object](Reference-manual.md#feature-option-object) is returned instead
+special [[@feature]] object is returned instead
 of the string representation of the option's value. This object can be
 passed to `required`:
 

docs/markdown/Builtin-options.md

@@ -166,7 +166,7 @@ option:
 `-Wl,-bitcode_bundle` while linking. These options are incompatible
 with `b_asneeded`, so that option will be silently disabled.
 
-[Shared modules](Reference-manual.md#shared_module) will not have
+[[shared_module]]s will not have
 bitcode embedded because `-Wl,-bitcode_bundle` is incompatible with
 both `-bundle` and `-Wl,-undefined,dynamic_lookup` which are necessary
 for shared modules to work.

docs/markdown/CMake-module.md

@@ -115,9 +115,8 @@ See [the CMake options object](#cmake-options-object) for a complete
 reference of all supported functions.
 
 The CMake configuration options object is very similar to the
-[configuration data
-object](Reference-manual.md#configuration-data-object) object returned
-by [`configuration_data`](Reference-manual.md#configuration_data). It
+[[@cfg_data]] object] object returned
+by [[configuration_data]]. It
 is generated by the `subproject_options` function
 
 All configuration options have to be set *before* the subproject is
@@ -138,8 +137,8 @@ and supports the following methods:
  - `dependency(target)` returns a dependency object for any CMake target. The
    `include_type` kwarg *(new in 0.56.0)* controls the include type of the
    returned dependency object similar to the same kwarg in the
-   [`dependency()`](Reference-manual.md#dependency) function.
- - `include_directories(target)` returns a Meson `include_directories()`
+   [[dependency]] function.
+ - `include_directories(target)` returns a Meson [[@inc]]
    object for the specified target. Using this function is not necessary
    if the dependency object is used.
  - `target(target)` returns the raw build target.
@@ -160,7 +159,7 @@ following methods are supported:
  - `add_cmake_defines({'opt1': val1, ...})` add additional CMake commandline defines
  - `set_override_option(opt, val)` set specific [build options](Build-options.md)
    for targets. This will effectively add `opt=val` to the `override_options`
-   array of the [build target](Reference-manual.md#executable)
+   array of the [[build_target]]
  - `set_install(bool)` override wether targets should be installed or not
  - `append_compile_args(lang, arg1, ...)` append compile flags for a specific
    language to the targets

docs/markdown/External-Project-module.md

@@ -86,7 +86,7 @@ Keyword arguments:
 - `verbose`: If set to `true` the output of sub-commands ran to configure, build
   and install the project will be printed onto Meson's stdout.
 - `env` : environment variables to set, such as `['NAME1=value1', 'NAME2=value2']`,
-  a dictionary, or an [`environment()` object](Reference-manual.md#environment-object).
+  a dictionary, or an [[@env]] object.
 
 Returns an [`ExternalProject`](#ExternalProject_object) object
 

docs/markdown/External-commands.md

@@ -22,8 +22,7 @@ Since 0.52.0, you can pass the command environment as a dictionary:
 run_command('command', 'arg1', 'arg2', env: {'FOO': 'bar'})
 ```
 
-Since 0.50.0, you can also pass the command
-[`environment`](Reference-manual.md#environment-object) object:
+Since 0.50.0, you can also pass the command [[@env]] object:
 
 ```meson
 env = environment()

docs/markdown/Generating-sources.md

@@ -8,8 +8,8 @@ Sometimes source files need to be preprocessed before they are passed
 to the actual compiler. As an example you might want build an IDL
 compiler and then run some files through that to generate actual
 source files. In Meson this is done with
-[`generator()`](Reference-manual.md#generator) or
-[`custom_target()`](Reference-manual.md#custom_target).
+[[generator]] or
+[[custom_target]].
 
 ## Using custom_target()
 
@@ -120,7 +120,7 @@ idep_foo = declare_dependency(
 ```
 
 See [dependencies](Dependencies.md#declaring-your-own), and
-[reference](Reference-manual.md#declare_dependency) for more
+[[declare_dependency]] for more
 information.
 
 ## Using generator()
@@ -139,7 +139,7 @@ output will be created in a target-private directory `@BUILD_DIR@`.
 If you want to generate files for general purposes such as for
 generating headers to be used by several sources, or data that will be
 installed, and so on, use a
-[`custom_target()`](Reference-manual.md#custom_target) instead.
+[[custom_target]] instead.
 
 
 ```meson

docs/markdown/Gnome-module.md

@@ -225,9 +225,9 @@ useful when running the application locally for example during tests.
 * `build_by_default`: causes, when set to true, to have this target be
   built by default, that is, when invoking plain `meson compile`, the default
   value is true for all built target types
-* `depend_files`: files ([`string`](Reference-manual.md#string-object),
-  [`files()`](Reference-manual.md#files), or
-  [`configure_file()`](Reference-manual.md#configure_file)) of
+* `depend_files`: files ([[@str]],
+  [[files]], or
+  [[configure_file]]) of
   schema source XML files that should trigger a re-compile if changed.
 
 ### gnome.gdbus_codegen()

docs/markdown/Hotdoc-module.md

@@ -31,21 +31,17 @@ Generates documentation using [hotdoc] and installs it into `$prefix/share/doc/h
 
 **Keyworded arguments:**
 
-* `sitemap` (*[string] or [file]*) (**required**): The hotdoc sitemap file
-* `index` (*[string] or [file]*) (**required**): Location of the index file
-* `dependencies`(*[targets]*): Targets on which the documentation generation depends on.
+* `sitemap` ([[@str]] or [[@file]]) (**required**): The hotdoc sitemap file
+* `index` ([[@str]] or [[@file]]) (**required**): Location of the index file
+* `dependencies`([[@build_tgt]]): Targets on which the documentation generation depends on.
 * `subprojects`: A list of `HotdocTarget` that are used as subprojects for hotdoc to generate
   the documentation.
 * ... Any argument of `hotdoc` can be used replacing dashes (`-`) with underscores (`_`).
   For a full list of available parameters, just have a look at `hotdoc help`.
 
-[file]: Reference-manual.md#files
-[string]: Reference-manual.md#string-object
-[targets]: Reference-manual.md#build-target-object
-
 **Returns:**
 
-`HotdocTarget`: A [`custom_target`](Reference-manual.md#custom-target-object) with the
+`HotdocTarget`: A [[custom_target]] with the
 following extra methods:
 
 * `config_path`: Path to the generated `hotdoc` configuration file.

docs/markdown/IDE-integration.md

@@ -79,7 +79,7 @@ project.
 
 *(New in 0.56.0)* The `extra_files` key lists all files specified via
 the `extra_files` kwarg of a build target. See
-[`executable()`](Reference-manual.md#executable).
+[[executable]].
 
 A target usually generates only one file. However, it is possible for
 custom targets to have multiple outputs.

docs/markdown/Keyval-module.md

@@ -55,4 +55,4 @@ option](Build-options.md).
 * The first (and only) argument is the path to the configuration file to
   load (usually ".config").
 
-**Returns**: a [dictionary object](Reference-manual.md#dictionary-object).
+**Returns**: a [[@dict]] object.

docs/markdown/Python-3-module.md

@@ -10,7 +10,7 @@ This module is deprecated and replaced by the
 
 This is a cross platform way of finding the Python 3 executable, which
 may have a different name on different operating systems. Returns an
-[external program](Reference-manual.md#external-program-object)
+[[@external_program]]
 object.
 
 *Added 0.38.0*
@@ -24,7 +24,7 @@ from `python` module.
 Creates a `shared_module` target that is named according to the naming
 conventions of the target platform. All positional and keyword
 arguments are the same as for
-[shared_module](Reference-manual.md#shared_module).
+[[shared_module]].
 
 `extension_module` does not add any dependencies to the library so user may
 need to add `dependencies : dependency('python3')`, see

docs/markdown/Python-module.md

@@ -30,7 +30,7 @@ installation will be the one used to run Meson.
 If provided, it can be:
 
 - A simple name, eg `python-2.7`, Meson will look for an external program
-  named that way, using [find_program]
+  named that way, using [[find_program]]
 
 - A path, eg `/usr/local/bin/python3.4m`
 
@@ -49,7 +49,7 @@ Keyword arguments are the following:
   [`feature`](Build-options.md#features) option can also be passed to the
   `required` keyword argument.
 - `disabler`: if `true` and no python installation can be found, return a
-  [disabler object](Reference-manual.md#disabler-object) instead of a not-found object.
+  [[@disabler]] object instead of a not-found object.
   *Since 0.49.0*
 - `modules`: a list of module names that this python installation must have.
   *Since 0.51.0*
@@ -58,7 +58,7 @@ Keyword arguments are the following:
 
 ## `python_installation` object
 
-The `python_installation` object is an [external program], with several
+The `python_installation` object is an [[@external_program]], with several
 added methods.
 
 ### Methods
@@ -80,11 +80,11 @@ provided prior to 0.50.0 due to a bug.
 shared_module py_installation.extension_module(module_name, list_of_sources, ...)
 ```
 
-Create a `shared_module` target that is named according to the naming
+Create a [[shared_module]] target that is named according to the naming
 conventions of the target platform.
 
 All positional and keyword arguments are the same as for
-[shared_module], excluding `name_suffix` and `name_prefix`, and with
+[[shared_module]], excluding `name_suffix` and `name_prefix`, and with
 the addition of the following:
 
 - `subdir`: By default, Meson will install the extension module in
@@ -95,9 +95,9 @@ the addition of the following:
 
 `extension_module` does not add any dependencies to the library so
 user may need to add `dependencies : py_installation.dependency()`,
-see [][`dependency()`].
+see [[dependency]].
 
-**Returns**: a [buildtarget object]
+**Returns**: a [[@build_tgt]] object
 
 #### `dependency()`
 
@@ -106,7 +106,7 @@ python_dependency py_installation.dependency(...)
 ```
 
 This method accepts no positional arguments, and the same keyword
-arguments as the standard [dependency] function. It also supports the
+arguments as the standard [[dependency]] function. It also supports the
 following keyword argument:
 
 - `embed`: *(since 0.53.0)* If true, Meson will try to find a python
@@ -126,7 +126,7 @@ void py_installation.install_sources(list_of_files, ...)
 Install actual python sources (`.py`).
 
 All positional and keyword arguments are the same as for
-[install_data], with the addition of the following:
+[[install_data]], with the addition of the following:
 
 - `pure`: On some platforms, architecture independent files are
   expected to be placed in a separate directory. However, if the
@@ -149,7 +149,7 @@ string py_installation.get_install_dir(...)
 Retrieve the directory [][`install_sources()`] will install to.
 
 It can be useful in cases where `install_sources` cannot be used
-directly, for example when using [configure_file].
+directly, for example when using [[configure_file]].
 
 This function accepts no arguments, its keyword arguments are the same
 as [][`install_sources()`].
@@ -236,18 +236,9 @@ with [][`get_variable()`], false otherwise.
 
 ## `python_dependency` object
 
-This [dependency object] subclass will try various methods to obtain
+This [[@dep]] object subclass will try various methods to obtain
 the compiler and linker arguments, starting with pkg-config then
 potentially using information obtained from python's `sysconfig`
 module.
 
 It exposes the same methods as its parent class.
-
-[find_program]: Reference-manual.md#find_program
-[shared_module]: Reference-manual.md#shared_module
-[external program]: Reference-manual.md#external-program-object
-[dependency]: Reference-manual.md#dependency
-[install_data]: Reference-manual.md#install_data
-[configure_file]: Reference-manual.md#configure_file
-[dependency object]: Reference-manual.md#dependency-object
-[buildtarget object]: Reference-manual.md#build-target-object

docs/markdown/Release-notes-for-0.37.0.md

@@ -153,7 +153,7 @@ you don't need to add that yourself to `vala_args:`.
 ## Improvements to install scripts
 
 You can now pass arguments to install scripts added with
-[`meson.add_install_script()`](Reference-manual.md#meson-object). All
+[[meson.add_install_script]]. All
 arguments after the script name will be passed to the script.
 
 The `MESON_INSTALL_DESTDIR_PREFIX` environment variable is now set

docs/markdown/Release-notes-for-0.38.0.md

@@ -106,7 +106,7 @@ the check is now ~40% faster.
 ## Array indexing now supports fallback values
 
 The second argument to the array
-[`.get()`](Reference-manual.md#array-object) function is now returned
+[[list.get]] function is now returned
 if the specified index could not be found
 
 ```meson

docs/markdown/Release-notes-for-0.42.0.md

@@ -114,7 +114,7 @@ dependency](Dependencies.md#mpi) for more information.
 
 ## Allow excluding files or directories from `install_subdir`
 
-The [`install_subdir`](Reference-manual.md#install_subdir) command
+The [[install_subdir]] command
 accepts the new `exclude_files` and `exclude_directories` keyword
 arguments that allow specified files or directories to be excluded
 from the installed subdirectory.

docs/markdown/Release-notes-for-0.46.0.md

@@ -132,14 +132,14 @@ meson.override_find_program('mycodegen', prog_script)
 
 ## New functions: has_link_argument() and friends
 
-A new set of methods has been added to [compiler
-objects](Reference-manual.md#compiler-object) to test if the linker
+A new set of methods has been added to [[@compiler]]
+objects to test if the linker
 supports given arguments.
 
-- `has_link_argument()`
-- `has_multi_link_arguments()`
-- `get_supported_link_arguments()`
-- `first_supported_link_argument()`
+- [[compiler.has_link_argument]]
+- [[compiler.has_multi_link_arguments]]
+- [[compiler.get_supported_link_arguments]]
+- [[compiler.first_supported_link_argument]]
 
 ## "meson help" now shows command line help
 
@@ -288,9 +288,9 @@ passed via the `libraries` keyword argument.
 
 Projects that install both a static and a shared version of a library
 should use the result of
-[`both_libraries()`](Reference-manual.md#both_libraries) to the
+[[both_libraries]] to the
 pkg-config file generator or use
-[`configure_file()`](Reference-manual.md#configure_file) for more
+[[configure_file]] for more
 complicated setups.
 
 ## Improvements to pkgconfig module

docs/markdown/Release-notes-for-0.47.0.md

@@ -81,7 +81,7 @@ should be used whenever possible.
 ## New action `copy:` for `configure_file()`
 
 In addition to the existing actions `configuration:` and `command:`,
-[`configure_file()`](Reference-manual.md#configure_file) now accepts a
+[[configure_file]] now accepts a
 keyword argument `copy:` which specifies a new action to copy the file
 specified with the `input:` keyword argument to a file in the build
 directory with the name specified with the `output:` keyword argument.
@@ -92,7 +92,7 @@ can only do one action at a time.
 ## New keyword argument `encoding:` for `configure_file()`
 
 Add a new keyword to
-[`configure_file()`](Reference-manual.md#configure_file) that allows
+[[configure_file]] that allows
 the developer to specify the input and output file encoding. The
 default value is the same as before: UTF-8.
 

docs/markdown/Release-notes-for-0.48.0.md

@@ -30,7 +30,7 @@ manually changed with the new base option `b_vscrt`.
 ## Meson warns if two calls to `configure_file()` write to the same file
 
 If two calls to
-[`configure_file()`](Reference-manual.md#configure_file) write to the
+[[configure_file]] write to the
 same file Meson will print a `WARNING:` message during configuration.
 For example:
 
@@ -268,7 +268,7 @@ Now, by default `shared_library()` sets `-compatibility_version` and
 `-current_version` of a macOS dylib using the `soversion`.
 
 This can be overridden by using the `darwin_versions:` kwarg to
-[`shared_library()`](Reference-manual.md#shared_library). As usual,
+[[shared_library]]. As usual,
 you can also pass this kwarg to `library()` or `build_target()` and it
 will be used in the appropriate circumstances.
 

docs/markdown/Release-notes-for-0.50.0.md

@@ -202,8 +202,8 @@ dependency tracking does not work.
 
 ## `run_command()` accepts `env` kwarg
 
-You can pass [`environment`](Reference-manual.md#environment-object)
-object to [`run_command`](Reference-manual.md#run-command), just
+You can pass [[@env]]
+object to [[run_command]], just
 like to `test`:
 
 ```meson

docs/markdown/Release-notes-for-0.53.0.md

@@ -32,7 +32,7 @@ Meson now ships with predefined project templates for `Dlang`,
 
 ## Add a new summary() function
 
-A new function [`summary()`](Reference-manual.md#summary) has been
+A new function [[summary]] has been
 added to summarize build configuration at the end of the build
 process.
 

docs/markdown/Release-notes-for-0.55.0.md

@@ -93,9 +93,8 @@ Meson now supports passing configuration options to CMake and
 overriding certain build details extracted from the CMake subproject.
 
 The new CMake configuration options object is very similar to the
-[configuration data
-object](Reference-manual.md#configuration-data-object) object returned
-by [`configuration_data`](Reference-manual.md#configuration_data). It
+[[@cfg_data]] object object returned
+by [[configuration_data]]. It
 is generated by the `subproject_options` function
 
 All configuration options have to be set *before* the subproject is

docs/markdown/Release-notes-for-0.57.0.md

@@ -56,8 +56,8 @@ configuration dependency on the file, and so if the `COPYING` file is modified,
 Meson will automatically reconfigure, guaranteeing the build is consistent. It
 can be used for any properly encoded text files. It supports specification of
 non utf-8 encodings too, so if you're stuck with text files in a different
-encoding, it can be passed as an argument. See the [`meson`
-object](Reference-manual.md#meson-object) documentation for details.
+encoding, it can be passed as an argument. See the [[@meson]]
+documentation for details.
 
 ## meson install --dry-run
 

docs/markdown/Release-notes-for-0.59.0.md

@@ -195,9 +195,9 @@ executable(
 
 ## New `build target` methods
 
-The [`build target` object](Reference-manual.md#build-target-object) now supports
+The [[@build_tgt]] object now supports
 the following two functions, to ensure feature compatebility with
-[`external program` objects](Reference-manual.html#external-program-object):
+[[@external_program]] objects:
 
 - `found()`: Always returns `true`. This function is meant
   to make executables objects feature compatible with

docs/markdown/Rust-module.md

@@ -28,7 +28,7 @@ adding the `--test` argument to the compilation, then creates a new
 test target which calls that executable, using the rust test protocol.
 
 This accepts all of the keyword arguments as the
-[`test`](Reference-manual.md#test) function except `protocol`, it will set
+[[test]] function except `protocol`, it will set
 that automatically.
 
 Additional, test only dependencies may be passed via the dependencies

docs/markdown/Syntax.md

@@ -159,7 +159,7 @@ joined = 'C:\\foo\\bar' / 'builddir'     # => C:/foo/bar/builddir
 joined = 'C:\\foo\\bar' / 'D:\\builddir' # => D:/builddir
 ```
 
-Note that this is equivalent to using [`join_paths()`](Reference-manual.md#join_paths),
+Note that this is equivalent to using [[join_paths]],
 which was obsoleted by this operator.
 
 ### Strings running over multiple lines
@@ -260,6 +260,9 @@ string = 'xyxHelloxyx'.strip('xy')
 # 'string' now has the value 'Hello'
 ```
 
+Since 0.43.0, you can specify one positional string argument,
+and all characters in that string will be stripped.
+
 #### .to_upper(), .to_lower()
 
 ```meson
@@ -452,7 +455,7 @@ Dictionaries are immutable and do not have a guaranteed order.
 
 Dictionaries are available since 0.47.0.
 
-Visit the [Reference Manual](Reference-manual.md#dictionary-object) to read
+Visit the [[@dict]] objects page in the Reference Manual to read
 about the methods exposed by dictionaries.
 
 Since 0.49.0, you can check if a dictionary contains a key like this:

docs/markdown/Tutorial.md

@@ -160,7 +160,7 @@ executable('demo', 'main.c', dependencies : gtkdep)
 ```
 
 If your app needs to use multiple libraries, you need to use separate
-[`dependency()`](Reference-manual.md#dependency) calls for each, like so:
+[[dependency]] calls for each, like so:
 
 ```meson
 gtkdeps = [dependency('gtk+-3.0'), dependency('gtksourceview-3.0')]

docs/markdown/Unit-tests.md

@@ -36,7 +36,7 @@ By default, environment variable
 [`MALLOC_PERTURB_`](http://man7.org/linux/man-pages/man3/mallopt.3.html) is
 set to a random value between 1..255. This can help find memory leaks on
 configurations using glibc, including with non-GCC compilers. This feature
-can be disabled as discussed in [test()](Reference-manual.md#test).
+can be disabled as discussed in [[test]].
 
 ## Coverage
 

docs/markdown/Vala.md

@@ -30,7 +30,7 @@ runtime type system.
 
 ## Using libraries
 
-Meson uses the [`dependency()`](Reference-manual.md#dependency)
+Meson uses the [[dependency]]
 function to find the relevant VAPI, C headers and linker flags when it
 encounters a Vala source file in a build target. Vala needs a VAPI
 file and a C header or headers to use a library. The VAPI file helps
@@ -39,7 +39,7 @@ map Vala code to the library's C programming interface. It is the
 tool that makes finding these installed files all work seamlessly
 behind the scenes. When a `pkg-config` file doesn't exist for the
 library then the `find_library()`
-method of the [compiler object](Reference-manual.md#compiler-object)
+method of the [[@compiler]] object
 needs to be used. Examples are given later.
 
 Note Vala uses libraries that follow the C Application Binary Interface (C ABI).
@@ -86,7 +86,7 @@ standard search path and so works just as seamlessly using the
 
 ### Targeting a version of GLib
 
-Meson's [`dependency()`](Reference-manual.md#dependency) function
+Meson's [[dependency]] function
 allows a version check of a library. This is often used to check a
 minimum version is installed. When setting a minimum version of GLib,
 Meson will also pass this to the Vala compiler using the
@@ -287,7 +287,7 @@ add_project_arguments('-DFUSE_USE_VERSION=26', language: 'c')
 
 ### Changing C header and VAPI names
 
-Meson's [`library`](Reference-manual.md#library) target automatically
+Meson's [[library]] target automatically
 outputs the C header and the VAPI. They can be renamed by setting the
 `vala_header` and `vala_vapi` arguments respectively:
 

docs/markdown/Yaml-RefMan.md

@@ -0,0 +1,190 @@
+---
+title: YAML Reference manual
+short-description: Editing and maintaining the Reference manual
+...
+
+# Reference Manual
+
+The [Reference Manual](RefMan.md) is automatically generated out of YAML
+files in `docs/yaml`. This allows the Meson project to enforce a consistent
+style of the Reference Manual and enables easier style changes to the generated
+Markdown files without touching the actual documentation.
+Additionally, multiple generation backends can be supported (besides the
+Markdown generator for mesonbuild.com).
+
+The generator that reads these YAML files is located in `docs/refman`, with the
+main executable being `docs/genrefman.py`.
+
+## Linking to the Reference Manual
+
+Links to the Reference Manual can be inserted *anywhere* in the Meson docs with
+tags like this: `[[<tag>]]`. This guarantees that links remain stable (even if
+the structure of the Reference Manual changes) and are uniformly formatted
+everywhere.
+
+To link to functions, the function name should be put into the tag:
+`[[<func name>]]`.
+Methods (for all kinds of objects, including modules) can be linked to like
+this: `[[<object name>.<method name>]]`.
+To link to objects themself, the `[[@<object name>]]` syntax can be used.
+
+These tags do **not** need to be put in inline code! A hotdoc extension handles
+the formatting here. If tags need to be placed (for instance, to include reference
+directly in code blocks), the `[[#<remaining tag>]]` syntax should be used.
+
+Examples:
+- Functions: [[executable]]
+- Methods: [[meson.version]]
+- Objects: [[@str]]
+
+Now the same in a code block:
+
+```meson
+[[#@str]] [[executable]]('main', [
+    'file_@0@.cpp'.format([[#meson.version]])
+])
+```
+
+
+## Directory structure
+
+The directory structure under `docs/yaml` is important, since it determines how
+the YAML files are interpreted:
+
+- `builtins`: Documentation for builtin objects, such as `meson`
+- `elementary`: Strings, lists, integers, void, etc.
+- `objects`: All Objects returned by functions and methods but **not** modules
+- `functions`: All root meson functions ([[executable]], [[project]], etc.)
+
+Finally, modules are defined inside the `modules` subdirectory. Here, each
+module has its own directory. The module itself **must** be in a file called
+`module.yaml`. All objects returned by the module are then located next to this
+file.
+
+The name of the YAML files themself are ignored (with the exception of
+`module.yaml`) and carry no specific meaning. However, it is recommended to name
+the YAML files after the `name` entry of the object.
+
+All objects and functions whose name starts with a `_` are marked as private and
+are *not* exported in the final documents. The primary purpose of these files
+is to make inheriting functions and arguments easier.
+
+
+
+# YAML schema
+
+The YAML files themself are structured as follows:
+
+## Functions
+
+```yaml
+name: executable     # The name of the function                [required]
+returns: build_tgt   # Must be a `name` of an existing object  [required]
+description: |
+  The first line until the first dot of the description is the brief.
+  All other lines are not part of the brief and should document the function
+
+  Here the full Markdown syntax is supported, such as links, `inline code`,
+  code blocks, and references to other parts of the Reference Manual: [[@str]].
+
+  This is true for **all** description keys in all YAML files. Defining a
+  description is **always** required.
+
+since:      0.42.0       # A valid Meson version
+deprecated: 100.99.0     # A valid Meson version
+
+example: |
+  Similar to `description`, but is put under a different section and should
+  contain an example.
+
+notes:
+- A list of notes that should stand out.
+- Should be used sparingly.
+- Notes are optional.
+
+warnings:
+- Similar to notes, but a warning
+- Warnings are also optional.
+
+
+# To avoid duplicating documentation / code, argument inheritence is supported with
+# the following optional keys:
+
+posargs_inherit: _build_target_base  # Use the posargs definition of `_build_target_base` here
+optargs_inherit: _build_target_base  # Use the optargs definition of `_build_target_base` here
+varargs_inherit: _build_target_base  # Use the varargs definition of `_build_target_base` here
+kwargs_inherit: _build_target_base   # Add all kwargs of `_build_target_base` to this function
+
+
+posargs:
+  arg_name:
+    type: bool | dep           # [required]
+    description: Some text.    # [required]
+    since: 0.42.0
+    deprecated: 100.99.0
+    default: false             # Is technically supported buy should **not** be used for posargs
+
+  another_arg:
+    ...
+
+optargs:
+  optional_arg:
+    type: int                  # [required]
+    description: Hello World   # [required]
+    since: 0.42.0
+    deprecated: 100.99.0
+    default: false             # Default values can make sense here
+
+  next_arg:
+    ...
+
+varargs:
+  name: Some name                # [required]
+  type: str | list[str | int]    # [required]
+  description: Some helpful text # [required]
+  since: 0.42.0
+  deprecated: 100.99.0
+  min_varargs: 1
+  max_varargs: 21
+
+
+kwargs:
+  kwarg_name:
+    type: str                      # [required]
+    description: Meson is great!   # [required]
+    since: 0.42.0
+    deprecated: 100.99.0
+    default: false
+    required: false                # Some kwargs may be required
+```
+
+
+## Objects
+
+```yaml
+name: build_tgt                       # [required]
+long_name: Build target               # [required]
+description: Just some description.   # [required]
+example: Same as for functions
+
+# Objects can be marked as containers. In this case they can be used in a `type`
+# like this `container[held | objects]`. Currently this only makes sense for
+# lists and dicts. There is almost no reason to set this to true for other objects.
+is_container: true
+
+since:      0.42.0
+deprecated: 100.99.0
+
+# Notes and warnings work the same as with functions
+notes:
+warnings:
+
+# Inheritance is also supported for objects. Here all methods from the parent
+# object are inherited. The trick with `_private` objects also works here
+# to help with more complex structures.
+extends: tgt
+
+# Methods are a list of functions (see the previous section).
+methods:
+- ...
+```

docs/markdown/i18n-module.md

@@ -46,7 +46,7 @@ This function also defines targets for maintainers to use:
 ### i18n.merge_file()
 
 This merges translations into a text file using `msgfmt`. See
-[custom_target](Reference-manual.md#custom_target)
+[[@custom_tgt]]
 for normal keywords. In addition it accepts these keywords:
 
 * `data_dirs`: (*Added 0.41.0*) list of directories for its files (See

docs/meson.build

@@ -15,10 +15,26 @@ docs_gen = custom_target(
     build_by_default: true,
     install: false)
 
+refman_gen = custom_target(
+    'gen_refman',
+    input: files('sitemap.txt'),
+    output: ['configured_sitemap.txt', 'refman_links.json'],
+    depfile: 'reman_dep.d',
+    command: [
+        find_program('./genrefman.py'),
+        '-g', 'md',
+        '-s', '@INPUT@',
+        '-o', '@OUTPUT0@',
+        '--link-defs', '@OUTPUT1@',
+        '--depfile', '@DEPFILE@',
+        '--force-color',
+    ],
+)
+
 hotdoc = import('hotdoc')
 documentation = hotdoc.generate_doc(meson.project_name(),
     project_version: meson.project_version(),
-    sitemap: 'sitemap.txt',
+    sitemap: refman_gen[0],
     build_by_default: true,
     depends: docs_gen,
     index: 'markdown/index.md',
@@ -30,6 +46,9 @@ documentation = hotdoc.generate_doc(meson.project_name(),
     git_upload_repository: 'git@github.com:mesonbuild/mesonbuild.github.io.git',
     edit_on_github_repository: 'https://github.com/mesonbuild/meson',
     syntax_highlighting_activate: true,
+    keep_markup_in_code_blocks: true,
+    extra_extension: meson.current_source_dir() / 'extensions' / 'refman_links.py',
+    refman_data_file: refman_gen[1],
 )
 
 run_target('upload',

docs/refman/generatorbase.py

@@ -0,0 +1,71 @@
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABCMeta, abstractmethod
+import typing as T
+
+from .model import ReferenceManual, Function, Method, Object, ObjectType, NamedObject
+
+_N = T.TypeVar('_N', bound=NamedObject)
+
+class GeneratorBase(metaclass=ABCMeta):
+    def __init__(self, manual: ReferenceManual) -> None:
+        self.manual = manual
+
+    @abstractmethod
+    def generate(self) -> None:
+        pass
+
+    @staticmethod
+    def brief(raw: _N) -> str:
+        desc_lines = raw.description.split('\n')
+        brief = desc_lines[0]
+        if '.' in brief and '[[' not in brief:
+            brief = brief[:brief.index('.')]
+        return brief.strip()
+
+    @staticmethod
+    def sorted_and_filtered(raw: T.List[_N]) -> T.List[_N]:
+        def key_fn(fn: NamedObject) -> str:
+            if isinstance(fn, Method):
+                return f'1_{fn.obj.name}.{fn.name}'
+            return f'0_{fn.name}'
+        return sorted([x for x in raw if not x.hidden], key=key_fn)
+
+    @property
+    def functions(self) -> T.List[Function]:
+        return GeneratorBase.sorted_and_filtered(self.manual.functions)
+
+    @property
+    def objects(self) -> T.List[Object]:
+        return GeneratorBase.sorted_and_filtered(self.manual.objects)
+
+    @property
+    def elementary(self) -> T.List[Object]:
+        return [x for x in self.objects if x.obj_type == ObjectType.ELEMENTARY]
+
+    @property
+    def builtins(self) -> T.List[Object]:
+        return [x for x in self.objects if x.obj_type == ObjectType.BUILTIN]
+
+    @property
+    def returned(self) -> T.List[Object]:
+        return [x for x in self.objects if x.obj_type == ObjectType.RETURNED and x.defined_by_module is None]
+
+    @property
+    def modules(self) -> T.List[Object]:
+        return [x for x in self.objects if x.obj_type == ObjectType.MODULE]
+
+    def extract_returned_by_module(self, module: Object) -> T.List[Object]:
+        return [x for x in self.objects if x.obj_type == ObjectType.RETURNED and x.defined_by_module is module]

docs/refman/generatormd.py

@@ -0,0 +1,386 @@
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .generatorbase import GeneratorBase
+import re
+import json
+
+from .model import (
+    ReferenceManual,
+    Function,
+    Method,
+    Object,
+    ObjectType,
+    Type,
+    DataTypeInfo,
+    ArgBase,
+    PosArg,
+    VarArgs,
+    Kwarg,
+)
+
+from pathlib import Path
+from textwrap import dedent
+import typing as T
+
+from mesonbuild import mlog
+
+PlaceholderTypes = T.Union[None, str, bool]
+FunctionDictType = T.Dict[
+    str,
+    T.Union[
+        PlaceholderTypes,
+        T.Dict[str, PlaceholderTypes],
+        T.Dict[str, T.Dict[str, PlaceholderTypes]],
+        T.Dict[str, T.List[T.Dict[str, PlaceholderTypes]]],
+        T.List[T.Dict[str, PlaceholderTypes]],
+        T.List[str],
+    ]
+]
+
+_ROOT_BASENAME = 'RefMan'
+
+_OBJ_ID_MAP = {
+    ObjectType.ELEMENTARY: 'elementary',
+    ObjectType.BUILTIN: 'builtin',
+    ObjectType.MODULE: 'module',
+    ObjectType.RETURNED: 'returned',
+}
+
+# Indent all but the first line with 4*depth spaces.
+# This function is designed to be used with `dedent`
+# and fstrings where multiline strings are used during
+# the string interpolation.
+def smart_indent(raw: str, depth: int = 3) -> str:
+    lines = raw.split('\n')
+    first_line = lines[0]
+    lines = [' ' * (4 * depth) + x for x in lines]
+    lines[0] = first_line  # Do not indent the first line
+    return '\n'.join(lines)
+
+def code_block(code: str) -> str:
+    code = dedent(code)
+    return f'<pre><code class="language-meson">{code}</code></pre>'
+
+class GeneratorMD(GeneratorBase):
+    def __init__(self, manual: ReferenceManual, sitemap_out: Path, sitemap_in: Path, link_def_out: Path) -> None:
+        super().__init__(manual)
+        self.sitemap_out = sitemap_out.resolve()
+        self.sitemap_in = sitemap_in.resolve()
+        self.link_def_out = link_def_out.resolve()
+        self.out_dir = self.sitemap_out.parent
+        self.generated_files: T.Dict[str, str] = {}
+
+    # Utility functions
+    def _gen_filename(self, file_id: str, *, extension: str = 'md') -> str:
+        parts = file_id.split('.')
+        assert parts[0] == 'root'
+        assert all([x for x in parts])
+        parts[0] = _ROOT_BASENAME
+        parts = [re.sub(r'[0-9]+_', '', x) for x in parts]
+        return f'{"_".join(parts)}.{extension}'
+
+    def _gen_object_file_id(self, obj: Object) -> str:
+        '''
+            Deterministically generate a unique file ID for the Object.
+
+            This ID determines where the object will be inserted in the sitemap.
+        '''
+        if obj.obj_type == ObjectType.RETURNED and obj.defined_by_module is not None:
+            base = self._gen_object_file_id(obj.defined_by_module)
+            return f'{base}.{obj.name}'
+        return f'root.{_OBJ_ID_MAP[obj.obj_type]}.{obj.name}'
+
+    def _link_to_object(self, obj: T.Union[Function, Object], in_code_block: bool = False) -> str:
+        '''
+            Generate a palaceholder tag for the the function/method/object documentation.
+            This tag is then replaced in the custom hotdoc plugin.
+        '''
+        prefix = '#' if in_code_block else ''
+        if isinstance(obj, Object):
+            return f'[[{prefix}@{obj.name}]]'
+        elif isinstance(obj, Method):
+            return f'[[{prefix}{obj.obj.name}.{obj.name}]]'
+        elif isinstance(obj, Function):
+            return f'[[{prefix}{obj.name}]]'
+        else:
+            raise RuntimeError(f'Invalid argument {obj}')
+
+    def _write_file(self, data: str, file_id: str) -> None:#
+        ''' Write the data to disk ans store the id for the generated data '''
+
+        self.generated_files[file_id] = self._gen_filename(file_id)
+        out_file = self.out_dir / self.generated_files[file_id]
+        out_file.write_text(data, encoding='ascii')
+        mlog.log('Generated', mlog.bold(out_file.name))
+
+    def _write_template(self, data: T.Dict[str, T.Any], file_id: str, template_name: T.Optional[str] = None) -> None:
+        ''' Render the template mustache files and write the result '''
+        template_dir = Path(__file__).resolve().parent / 'templates'
+        template_name = template_name or file_id
+        template_name = f'{template_name}.mustache'
+        template_file = template_dir / template_name
+
+        # Import here, so that other generators don't also depend on it
+        import chevron
+        result = chevron.render(
+            template=template_file.read_text(encoding='utf-8'),
+            data=data,
+            partials_path=template_dir.as_posix(),
+            warn=True,
+        )
+
+        self._write_file(result, file_id)
+
+
+    # Actual generator functions
+    def _gen_func_or_method(self, func: Function) -> FunctionDictType:
+        def render_type(typ: Type, in_code_block: bool = False) -> str:
+            def data_type_to_str(dt: DataTypeInfo) -> str:
+                base = self._link_to_object(dt.data_type, in_code_block)
+                if dt.holds:
+                    return f'{base}[{render_type(dt.holds, in_code_block)}]'
+                return base
+            assert typ.resolved
+            return ' | '.join([data_type_to_str(x) for x in typ.resolved])
+
+        def len_stripped(s: str) -> int:
+            s = s.replace(']]', '')
+            # I know, this regex is ugly but it works.
+            return len(re.sub(r'\[\[(#|@)*([^\[])', r'\2', s))
+
+        def render_signature() -> str:
+            # Skip a lot of computations if the function does not take any arguments
+            if not any([func.posargs, func.optargs, func.kwargs, func.varargs]):
+                return f'{render_type(func.returns, True)} {func.name}()'
+
+            signature = dedent(f'''\
+                # {self.brief(func)}
+                {render_type(func.returns, True)} {func.name}(
+            ''')
+
+            # Calculate maximum lengths of the type and name
+            all_args: T.List[ArgBase] = []
+            all_args += func.posargs
+            all_args += func.optargs
+            all_args += [func.varargs] if func.varargs else []
+
+            max_type_len = 0
+            max_name_len = 0
+            if all_args:
+                max_type_len = max([len_stripped(render_type(x.type)) for x in all_args])
+                max_name_len = max([len(x.name) for x in all_args])
+
+            # Generate some common strings
+            def prepare(arg: ArgBase) -> T.Tuple[str, str, str, str]:
+                type_str = render_type(arg.type, True)
+                type_len = len_stripped(type_str)
+                type_space = ' ' * (max_type_len - type_len)
+                name_space = ' ' * (max_name_len - len(arg.name))
+                name_str = f'<b>{arg.name.replace("<", "&lt;").replace(">", "&gt;")}</b>'
+                return type_str, type_space, name_str, name_space
+
+            for i in func.posargs:
+                type_str, type_space, name_str, name_space = prepare(i)
+                signature += f'  {type_str}{type_space} {name_str},{name_space}     # {self.brief(i)}\n'
+
+            for i in func.optargs:
+                type_str, type_space, name_str, name_space = prepare(i)
+                signature += f'  {type_str}{type_space} [{name_str}],{name_space}   # {self.brief(i)}\n'
+
+            if func.varargs:
+                type_str, type_space, name_str, name_space = prepare(func.varargs)
+                signature += f'  {type_str}{type_space} {name_str}...,{name_space}  # {self.brief(func.varargs)}\n'
+
+            # Abort if there are no kwargs
+            if not func.kwargs:
+                return signature + ')'
+
+            # Only add this seperator if there are any posargs
+            if all_args:
+                signature += '\n  # Keyword arguments:\n'
+
+            # Recalculate lengths for kwargs
+            all_args = list(func.kwargs.values())
+            max_type_len = max([len_stripped(render_type(x.type)) for x in all_args])
+            max_name_len = max([len(x.name) for x in all_args])
+
+            for kwarg in self.sorted_and_filtered(list(func.kwargs.values())):
+                type_str, type_space, name_str, name_space = prepare(kwarg)
+                required = ' <i>[required]</i> ' if kwarg.required else '            '
+                required = required if any([x.required for x in func.kwargs.values()]) else ''
+                signature += f'  {name_str}{name_space} : {type_str}{type_space} {required} # {self.brief(kwarg)}\n'
+
+            return signature + ')'
+
+        def gen_arg_data(arg: T.Union[PosArg, Kwarg, VarArgs], *, optional: bool = False) -> T.Dict[str, PlaceholderTypes]:
+            data: T.Dict[str, PlaceholderTypes] = {
+                'name': arg.name,
+                'type': render_type(arg.type),
+                'description': arg.description,
+                'since': arg.since or None,
+                'deprecated': arg.deprecated or None,
+                'optional': optional,
+                'default': None,
+            }
+
+            if isinstance(arg, VarArgs):
+                data.update({
+                    'min': str(arg.min_varargs) if arg.min_varargs > 0 else '0',
+                    'max': str(arg.max_varargs) if arg.max_varargs > 0 else 'infinity',
+                })
+            if isinstance(arg, (Kwarg, PosArg)):
+                data.update({'default': arg.default or None})
+            if isinstance(arg, Kwarg):
+                data.update({'required': arg.required})
+            return data
+
+        mname = f'\\{func.name}' if func.name == '[index]' else func.name
+
+        data: FunctionDictType = {
+            'name': f'{func.obj.name}.{mname}' if isinstance(func, Method) else func.name,
+            'base_level': '##' if isinstance(func, Method) else '#',
+            'type_name_upper': 'Method' if isinstance(func, Method) else 'Function',
+            'type_name': 'method' if isinstance(func, Method) else 'function',
+            'description': func.description,
+            'notes': func.notes,
+            'warnings': func.warnings,
+            'example': func.example or None,
+            'signature_level': 'h4' if isinstance(func, Method) else 'h3',
+            'signature': render_signature(),
+            'has_args': bool(func.posargs or func.optargs or func.kwargs or func.varargs),
+            # Merge posargs and optargs by generating the *[optional]* tag for optargs
+            'posargs': {
+                'args': [gen_arg_data(x) for x in func.posargs] + [gen_arg_data(x, optional=True) for x in func.optargs]
+            } if func.posargs or func.optargs else None,
+            'kwargs':  {'args': [gen_arg_data(x) for x in self.sorted_and_filtered(list(func.kwargs.values()))]} if func.kwargs else None,
+            'varargs': gen_arg_data(func.varargs) if func.varargs else None,
+
+            # For the feature taggs template
+            'since': func.since or None,
+            'deprecated': func.deprecated or None,
+            'optional': False,
+            'default': None
+        }
+
+        return data
+
+    def _write_object(self, obj: Object) -> None:
+        data = {
+            'name': obj.name,
+            'description': obj.description,
+            'notes': obj.notes,
+            'warnings': obj.warnings,
+            'long_name': obj.long_name,
+            'obj_type_name': _OBJ_ID_MAP[obj.obj_type].capitalize(),
+            'example': obj.example or None,
+            'has_methods': bool(obj.methods),
+            'has_inherited_methods': bool(obj.inherited_methods),
+            'has_subclasses': bool(obj.extended_by),
+            'is_returned': bool(obj.returned_by),
+            'extends': obj.extends_obj.name if obj.extends_obj else None,
+            'returned_by': [self._link_to_object(x) for x in self.sorted_and_filtered(obj.returned_by)],
+            'extended_by': [self._link_to_object(x) for x in self.sorted_and_filtered(obj.extended_by)],
+            'methods': [self._gen_func_or_method(m) for m in self.sorted_and_filtered(obj.methods)],
+            'inherited_methods': [self._gen_func_or_method(m) for m in self.sorted_and_filtered(obj.inherited_methods)],
+        }
+
+        self._write_template(data, self._gen_object_file_id(obj), 'object')
+
+    def _write_functions(self) -> None:
+        data = {'functions': [self._gen_func_or_method(x) for x in self.functions]}
+        self._write_template(data, 'root.functions')
+
+    def _root_refman_docs(self) -> None:
+        def gen_obj_links(objs: T.List[Object]) -> T.List[T.Dict[str, str]]:
+            ret: T.List[T.Dict[str, str]] = []
+            for o in objs:
+                ret += [{'indent': '', 'link': self._link_to_object(o), 'brief': self.brief(o)}]
+                for m in self.sorted_and_filtered(o.methods):
+                    ret += [{'indent': '  ', 'link': self._link_to_object(m), 'brief': self.brief(m)}]
+                if o.obj_type == ObjectType.MODULE and self.extract_returned_by_module(o):
+                    tmp = gen_obj_links(self.extract_returned_by_module(o))
+                    tmp = [{**x, 'indent': '  ' + x['indent']} for x in tmp]
+                    ret += [{'indent': '  ', 'link': '**New objects:**', 'brief': ''}]
+                    ret += [*tmp]
+            return ret
+
+        data = {
+            'root': self._gen_filename('root'),
+            'elementary': gen_obj_links(self.elementary),
+            'returned': gen_obj_links(self.returned),
+            'builtins': gen_obj_links(self.builtins),
+            'modules': gen_obj_links(self.modules),
+            'functions': [{'indent': '', 'link': self._link_to_object(x), 'brief': self.brief(x)} for x in self.functions],
+        }
+
+        dummy = {'root': self._gen_filename('root')}
+
+        self._write_template(data, 'root')
+        self._write_template({**dummy, 'name': 'Elementary types'}, f'root.{_OBJ_ID_MAP[ObjectType.ELEMENTARY]}', 'dummy')
+        self._write_template({**dummy, 'name': 'Builtin objects'},  f'root.{_OBJ_ID_MAP[ObjectType.BUILTIN]}',    'dummy')
+        self._write_template({**dummy, 'name': 'Returned objects'}, f'root.{_OBJ_ID_MAP[ObjectType.RETURNED]}',   'dummy')
+        self._write_template({**dummy, 'name': 'Modules'},          f'root.{_OBJ_ID_MAP[ObjectType.MODULE]}',     'dummy')
+
+
+    def generate(self) -> None:
+        mlog.log('Generating markdown files...')
+        with mlog.nested():
+            self._write_functions()
+            for obj in self.objects:
+                self._write_object(obj)
+            self._root_refman_docs()
+            self._configure_sitemap()
+            self._generate_link_def()
+
+    def _configure_sitemap(self) -> None:
+        '''
+            Replaces the `@REFMAN_PLACEHOLDER@` placeholder with the reference
+            manual sitemap. The structure of the sitemap is derived from the
+            file IDs.
+        '''
+        raw = self.sitemap_in.read_text(encoding='utf-8')
+        out = ''
+        for l in raw.split('\n'):
+            if '@REFMAN_PLACEHOLDER@' not in l:
+                out += f'{l}\n'
+                continue
+            mlog.log('Generating', mlog.bold(self.sitemap_out.as_posix()))
+            base_indent = l.replace('@REFMAN_PLACEHOLDER@', '')
+            for k in sorted(self.generated_files.keys()):
+                indent = base_indent + '\t' * k.count('.')
+                out += f'{indent}{self.generated_files[k]}\n'
+        self.sitemap_out.write_text(out, encoding='utf-8')
+
+    def _generate_link_def(self) -> None:
+        '''
+            Generate the link definition file for the refman_links hotdoc
+            plugin. The plugin is then responsible for replacing the [[tag]]
+            tags with custom HTML elements.
+        '''
+        data: T.Dict[str, str] = {}
+
+        # Objects and methods
+        for obj in self.objects:
+            obj_file = self._gen_filename(self._gen_object_file_id(obj), extension='html')
+            data[f'@{obj.name}'] = obj_file
+            for m in obj.methods:
+                data[f'{obj.name}.{m.name}'] = f'{obj_file}#{obj.name}{m.name}'
+
+        # Functions
+        funcs_file = self._gen_filename('root.functions', extension='html')
+        for fn in self.functions:
+            data[fn.name] = f'{funcs_file}#{fn.name}'
+
+        self.link_def_out.write_text(json.dumps(data, indent=2), encoding='utf-8')

docs/refman/generatorpickle.py

@@ -0,0 +1,26 @@
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pickle
+from pathlib import Path
+from .generatorbase import GeneratorBase
+from .model import ReferenceManual
+
+class GeneratorPickle(GeneratorBase):
+    def __init__(self, manual: ReferenceManual, outpath: Path) -> None:
+        self.out = outpath
+        super().__init__(manual)
+
+    def generate(self) -> None:
+        self.out.write_bytes(pickle.dumps(self.manual))

docs/refman/generatorprint.py

@@ -0,0 +1,87 @@
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .generatorbase import GeneratorBase
+from .model import ReferenceManual, Object, Function, DataTypeInfo, Type, ObjectType
+
+from mesonbuild import mlog
+import typing as T
+
+def my_nested() -> T.ContextManager[None]:
+    prefix = '|' * len(mlog.log_depth)
+    return mlog.nested(prefix)
+
+class GeneratorPrint(GeneratorBase):
+    def _types_to_string(self, typ: Type) -> str:
+        def _data_type_to_str(dt: DataTypeInfo) -> str:
+            if dt.holds:
+                return f'{dt.data_type.name}[{self._types_to_string(dt.holds)}]'
+            return dt.data_type.name
+        return ' | '.join([_data_type_to_str(x) for x in typ.resolved])
+
+    def _generate_function(self, func: Function) -> None:
+        mlog.log()
+        mlog.log('Function', mlog.bold(func.name))
+        with my_nested():
+            desc = func.description
+            if '\n' in desc:
+                desc = desc[:desc.index('\n')]
+            mlog.log('Description:', mlog.bold(desc))
+            mlog.log('Return type:', mlog.bold(self._types_to_string(func.returns)))
+            mlog.log('Pos args:   ', mlog.bold(str([x.name for x in func.posargs])))
+            mlog.log('Opt args:   ', mlog.bold(str([x.name for x in func.optargs])))
+            mlog.log('Varargs:    ', mlog.bold(func.varargs.name if func.varargs is not None else 'null'))
+            mlog.log('Kwargs:     ', mlog.bold(str(list(func.kwargs.keys()))))
+
+    def _generate_object(self, obj: Object) -> None:
+        tags = []
+        tags += [{
+            ObjectType.ELEMENTARY: mlog.yellow('[elementary]'),
+            ObjectType.BUILTIN: mlog.green('[builtin]'),
+            ObjectType.MODULE: mlog.blue('[module]'),
+            ObjectType.RETURNED: mlog.cyan('[returned]'),
+        }[obj.obj_type]]
+        if obj.is_container:
+            tags += [mlog.red('[container]')]
+        mlog.log()
+        mlog.log('Object', mlog.bold(obj.name), *tags)
+        with my_nested():
+            desc = obj.description
+            if '\n' in desc:
+                desc = desc[:desc.index('\n')]
+            mlog.log('Description:', mlog.bold(desc))
+            mlog.log('Returned by:', mlog.bold(str([x.name for x in obj.returned_by])))
+            mlog.log('Methods:')
+            with my_nested():
+                for m in obj.methods:
+                    self._generate_function(m)
+
+    def generate(self) -> None:
+        mlog.log('\n\n', mlog.bold('=== Functions ==='), '\n')
+        for f in self.functions:
+            self._generate_function(f)
+        mlog.log('\n\n', mlog.bold('=== Elementary ==='), '\n')
+        for obj in self.elementary:
+            self._generate_object(obj)
+        mlog.log('\n\n', mlog.bold('=== Builtins ==='), '\n')
+        for obj in self.builtins:
+            self._generate_object(obj)
+        mlog.log('\n\n', mlog.bold('=== Returned objects ==='), '\n')
+        for obj in self.returned:
+            self._generate_object(obj)
+        mlog.log('\n\n', mlog.bold('=== Modules ==='), '\n')
+        for obj in self.modules:
+            self._generate_object(obj)
+            for mod_obj in self.extract_returned_by_module(obj):
+                self._generate_object(mod_obj)

docs/refman/loaderbase.py

@@ -0,0 +1,216 @@
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABCMeta, abstractmethod
+from pathlib import Path
+import re
+import typing as T
+
+from .model import (
+    NamedObject,
+    FetureCheck,
+    ArgBase,
+    PosArg,
+    DataTypeInfo,
+    Type,
+    Function,
+    Method,
+    Object,
+    ObjectType,
+    ReferenceManual,
+)
+
+from mesonbuild import mlog
+
+class _Resolver:
+    def __init__(self) -> None:
+        self.type_map: T.Dict[str, Object] = {}
+        self.func_map: T.Dict[str, T.Union[Function, Method]] = {}
+        self.processed_funcs: T.Set[str] = set()
+
+    def _validate_named_object(self, obj: NamedObject) -> None:
+        name_regex = re.compile(r'[a-zA-Z0-9_]+')
+        obj.name = obj.name.strip()
+        obj.description = obj.description.strip()
+        assert obj.name and obj.description, 'Both name and description must be set'
+        assert obj.name.islower(), f'Object names must be lower case ({obj.name})'
+        assert name_regex.match(obj.name) or obj.name == '[index]', f'Invalid name {obj.name}'
+
+    def _validate_feature_check(self, obj: FetureCheck) -> None:
+        meson_version_reg = re.compile(r'[0-9]+\.[0-9]+\.[0-9]+')
+        obj.since = obj.since.strip()
+        obj.deprecated = obj.deprecated.strip()
+        if obj.since:
+            assert meson_version_reg.match(obj.since)
+        if obj.deprecated:
+            assert meson_version_reg.match(obj.deprecated)
+
+    def _resolve_type(self, raw: str) -> Type:
+        typ = Type(raw)
+        # We can't use `types = raw.split('|')`, because of `list[str | env]`
+        types: T.List[str] = ['']
+        stack = 0
+        for c in raw:
+            if stack == 0 and c == '|':
+                types += ['']
+                continue
+            if c == '[':
+                stack += 1
+            if c == ']':
+                stack -= 1
+            types[-1] += c
+        types = [x.strip() for x in types]
+        for t in types:
+            t = t.strip()
+            idx = t.find('[')
+            base_type = t
+            held_type = None
+            if idx > 0:
+                base_type = t[:idx]
+                held_type = self._resolve_type(t[idx+1:-1])
+            assert base_type in self.type_map, f'No known object {t}'
+            obj = self.type_map[base_type]
+            typ.resolved += [DataTypeInfo(obj, held_type)]
+        return typ
+
+    def _validate_func(self, func: T.Union[Function, Method]) -> None:
+        # Always run basic checks, since they also slightly post-process (strip) some strings
+        self._validate_named_object(func)
+        self._validate_feature_check(func)
+
+        func_id = f'{func.obj.name}.{func.name}' if isinstance(func, Method) else func.name
+        if func_id in self.processed_funcs:
+            return
+
+        func.returns = self._resolve_type(func.returns.raw)
+
+        all_args: T.List[ArgBase] = []
+        all_args += func.posargs
+        all_args += func.optargs
+        all_args += func.kwargs.values()
+        all_args += [func.varargs] if func.varargs else []
+
+        for arg in all_args:
+            arg.type = self._resolve_type(arg.type.raw)
+
+        # Handle returned_by
+        for obj in func.returns.resolved:
+            obj.data_type.returned_by += [func]
+
+        # Handle kwargs inehritance
+        for base_name in func.kwargs_inherit:
+            base_name = base_name.strip()
+            assert base_name in self.func_map, f'Unknown base function `{base_name}` for {func.name}'
+            base = self.func_map[base_name]
+            if base_name not in self.processed_funcs:
+                self._validate_func(base)
+
+            curr_keys = set(func.kwargs.keys())
+            base_keys = set(base.kwargs.keys())
+
+            # Calculate the missing kwargs from the current set
+            missing = {k: v for k, v in base.kwargs.items() if k in base_keys - curr_keys}
+            func.kwargs.update(missing)
+
+        # Handloe other args inheritance
+        _T = T.TypeVar('_T', bound=T.Union[ArgBase, T.List[PosArg]])
+        def resolve_inherit(name: str, curr: _T, resolver: T.Callable[[Function], _T]) -> _T:
+            if name and not curr:
+                name = name.strip()
+                assert name in self.func_map, f'Unknown base function `{name}` for {func.name}'
+                if name not in self.processed_funcs:
+                    self._validate_func(self.func_map[name])
+                ref_args = resolver(self.func_map[name])
+                assert ref_args is not None, f'Inherited function `{name}` does not have inherited args set'
+                return ref_args
+            return curr
+
+        func.posargs = resolve_inherit(func.posargs_inherit, func.posargs, lambda x: x.posargs)
+        func.optargs = resolve_inherit(func.optargs_inherit, func.optargs, lambda x: x.optargs)
+        func.varargs = resolve_inherit(func.varargs_inherit, func.varargs, lambda x: x.varargs)
+
+        self.processed_funcs.add(func_id)
+
+    def validate_and_resolve(self, manual: ReferenceManual) -> ReferenceManual:
+        mlog.log('Validating loaded manual...')
+
+        # build type map and func map for methods
+        for obj in manual.objects:
+            assert obj.name not in self.type_map, f'Duplicate object name {obj.name}'
+            self.type_map[obj.name] = obj
+            for m in obj.methods:
+                mid = f'{obj.name}.{m.name}'
+                assert mid not in self.type_map, f'Duplicate metod {mid}'
+                self.func_map[mid] = m
+
+        # Build func map for functions
+        for func in manual.functions:
+            assert func.name not in [*self.func_map.keys()], f'Duplicate function {func.name}'
+            self.func_map[func.name] = func
+
+        mlog.log('Validating functions...')
+        for func in manual.functions:
+            mlog.log(' -- validating', mlog.bold(func.name))
+            self._validate_func(func)
+
+        mlog.log('Validating objects...')
+        for obj in manual.objects:
+            mlog.log(' -- validating', mlog.bold(obj.name))
+            self._validate_named_object(obj)
+            self._validate_feature_check(obj)
+            # Resolve and validate inheritence
+            if obj.extends:
+                assert obj.extends in self.type_map, f'Unknown extends object {obj.extends} in {obj.name}'
+                obj.extends_obj = self.type_map[obj.extends]
+                obj.extends_obj.extended_by += [obj]
+            # Only returned objects can be associated with module
+            if obj.obj_type is not ObjectType.RETURNED:
+                assert obj.defined_by_module is None
+            for m in obj.methods:
+                assert m.obj is obj
+                self._validate_func(m)
+
+        # Resolve inherited methods
+        for obj in manual.objects:
+            inherited_methods = obj.inherited_methods
+            curr = obj.extends_obj
+            while curr is not None:
+                inherited_methods += curr.methods
+                curr = curr.extends_obj
+        return manual
+
+class LoaderBase(metaclass=ABCMeta):
+    def __init__(self) -> None:
+        self._input_files: T.List[Path] = []
+
+    @property
+    def input_files(self) -> T.List[Path]:
+        return list(self._input_files)
+
+    def read_file(self, f: Path) -> str:
+        assert f.exists()
+        assert f.is_file()
+        self._input_files += [f.resolve()]
+        return f.read_text(encoding='utf-8')
+
+    @abstractmethod
+    def load_impl(self) -> ReferenceManual:
+        pass
+
+    def load(self) -> ReferenceManual:
+        self._input_files = []  # Reset input files
+        manual = self.load_impl()
+        resolver = _Resolver()
+        with mlog.nested():
+            return resolver.validate_and_resolve(manual)

docs/refman/loaderyaml.py

@@ -0,0 +1,203 @@
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .loaderbase import LoaderBase
+from .model import (
+    Type,
+    PosArg,
+    VarArgs,
+    Kwarg,
+    Function,
+    Method,
+    ObjectType,
+    Object,
+    ReferenceManual,
+)
+
+from mesonbuild import mlog
+from mesonbuild import mesonlib
+
+from strictyaml import Map, MapPattern, Optional, Str, Seq, Int, Bool, load, EmptyList, OrValidator
+from pathlib import Path
+import typing as T
+
+d_named_object = {
+    'name': Str(),
+    'description': Str(),
+}
+
+d_feture_check = {
+    Optional('since', default=''): Str(),
+    Optional('deprecated', default=''): Str(),
+}
+
+s_posarg = Map({
+    **d_feture_check,
+    'description': Str(),
+    'type': Str(),
+    Optional('default', default=''): Str(),
+})
+
+s_varargs = Map({
+    **d_named_object, **d_feture_check,
+    'type': Str(),
+    Optional('min_varargs', default=-1): Int(),
+    Optional('max_varargs', default=-1): Int(),
+})
+
+s_kwarg = Map({
+    **d_feture_check,
+    'type': Str(),
+    'description': Str(),
+    Optional('required', default=False): Bool(),
+    Optional('default', default=''): Str(),
+})
+
+s_function = Map({
+    **d_named_object, **d_feture_check,
+    'returns': Str(),
+    Optional('notes', default=[]): OrValidator(Seq(Str()), EmptyList()),
+    Optional('warnings', default=[]): OrValidator(Seq(Str()), EmptyList()),
+    Optional('example', default=''): Str(),
+    Optional('posargs'): MapPattern(Str(), s_posarg),
+    Optional('optargs'): MapPattern(Str(), s_posarg),
+    Optional('varargs'): s_varargs,
+    Optional('posargs_inherit', default=''): Str(),
+    Optional('optargs_inherit', default=''): Str(),
+    Optional('varargs_inherit', default=''): Str(),
+    Optional('kwargs'): MapPattern(Str(), s_kwarg),
+    Optional('kwargs_inherit', default=[]): OrValidator(OrValidator(Seq(Str()), EmptyList()), Str()),
+})
+
+s_object = Map({
+    **d_named_object, **d_feture_check,
+    'long_name': Str(),
+    Optional('extends', default=''): Str(),
+    Optional('notes', default=[]): OrValidator(Seq(Str()), EmptyList()),
+    Optional('warnings', default=[]): OrValidator(Seq(Str()), EmptyList()),
+    Optional('example', default=''): Str(),
+    Optional('methods'): Seq(s_function),
+    Optional('is_container', default=False): Bool()
+})
+
+class LoaderYAML(LoaderBase):
+    def __init__(self, yaml_dir: Path) -> None:
+        super().__init__()
+        self.yaml_dir = yaml_dir
+        self.func_dir = self.yaml_dir / 'functions'
+        self.elem_dir = self.yaml_dir / 'elementary'
+        self.objs_dir = self.yaml_dir / 'objects'
+        self.builtin_dir = self.yaml_dir / 'builtins'
+        self.modules_dir = self.yaml_dir / 'modules'
+
+    def _process_function_base(self, raw: T.OrderedDict, obj: T.Optional[Object] = None) -> Function:
+        # Handle arguments
+        posargs = raw.pop('posargs', {})
+        optargs = raw.pop('optargs', {})
+        varargs = raw.pop('varargs', None)
+        kwargs = raw.pop('kwargs', {})
+
+        # Fix kwargs_inherit
+        if isinstance(raw['kwargs_inherit'], str):
+            raw['kwargs_inherit'] = [raw['kwargs_inherit']]
+
+        # Parse args
+        posargs_mapped: T.List[PosArg] = []
+        optargs_mapped: T.List[PosArg] = []
+        varargs_mapped: T.Optional[VarArgs] = None
+        kwargs_mapped: T.Dict[str, Kwarg] = {}
+
+        for k, v in posargs.items():
+            v['type'] = Type(v['type'])
+            posargs_mapped += [PosArg(name=k, **v)]
+
+        for k, v in optargs.items():
+            v['type'] = Type(v['type'])
+            optargs_mapped += [PosArg(name=k, **v)]
+
+        for k, v in kwargs.items():
+            v['type'] = Type(v['type'])
+            kwargs_mapped[k] = Kwarg(name=k, **v)
+
+        if varargs is not None:
+            varargs['type'] = Type(varargs['type'])
+            varargs_mapped = VarArgs(**varargs)
+
+        raw['returns'] = Type(raw['returns'])
+
+        # Build function object
+        if obj is not None:
+            return Method(
+                posargs=posargs_mapped,
+                optargs=optargs_mapped,
+                varargs=varargs_mapped,
+                kwargs=kwargs_mapped,
+                obj=obj,
+                **raw,
+            )
+        return Function(
+            posargs=posargs_mapped,
+            optargs=optargs_mapped,
+            varargs=varargs_mapped,
+            kwargs=kwargs_mapped,
+            **raw,
+        )
+
+    def _load_function(self, path: Path, obj: T.Optional[Object] = None) -> Function:
+        path_label = path.relative_to(self.yaml_dir).as_posix()
+        mlog.log('Loading', mlog.bold(path_label))
+        raw = load(self.read_file(path), s_function, label=path_label).data
+        return self._process_function_base(raw)
+
+    def _load_object(self, obj_type: ObjectType, path: Path) -> Object:
+        path_label = path.relative_to(self.yaml_dir).as_posix()
+        mlog.log(f'Loading', mlog.bold(path_label))
+        raw = load(self.read_file(path), s_object, label=path_label).data
+
+        def as_methods(mlist: T.List[Function]) -> T.List[Method]:
+            res: T.List[Method] = []
+            for i in mlist:
+                assert isinstance(i, Method)
+                res += [i]
+            return res
+
+        methods = raw.pop('methods', [])
+        obj = Object(methods=[], obj_type=obj_type, **raw)
+        obj.methods = as_methods([self._process_function_base(x, obj) for x in methods])
+        return obj
+
+    def _load_module(self, path: Path) -> T.List[Object]:
+        assert path.is_dir()
+        module = self._load_object(ObjectType.MODULE, path / 'module.yaml')
+        objs = []
+        for p in path.iterdir():
+            if p.name == 'module.yaml':
+                continue
+            obj = self._load_object(ObjectType.RETURNED, p)
+            obj.defined_by_module = module
+            objs += [obj]
+        return [module, *objs]
+
+    def load_impl(self) -> ReferenceManual:
+        mlog.log('Loading YAML refererence manual')
+        with mlog.nested():
+            return ReferenceManual(
+                functions=[self._load_function(x) for x in self.func_dir.iterdir()],
+                objects=mesonlib.listify([
+                    [self._load_object(ObjectType.ELEMENTARY, x) for x in self.elem_dir.iterdir()],
+                    [self._load_object(ObjectType.RETURNED, x) for x in self.objs_dir.iterdir()],
+                    [self._load_object(ObjectType.BUILTIN, x) for x in self.builtin_dir.iterdir()],
+                    [self._load_module(x) for x in self.modules_dir.iterdir()]
+                ], flatten=True)
+            )

docs/refman/main.py

@@ -0,0 +1,75 @@
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+import argparse
+import typing as T
+
+from mesonbuild import mlog
+
+from .loaderbase import LoaderBase
+from .loaderyaml import LoaderYAML
+
+from .generatorbase import GeneratorBase
+from .generatorprint import GeneratorPrint
+from .generatorpickle import GeneratorPickle
+from .generatormd import GeneratorMD
+
+meson_root = Path(__file__).absolute().parents[2]
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description='Meson reference manual generator')
+    parser.add_argument('-l', '--loader', type=str, default='yaml', choices=['yaml'], help='Information loader backend')
+    parser.add_argument('-g', '--generator', type=str, choices=['print', 'pickle', 'md'], required=True, help='Generator backend')
+    parser.add_argument('-s', '--sitemap', type=Path, default=meson_root / 'docs' / 'sitemap.txt', help='Path to the input sitemap.txt')
+    parser.add_argument('-o', '--out', type=Path, required=True, help='Output directory for generated files')
+    parser.add_argument('--link-defs', type=Path, help='Output file for the MD generator link definition file')
+    parser.add_argument('--depfile', type=Path, default=None, help='Set to generate a depfile')
+    parser.add_argument('--force-color', action='store_true', help='Force enable colors')
+    args = parser.parse_args()
+
+    if args.force_color:
+        mlog.colorize_console = lambda: True
+
+    loaders: T.Dict[str, T.Callable[[], LoaderBase]] = {
+        'yaml': lambda: LoaderYAML(meson_root / 'docs' / 'yaml'),
+    }
+
+    loader = loaders[args.loader]()
+    refMan = loader.load()
+
+    generators: T.Dict[str, T.Callable[[], GeneratorBase]] = {
+        'print': lambda: GeneratorPrint(refMan),
+        'pickle': lambda: GeneratorPickle(refMan, args.out),
+        'md': lambda: GeneratorMD(refMan, args.out, args.sitemap, args.link_defs),
+    }
+    generator = generators[args.generator]()
+
+    # Generate the depfile if required
+    if args.depfile is not None:
+        assert isinstance(args.depfile, Path)
+        assert isinstance(args.out, Path)
+
+        # Also add all files of this package
+        script_files = list(Path(__file__).resolve().parent.glob('**/*.py'))
+        templates = list(Path(__file__).resolve().parent.glob('**/*.mustache'))
+
+        out_text = f'{args.out.resolve().as_posix()}: \\\n'
+        for input in loader.input_files + script_files + templates:
+            out_text += f'    {input.resolve().as_posix():<93} \\\n'
+
+        args.depfile.write_text(out_text, encoding='utf-8')
+
+    generator.generate()
+    return 0

docs/refman/model.py

@@ -0,0 +1,113 @@
+# Copyright 2021 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from enum import Enum
+import typing as T
+
+# Utils
+@dataclass
+class NamedObject:
+    name: str
+    description: str
+
+    @property
+    def hidden(self) -> bool:
+        return self.name.startswith('_')
+
+@dataclass
+class FetureCheck:
+    since: str
+    deprecated: str
+
+@dataclass
+class DataTypeInfo:
+    data_type: 'Object'
+    holds: T.Optional['Type']
+
+@dataclass
+class Type:
+    raw: str
+    resolved: T.List[DataTypeInfo] = field(init=False, default_factory=list)
+
+
+# Arguments
+@dataclass
+class ArgBase(NamedObject):
+    type: Type
+
+@dataclass
+class PosArg(ArgBase, FetureCheck):
+    default: str
+
+@dataclass
+class VarArgs(ArgBase, FetureCheck):
+    min_varargs: int
+    max_varargs: int
+
+@dataclass
+class Kwarg(ArgBase, FetureCheck):
+    required: bool
+    default: str
+
+
+# Function
+@dataclass
+class Function(NamedObject, FetureCheck):
+    notes: T.List[str]
+    warnings: T.List[str]
+    returns: Type
+    example: str
+    posargs: T.List[PosArg]
+    optargs: T.List[PosArg]
+    varargs: T.Optional[VarArgs]
+    kwargs: T.Dict[str, Kwarg]
+    posargs_inherit: str
+    optargs_inherit: str
+    varargs_inherit: str
+    kwargs_inherit: T.List[str]
+
+@dataclass
+class Method(Function):
+    obj: 'Object'
+
+
+# Types and objects
+class ObjectType(Enum):
+    ELEMENTARY = 0
+    BUILTIN = 1
+    MODULE = 2
+    RETURNED = 3
+
+@dataclass
+class Object(NamedObject, FetureCheck):
+    notes: T.List[str]
+    warnings: T.List[str]
+    long_name: str
+    example: str
+    obj_type: ObjectType
+    methods: T.List[Method]
+    is_container: bool
+    extends: str
+    extends_obj: T.Optional['Object'] = None
+    defined_by_module: T.Optional['Object'] = None
+    returned_by: T.List[T.Union[Function, Method]] = field(default_factory=list)
+    extended_by: T.List['Object'] = field(default_factory=list)
+    inherited_methods: T.List[Method] = field(default_factory=list)
+
+# ROOT
+@dataclass
+class ReferenceManual:
+    functions: T.List[Function]
+    objects: T.List[Object]

docs/refman/templates/args.mustache

@@ -0,0 +1,28 @@
+<!-- Hotdoc / markdown inserts <p> around the table elements. Override the margin to make them invisible -->
+<style>
+  .nomargin p:last-child { margin-bottom: 0px !important; }
+</style>
+<table>
+  <thead>
+    <tr>
+      <th style="white-space: nowrap; text-align: center;">Name</th>
+      <th style="white-space: nowrap; text-align: center;">Type</th>
+      <th style="width: 56%;">Description</th>
+      <th style="white-space: nowrap; text-align: center; width: 0px;">Tags</th>
+    </tr>
+  </thead>
+  <tbody class="nomargin">
+    {{#args}}
+    <tr>
+      <td style="white-space: nowrap; text-align: center; padding: 6px;"><code class="language-meson">{{name}}</code></td>
+      <td style="white-space: revert; text-align: center; padding: 6px; word-wrap: break-word;">{{&type}}</td>
+      <!-- This suboptimal formating is required to ensure hotdoc correctly generates the HTML -->
+      <td style="width: 56%; padding: 6px;">
+
+{{&description}}
+</td>
+      <td style="white-space: nowrap; text-align: center; padding: 6px; width: 0px;">{{>taggs}}</td>
+    </tr>
+    {{/args}}
+  </tbody>
+</table>

docs/refman/templates/dummy.mustache

@@ -0,0 +1,8 @@
+---
+short-description: {{name}}
+render-subpages: true
+...
+# {{name}}
+
+See the [root manual document]({{root}}) for
+a general overview.

docs/refman/templates/func.mustache

@@ -0,0 +1,55 @@
+{{base_level}}# {{name}}()
+
+{{&description}}
+
+<p style="padding: 5px; margin: 0px;"></p> <!-- A bit of space because we remove the top margin below -->
+<div style="display: flex;">
+  <{{signature_level}} style="margin-top: 0px;">Signature</{{signature_level}}>
+  <div style="flex-grow: 1;"></div>
+  <div>{{>taggs}}</div>
+</div>
+
+<pre><code class="language-meson">{{&signature}}</code></pre>
+
+{{#example}}
+  <p style="padding: 5px; margin: 0px;"></p> <!-- A bit more space -->
+
+  {{base_level}}## Example
+
+{{&example}}
+{{/example}}
+
+{{>notes}}
+
+{{#has_args}}
+  <p style="padding: 5px; margin: 0px;"></p> <!-- A bit more space -->
+
+  {{base_level}}## Arguments
+{{/has_args}}
+
+{{#posargs}}
+  The {{type_name}} `{{name}}()` accepts the following positional arguments:
+
+  {{>args}}
+
+  <p style="padding: 5px; margin: 0px;"></p> <!-- Extra space -->
+{{/posargs}}
+
+{{#varargs}}
+  {{#posargs}}Additionally, the{{/posargs}}{{^posargs}}The{{/posargs}}
+  {{type_name}} accepts between `{{min}}` and `{{max}}` variadic
+  arguments (`{{name}}...`) of type <code>{{&type}}</code>.
+
+  {{&description}}
+
+  {{>taggs}}
+
+  <p style="padding: 5px; margin: 0px;"></p> <!-- Extra space -->
+{{/varargs}}
+
+{{#kwargs}}
+  {{#posargs}}Finally, `{{name}}()`{{/posargs}}{{^posargs}}The {{type_name}} `{{name}}()`{{/posargs}}
+  accepts the following keyword arguments:
+
+  {{>args}}
+{{/kwargs}}

docs/refman/templates/notes.mustache

@@ -0,0 +1,14 @@
+{{#notes}}
+<div class="alert alert-info">
+  <strong>Note:</strong>
+
+{{&.}}
+</div>
+{{/notes}}
+{{#warnings}}
+<div class="alert alert-warning">
+  <strong>Warning:</strong>
+
+{{&.}}
+</div>
+{{/warnings}}

docs/refman/templates/object.mustache

@@ -0,0 +1,62 @@
+---
+short-description: "{{obj_type_name}} object: {{long_name}}"
+title: {{name}}{{#extends}} (extends {{.}}){{/extends}}
+render-subpages: false
+...
+# {{long_name}} (`{{name}}`{{#extends}} extends [[@{{.}}]]{{/extends}})
+
+{{&description}}
+
+{{#has_subclasses}}
+## Extended by
+
+{{long_name}} is extended by the following subtypes:
+{{#extended_by}}
+- {{&.}}
+{{/extended_by}}
+{{/has_subclasses}}
+
+{{#is_returned}}
+## Returned by
+
+{{long_name}} objects are returned by the following functions and methods:
+{{#returned_by}}
+- {{&.}}
+{{/returned_by}}
+{{/is_returned}}
+
+{{#example}}
+## Example
+
+<pre><code class="language-meson">{{&example}}</code></pre>
+{{/example}}
+
+{{>notes}}
+
+{{#has_methods}}
+## {{long_name}} methods
+
+{{#methods}}
+<p style="padding: 7.5px; margin: 0px;"></p>
+
+{{>func}}
+
+<p style="padding: 7.5px; margin: 0px;"></p>
+
+---
+{{/methods}}
+{{/has_methods}}
+
+{{#has_inherited_methods}}
+## Inherited methods
+
+{{#inherited_methods}}
+<p style="padding: 7.5px; margin: 0px;"></p>
+
+{{>func}}
+
+<p style="padding: 7.5px; margin: 0px;"></p>
+
+---
+{{/inherited_methods}}
+{{/has_inherited_methods}}

docs/refman/templates/root.functions.mustache

@@ -0,0 +1,20 @@
+---
+short-description: Meson functions
+render-subpages: false
+...
+
+# Functions
+
+This document lists all functions available in `meson.build` files.
+See the [root manual document]({{root}}) for
+an overview of all features.
+
+{{#functions}}
+<p style="padding: 7.5px; margin: 0px;"></p>
+
+{{>func}}
+
+<p style="padding: 7.5px; margin: 0px;"></p>
+
+---
+{{/functions}}

docs/refman/templates/root.mustache

@@ -0,0 +1,51 @@
+---
+short-description: The Meson reference manual
+render-subpages: false
+...
+
+# Reference manual
+
+This is the root page of the Meson reference manual. All functions
+and methods are documented in detail in the following subpages:
+
+## Elementary types
+
+{{#elementary}}
+{{indent}}- {{&link}}
+{{/elementary}}
+
+## Functions
+
+The following functions are available in build files. Click on each
+to see the description and usage. The objects returned by them are
+[listed here](#returned-objects).
+
+{{#functions}}
+{{indent}}- {{&link}}
+{{/functions}}
+
+## Builtin objects
+
+These are built-in objects that are always available.
+
+{{#builtins}}
+{{indent}}- {{&link}}
+{{/builtins}}
+
+## Returned objects
+
+These are objects that can be returned by [functions](#functions)
+or other methods.
+
+{{#returned}}
+{{indent}}- {{&link}}
+{{/returned}}
+
+## Modules
+
+{{#modules}}
+{{indent}}- {{&link}}
+{{/modules}}
+
+
+<!-- The links used to be generated wit {>root_link}, but this is a bit hard to read  -->

docs/refman/templates/root_link.mustache

@@ -0,0 +1 @@
+{{indent}}- <span style="display: flex;"><span>{{&link}}</span><span style="flex-grow: 1;"></span><span style="text-align: right;">{{&brief}}</span></span>

docs/refman/templates/taggs.mustache

@@ -0,0 +1,18 @@
+<div style="margin: 0px; text-align: center;">
+{{#since}}
+<p style="margin: 0px;"><em style="color: #5affff;">(since {{since}})</em></p>
+{{/since}}
+{{#deprecated}}
+<div style="color: #ffa844">
+    <p style="margin: 0px;"><strong>DEPRECATED</strong></p>
+    <p style="margin: 0px;"><em>in {{deprecated}}</em></p>
+</div>
+{{/deprecated}}
+{{#optional}}
+<p style="margin: 0px;"><b>[optional]</b></p>
+{{/optional}}
+{{#default}}
+<p style="margin: 0px;"><code class="language-meson">default =
+{{default}}</code></p>
+{{/default}}
+</div>

docs/sitemap.txt

@@ -71,7 +71,7 @@ index.md
 		Creating-OSX-packages.md
 		Creating-Linux-binaries.md
 		Project-templates.md
-	Reference-manual.md
+	@REFMAN_PLACEHOLDER@
 	Reference-tables.md
 	Style-guide.md
 	Rewriter.md
@@ -131,6 +131,7 @@ index.md
 		Using-multiple-build-directories.md
 		Vs-External.md
 	Contributing.md
+		Yaml-RefMan.md
 		MesonCI.md
 	legal.md
 	Videos.md

docs/yaml/builtins/build_machine.yaml

@@ -0,0 +1,37 @@
+name: build_machine
+long_name: Build machine information
+description: |
+  Provides information about the build machine -- the machine that is doing the actual compilation.
+  See [Cross-compilation](Cross-compilation.md).
+
+  Currently, these values are populated using
+  [`platform.system()`](https://docs.python.org/3.7/library/platform.html#platform.system) and
+  [`platform.machine()`](https://docs.python.org/3.7/library/platform.html#platform.machine).
+  If you think the returned values for any of these are incorrect for
+  your system or CPU, or if your OS is not in the linked table, please
+  [file a bug](https://github.com/mesonbuild/meson/issues/new) report
+  with details and we'll look into it.
+
+methods:
+- name: cpu_family
+  returns: str
+  description: |
+    Returns the CPU family name.
+    [This table](Reference-tables.md#cpu-families) contains
+    all known CPU families. These are guaranteed to continue working.
+
+- name: cpu
+  returns: str
+  description: Returns a more specific CPU name, such as `i686`, `amd64`, etc.
+
+- name: system
+  returns: str
+  description: |
+    Returns the operating system name.
+    [This table](Reference-tables.md#operating-system-names) Lists
+    all of the currently known Operating System names, these are
+    guaranteed to continue working.
+
+- name: endian
+  returns: str
+  description: returns `'big'` on big-endian systems and `'little'` on little-endian systems.

docs/yaml/builtins/host_machine.yaml

@@ -0,0 +1,15 @@
+name: host_machine
+long_name: Host machine information
+extends: build_machine
+description: |
+  Provides information about the host machine -- the machine on which the
+  compiled binary will run. See
+  [Cross-compilation](Cross-compilation.md).
+
+  It has the same methods as [[@build_machine]].
+
+  When not cross-compiling, all the methods return the same values as
+  [[@build_machine]] (because the build machine is the host machine)
+
+  Note that while cross-compiling, it simply returns the values defined
+  in the cross-info file.

docs/yaml/builtins/meson.yaml

@@ -0,0 +1,432 @@
+name: meson
+long_name: Meson object
+description: |
+  The `meson` object allows you to introspect various properties of the
+  system. This object is always mapped in the `meson` variable.
+
+methods:
+  - name: add_dist_script
+    returns: void
+    since: 0.48.0
+    description: |
+      Causes the script given as argument to run during `dist`
+      operation after the
+      distribution source has been generated but before it is
+      archived. Note that this runs the script file that is in the
+      _staging_ directory, not the one in the source directory. If the
+      script file can not be found in the staging directory, it is a hard
+      error. The `MESON_DIST_ROOT` environment variables is set when dist scripts is
+      run.
+
+      *(since 0.54.0)* The `MESON_SOURCE_ROOT` and `MESON_BUILD_ROOT`
+      environment variables are set when dist scripts are run. They are path to the
+      root source and build directory of the main project, even when the script
+      comes from a subproject.
+
+      *(since 0.58.0)* This command can be invoked from a subproject, it was a hard
+      error in earlier versions. Subproject dist scripts will only be executed
+      when running `meson dist --include-subprojects`. `MESON_PROJECT_SOURCE_ROOT`,
+      `MESON_PROJECT_BUILD_ROOT` and `MESON_PROJECT_DIST_ROOT` environment
+      variables are set when dist scripts are run. They are identical to
+      `MESON_SOURCE_ROOT`, `MESON_BUILD_ROOT` and `MESON_DIST_ROOT` for main project
+      scripts, but for subproject scripts they have the path to the root of the
+      subproject appended, usually `subprojects/<subproject-name>`.
+
+    posargs:
+      script_name:
+        type: str | file | external_program | exe | custom_tgt | custom_idx
+        description: |
+          The script to execute.
+
+          *(since 0.55.0)* The output of [[configure_file]], [[files]], and [[find_program]]
+          as well as strings are accepted.
+
+          *(since 0.57.0)* [[@file]] objects and the output of [[configure_file]] may be used.
+
+    varargs:
+      name: arg
+      type: str | file | external_program | exe | custom_tgt | custom_idx
+      since: 0.49.0
+      description: |
+        Additional arguments
+
+        *(since 0.55.0)* The output of [[configure_file]], [[files]], and [[find_program]]
+        as well as strings are accepted.
+
+        *(since 0.57.0)* [[@file]] objects and the output of [[configure_file]] may be used.
+
+  - name: add_install_script
+    returns: void
+    description: |
+      Causes the script given as an argument to be run during the install step,
+      this script  will have the environment variables `MESON_SOURCE_ROOT`,
+      `MESON_BUILD_ROOT`, `MESON_INSTALL_PREFIX`,
+      `MESON_INSTALL_DESTDIR_PREFIX`, and `MESONINTROSPECT` set.
+      All positional arguments are passed as parameters.
+
+      *(since 0.54.0)* If `meson install` is called with the `--quiet` option, the
+      environment variable `MESON_INSTALL_QUIET` will be set.
+
+      Meson uses the `DESTDIR` environment variable as set by the
+      inherited environment to determine the (temporary) installation
+      location for files. Your install script must be aware of this while
+      manipulating and installing files. The correct way to handle this is
+      with the `MESON_INSTALL_DESTDIR_PREFIX` variable which is always set
+      and contains `DESTDIR` (if set) and `prefix` joined together. This
+      is useful because both are usually absolute paths and there are
+      platform-specific edge-cases in joining two absolute paths.
+
+      In case it is needed, `MESON_INSTALL_PREFIX` is also always set and
+      has the value of the `prefix` option passed to Meson.
+
+      `MESONINTROSPECT` contains the path to the introspect command that
+      corresponds to the `meson` executable that was used to configure the
+      build. (This might be a different path than the first executable
+      found in `PATH`.) It can be used to query build configuration. Note
+      that the value will contain many parts, f.ex., it may be `python3
+      /path/to/meson.py introspect`. The user is responsible for splitting
+      the string to an array if needed by splitting lexically like a UNIX
+      shell would. If your script uses Python, `shlex.split()` is the
+      easiest correct way to do this.
+
+    posargs_inherit: meson.add_dist_script
+    varargs_inherit: meson.add_dist_script
+
+    kwargs:
+      skip_if_destdir:
+        type: bool
+        since: 0.57.0
+        default: false
+        description: |
+          If `true` the script will not be run if DESTDIR is set during installation.
+          This is useful in the case the script updates system wide
+          cache that is only needed when copying files into final destination.
+
+      install_tag:
+        type: str
+        since: 0.60.0
+        description: |
+          A string used by the `meson install --tags` command
+          to install only a subset of the files.
+          By default the script has no install tag which means it is not being run when
+          `meson install --tags` argument is specified.
+
+  - name: add_postconf_script
+    returns: void
+    description: |
+      Runs the given command after all project files have been generated.
+      This script will have the environment variables
+      `MESON_SOURCE_ROOT` and `MESON_BUILD_ROOT` set.
+
+    posargs_inherit: meson.add_dist_script
+    varargs_inherit: meson.add_dist_script
+
+  - name: backend
+    returns: str
+    since: 0.37.0
+    description: |
+      Returns a string representing the current backend:
+
+      - `ninja`
+      - `vs2010`
+      - `vs2012`
+      - `vs2013`
+      - `vs2015`
+      - `vs2017`
+      - `vs2019`
+      - `xcode`
+
+  - name: build_root
+    returns: str
+    deprecated: 0.56.0
+    description: |
+      Returns a string with the absolute path to the build root directory.
+      This function will return the
+      build root of the parent project if called from a subproject, which is usually
+      not what you want. Try using [[meson.current_build_dir]] or [[meson.project_build_root]].
+      In the rare cases where the root of the main project is needed,
+      use [[meson.global_build_root]] that has the same behaviour but with a more explicit
+      name.
+
+  - name: source_root
+    returns: str
+    deprecated: 0.56.0
+    description: |
+      Returns a string with the absolute path to the source root directory.
+
+      This function will return the source root of the
+      parent project if called from a subproject, which is usually not what you want.
+      Try using [[meson.current_source_dir]] or [[meson.project_source_root]].
+      In the rare cases where the root of the main project is needed,
+      use [[meson.global_source_root]] that has the same behaviour but with a more explicit
+      name.
+
+    notes:
+      - |
+        You should use the [[files]] function
+        to refer to files in the root source directory instead of
+        constructing paths manually with [[meson.source_root]].
+
+  - name: project_build_root
+    returns: str
+    since: 0.56.0
+    description: Returns a string with the absolute path to the build root directory of the current (sub)project.
+
+  - name: project_source_root
+    returns: str
+    since: 0.56.0
+    description: Returns a string with the absolute path to the source root directory of the current (sub)project.
+
+  - name: global_build_root
+    returns: str
+    since: 0.58.0
+    description: |
+      Returns a string with the absolute path to the build root directory.
+      This function will return the build root of the
+      main project if called from a subproject, which is usually not what you want.
+      It is usually preferable to use [[meson.current_build_dir]] or [[meson.project_build_root]].
+
+  - name: global_source_root
+    returns: str
+    since: 0.58.0
+    description: |
+      Returns a string with the absolute path to the source root directory
+      This function will return the source root of the
+      main project if called from a subproject, which is usually not what you want.
+      It is usually preferable to use [[meson.current_source_dir]] or [[meson.project_source_root]].
+
+  - name: current_build_dir
+    returns: str
+    description: Returns a string with the absolute path to the current build directory.
+
+  - name: current_source_dir
+    returns: str
+    description: Returns a string to the current source directory.
+    notes:
+      - |
+        **You do not need to use this function!**
+
+        When passing files from the current source directory to a function since
+        that is the default. Also, you can use the [[files]] function to
+        refer to files in the current or any other source directory instead
+        of constructing paths manually with [[meson.current_source_dir]].
+
+  - name: get_compiler
+    returns: compiler
+    description: Returns a [[@compiler]] object describing a compiler.
+
+    posargs:
+      language:
+        type: str
+        description: |
+          The language of the compiler to return.
+
+          See our [list of supported languages](Reference-tables.md#language-arguments-parameter-names).
+
+    kwargs:
+      native:
+        type: bool
+        default: false
+        description: |
+          When set to `true` Meson returns the compiler for the build
+          machine (the "native" compiler) and when `false` it returns the host
+          compiler (the "cross" compiler). If `native` is omitted, Meson
+          returns the "cross" compiler if we're currently cross-compiling and
+          the "native" compiler if we're not.
+
+  - name: get_cross_property
+    returns: any
+    deprecated: 0.58.0
+    description: |
+      Returns the given property from a cross file, the optional fallback_value
+      is returned if not cross compiling or the given property is not found.
+
+      This method is replaced by [[meson.get_external_property]].
+
+    posargs_inherit: meson.get_external_property
+    optargs_inherit: meson.get_external_property
+
+  - name: get_external_property
+    returns: any
+    since: 0.54.0
+    description: |
+      Returns the given property from a native or cross file.
+      The optional fallback_value is returned if the given property is not found.
+
+    posargs:
+      propname:
+        type: str
+        description: Name of the property in the cross / native file.
+
+    optargs:
+      fallback_value:
+        type: any
+        description: Value to return if `propname` is not set in the machine file.
+
+    kwargs:
+      native:
+        type: bool
+        description: |
+          Setting `native` to `true` forces retrieving a variable from the
+          native file, even when cross-compiling.
+          If `native: false` or not specified, the variable is retrieved from the
+          cross-file if cross-compiling, and from the native-file when not cross-compiling.
+
+  - name: has_external_property
+    returns: bool
+    since: 0.58.0
+    description: Checks whether the given property exist in a native or cross file.
+    posargs_inherit: meson.get_external_property
+    kwargs_inherit: meson.get_external_property
+
+  - name: can_run_host_binaries
+    returns: bool
+    since: 0.55.0
+    description: |
+      Returns true if the build machine can run binaries compiled for the host.
+      This returns `true` unless you are
+      cross compiling, need a helper to run host binaries, and don't have one.
+      For example when cross compiling from Linux to Windows, one can use `wine`
+      as the helper.
+
+  - name: has_exe_wrapper
+    returns: bool
+    deprecated: 0.55.0
+    description: Use [[meson.can_run_host_binaries]] instead.
+
+  - name: install_dependency_manifest
+    returns: void
+    description: |
+      Installs a manifest file
+      containing a list of all subprojects, their versions and license
+      files to the file name given as the argument.
+
+    posargs:
+      output_name:
+        type: str
+        description: Name of the manifest file to install
+
+  - name: override_find_program
+    returns: void
+    since: 0.46.0
+    description: |
+      specifies that whenever [[find_program]] is used to find a program
+      named `progname`, Meson should not look it up on the system but
+      instead return `program`, which may either be the result of
+      [[find_program]], [[configure_file]] or [[executable]].
+
+      *(since 0.55.0)* If a version
+      check is passed to [[find_program]] for a program that has been overridden with
+      an executable, the current project version is used.
+
+    posargs:
+      progname:
+        type: str
+        description: The name of the program to override.
+
+      program:
+        type: exe | file | external_program
+        description: The program to set as the override for `progname`.
+
+  - name: override_dependency
+    returns: void
+    since: 0.54.0
+    description: |
+      Specifies that whenever [[dependency]] with `name` is used, Meson should not
+      look it up on the system but instead return `dep_object`, which may either be
+      the result of [[dependency]] or [[declare_dependency]].
+
+      Doing this in a subproject allows the parent
+      project to retrieve the dependency without having to know the dependency
+      variable name: `dependency(name, fallback : subproject_name)`.
+
+    posargs:
+      name:
+        type: str
+        description: The name of the dependency to override.
+
+      dep_object:
+        type: dep
+        description: The dependency to set as the override for `name`.
+
+    kwargs:
+      native:
+        type: bool
+        default: false
+        description: |
+          If set to `true`, the dependency is always overwritten for the build machine.
+          Otherwise, the dependency is overwritten for the host machine, which
+          differs from the build machine when cross-compiling.
+
+      static:
+        type: bool
+        since: 0.60.0
+        description: |
+          Used to override static and/or shared dependencies separately.
+          If not specified it is assumed
+          `dep_object` follows `default_library` option value.
+
+  - name: is_cross_build
+    returns: bool
+    description: Returns `true` if the current build is a [cross build](Cross-compilation.md) and `false` otherwise.
+
+  - name: is_subproject
+    returns: bool
+    description: Returns `true` if the current project is being built as a subproject of some other project and `false` otherwise.
+
+  - name: is_unity
+    returns: bool
+    description: Returns `true` when doing a [unity build](Unity-builds.md) (multiple sources are combined before compilation to reduce build time) and `false` otherwise.
+
+  - name: project_version
+    returns: str
+    description: Returns the version string specified in [[project]] function call.
+
+  - name: project_license
+    returns: list[str]
+    description: Returns the array of licenses specified in [[project]] function call.
+
+  - name: project_name
+    returns: str
+    description: Returns the project name specified in the [[project]] function call.
+
+  - name: version
+    returns: str
+    description: Return a string with the version of Meson.
+
+  - name: add_devenv
+    returns: void
+    since: 0.58.0
+    description: |
+      add an [[@env]] object (returned by [[environment]])
+      to the list of environments that will be applied when using [`meson devenv`](Commands.md#devenv)
+      command line.
+
+      This is useful for developpers who wish to use the project without
+      installing it, it is often needed to set for example the path to plugins
+      directory, etc. Alternatively, a list or dictionary can be passed as first
+      argument.
+
+      ``` meson
+      devenv = environment()
+      devenv.set('PLUGINS_PATH', meson.current_build_dir())
+      ...
+      meson.add_devenv(devenv)
+      ```
+
+      After configuring and compiling that project, a terminal can be opened with
+      the environment set:
+
+      ```sh
+      $ meson devenv -C <builddir>
+      $ echo $PLUGINS_PATH
+      /path/to/source/subdir
+      ```
+
+      See [`meson devenv`](Commands.md#devenv) command documentation for a list of
+      environment variables that are set by default by Meson.
+
+    posargs:
+      env:
+        type: env
+        description: The [[@env]] object to add.

docs/yaml/builtins/target_machine.yaml

@@ -0,0 +1,18 @@
+name: target_machine
+long_name: Target machine information
+extends: build_machine
+description: |
+  Provides information about the target machine -- the machine on which
+  the compiled binary's output will run. Hence, this object should only
+  be used while cross-compiling a compiler. See
+  [Cross-compilation](Cross-compilation.md).
+
+  It has the same methods as [[@build_machine]].
+
+  When all compilation is 'native', all the methods return the same
+  values as [[@build_machine]] (because the build machine is the host
+  machine and the target machine).
+
+  Note that while cross-compiling, it simply returns the values defined
+  in the cross-info file. If `target_machine` values are not defined in
+  the cross-info file, `host_machine` values are returned instead.

docs/yaml/elementary/any.yaml

@@ -0,0 +1,5 @@
+name: any
+long_name: Any
+description: |
+  A placeholder representing all types.
+  This includes builtin, as well as returned objects.

docs/yaml/elementary/bool.yml

@@ -0,0 +1,28 @@
+name: bool
+long_name: Boolean
+description: A boolean object which is either `true` or `false`
+
+methods:
+- name: to_int
+  returns: int
+  description: Returns `1` if `true` and `0` if `false`
+
+- name: to_string
+  returns: str
+  description: |
+    Returns the string `'true'` if the boolean is true or `'false'` otherwise.
+    You can also pass it two strings as positional
+    arguments to specify what to return for true/false. For instance,
+    `bool.to_string('yes', 'no')` will return `yes` if the boolean is
+    true and `no` if it is false.
+
+  optargs:
+    true_str:
+      type: str
+      default: "'true'"
+      description: The string to return when the boolean is `true`
+
+    false_str:
+      type: str
+      default: "'false'"
+      description: The string to return when the boolean is `false`

docs/yaml/elementary/dict.yml

@@ -0,0 +1,45 @@
+name: dict
+long_name: Dict
+since: 0.47.0
+is_container: true
+description: |
+  Stores a mapping of strings to other objects. See [dictionaries](Syntax.md#dictionaries).
+
+  You can also iterate over dictionaries with the [`foreach`
+  statement](Syntax.md#foreach-statements).
+
+  *(since 0.48.0)* Dictionaries can be added (e.g. `d1 = d2 + d3` and `d1 += d2`).
+  Values from the second dictionary overrides values from the first.
+
+
+methods:
+- name: has_key
+  returns: bool
+  description: Returns `true` if the dictionary contains the key given as argument, `false` otherwise.
+
+  posargs:
+    key:
+      type: str
+      description: The key to query.
+
+- name: get
+  returns: any
+  description: |
+    returns the value for the key given as first
+    argument if it is present in the dictionary, or the optional
+    fallback value given as the second argument. If a single argument
+    was given and the key was not found, causes a fatal error
+
+  posargs:
+    key:
+      type: str
+      description: The key to query.
+
+  optargs:
+    fallback:
+      type: any
+      description: Fallback value that is returned if the key is not in the [[@dict]].
+
+- name: keys
+  returns: list[str]
+  description: Returns an array of keys in the dictionary.

docs/yaml/elementary/int.yml

@@ -0,0 +1,16 @@
+name: int
+long_name: Integer
+description: All integer numbers. See [Numbers](Syntax.md#numbers) for more information.
+
+methods:
+- name: is_even
+  returns: bool
+  description: Returns true if the number is even.
+
+- name: is_odd
+  returns: bool
+  description: Returns true if the number is odd
+
+- name: to_string
+  returns: str
+  description: Returns the value of the number as a string.

docs/yaml/elementary/list.yml

@@ -0,0 +1,38 @@
+name: list
+long_name: List
+description: An array of elements. See [arrays](Syntax.md#arrays).
+is_container: true
+
+methods:
+- name: contains
+  returns: bool
+  description: |
+    Returns `true` if the array contains the object
+    given as argument, `false` otherwise
+
+  posargs:
+    item:
+      type: any
+      description: The item to check
+
+- name: get
+  returns: any
+  description: |
+    returns the object at the given index,
+    negative indices count from the back of the array, indexing out of
+    bounds returns the `fallback` value *(since 0.38.0)* or, if it is
+    not specified, causes a fatal error
+
+  posargs:
+    index:
+      type: int
+      description: Index of the list position to query. Negative values start at the end of the list
+
+  optargs:
+    fallback:
+      type: any
+      description: Fallback value that is returned if the index is out of range.
+
+- name: length
+  returns: int
+  description: Returns the current size of the array / list.

docs/yaml/elementary/str.yml

@@ -0,0 +1,269 @@
+name: str
+long_name: String
+description: |
+  All [strings](Syntax.md#strings) have the following methods. Strings
+  are immutable, all operations return their results as a new string.
+
+methods:
+
+# str.format(fmt, value...)
+- name: format
+  returns: str
+  description: |
+    Strings can be built using the string formatting functionality.
+
+    See [the Meson syntax entry](Syntax.md#string-formatting) for more
+    information.
+  example: |
+    ```meson
+    template = 'string: @0@, number: @1@, bool: @2@'
+    res = template.format('text', 1, true)
+    # res now has value 'string: text, number: 1, bool: true'
+    ```
+
+  posargs:
+    fmt:
+      description: |
+        The string to format.
+
+        The formatting works by replacing placeholders of type `@number@` with
+        the corresponding varargs.
+      type: str
+
+  varargs:
+    name: value
+    description: The values to replace the @number@ placeholders in the format string.
+    type: int | bool | str
+
+# str.replace(old, new)
+- name: replace
+  description: Search all occurences of `old` and and replace it with `new`
+  returns: str
+  since: 0.58.0
+  example: |
+    ```meson
+    # Replaces all instances of one substring with another
+    s = 'semicolons;as;separators'
+    s = s.replace('as', 'are')
+    # 's' now has the value of 'semicolons;are;separators'
+    ```
+
+  posargs:
+    old:
+      description: The substring to search
+      type: str
+
+    new:
+      description: The replacement string
+      type: str
+
+# str.strip()
+- name: strip
+  description: Removes leading/ending spaces and newlines from the string.
+  returns: str
+  example: |
+    ```meson
+    # Similar to the Python str.strip(). Removes leading/ending spaces and newlines
+    define = ' -Dsomedefine '
+    stripped_define = define.strip()
+    # 'stripped_define' now has the value '-Dsomedefine'
+    ```
+
+  optargs:
+    strip_chars:
+      type: str
+      since: 0.43.0
+      description: All characters in this string will be stripped.
+
+# str.to_lower()
+- name: to_lower
+  description: Converts all characters to lower case
+  returns: str
+  example: |
+    ```meson
+    target = 'x86_FreeBSD'
+    lower = target.to_lower() # t now has the value 'x86_freebsd'
+    ```
+
+# str.to_upper()
+- name: to_upper
+  description: Converts all characters to upper case
+  returns: str
+  example: |
+    ```meson
+    target = 'x86_FreeBSD'
+    upper = target.to_upper() # t now has the value 'X86_FREEBSD'
+    ```
+
+# str.to_int()
+- name: to_int
+  description: Converts the string to an int and throws an error if it can't be
+  returns: int
+  example: |
+    ```meson
+    version = '1'
+    # Converts the string to an int and throws an error if it can't be
+    ver_int = version.to_int()
+    ```
+
+# str.contains()
+- name: contains
+  returns: bool
+  description: Returns `true` if string contains the string specified as the argument.
+  example: |
+    ```meson
+    target = 'x86_FreeBSD'
+    is_fbsd = target.to_lower().contains('freebsd')
+    # is_fbsd now has the boolean value 'true'
+    ```
+
+  posargs:
+    fragment:
+      type: str
+      description: The string fragment to check
+
+# str.startswith()
+- name: startswith
+  returns: bool
+  description: Returns true if string starts with the string specified as the argument.
+  posargs_inherit: str.contains
+  example: |
+    ```meson
+    target = 'x86_FreeBSD'
+    is_x86 = target.startswith('x86') # boolean value 'true'
+    ```
+
+# str.endswith()
+- name: endswith
+  returns: bool
+  description: Returns true if string ends with the string specified as the argument.
+  posargs_inherit: str.contains
+  example: |
+    ```meson
+    target = 'x86_FreeBSD'
+    is_bsd = target.to_lower().endswith('bsd') # boolean value 'true'
+    ```
+
+# str.substring()
+- name: substring
+  returns: str
+  since: 0.56.0
+  description: |
+    Returns a substring specified from `start` to `end`.
+    Both `start` and `end` arguments are optional, so, for example, `'foobar'.substring()` will return `'foobar'`.
+
+    The method accepts negative values where negative `start` is relative to the end of
+    string `len(string) - start` as well as negative `end`.
+
+  example: |
+    ```meson
+    # Similar to the Python str[start:end] syntax
+    target = 'x86_FreeBSD'
+    platform = target.substring(0, 3) # prefix string value 'x86'
+    system = target.substring(4) # suffix string value 'FreeBSD'
+    ```
+
+    Example with negative values:
+
+    ```meson
+    string = 'foobar'
+    string.substring(-5, -3) # => 'oo'
+    string.substring(1, -1) # => 'ooba'
+    ```
+
+  optargs:
+    start:
+      type: int
+      description: The start position
+
+    end:
+      type: int
+      description: The end position
+
+# str.split
+- name: split
+  returns: list[str]
+  description: |
+    Splits the string at the specified character
+    (or whitespace if not set) and returns the parts in an
+    array.
+
+  example: |
+    ```meson
+    # Similar to the Python str.split()
+    components = 'a b   c d '.split()
+    # components now has the value ['a', 'b', 'c', 'd']
+    components = 'a b   c d '.split(' ')
+    # components now has the value ['a', 'b', '', '', 'c', 'd', '']
+    ```
+
+  optargs:
+    split_string:
+      type: str
+      description: Specifies the character / substring where to split the string.
+
+# str.join()
+- name: join
+  returns: str
+  description: |
+    The opposite of split,
+    for example `'.'.join(['a', 'b', 'c']` yields `'a.b.c'`.
+
+  example: |
+    ```meson
+    # Similar to the Python str.join()
+    output = ' '.join(['foo', 'bar'])
+    # Output value is 'foo bar'
+    pathsep = ':'
+    path = pathsep.join(['/usr/bin', '/bin', '/usr/local/bin'])
+    # path now has the value '/usr/bin:/bin:/usr/local/bin'
+    ```
+
+  varargs:
+      name: strings
+      type: str
+      since: 0.60.0
+      description: |
+        The strings to join with the current string.
+
+        Before Meson *0.60.0* this function only accepts a single positional
+        argument of the type [[list[str]]].
+
+# str.underscorify
+- name: underscorify
+  returns: str
+  description: Creates a string where every non-alphabetical non-number character is replaced with `_`.
+  example: |
+    ```meson
+    name = 'Meson Docs.txt#Reference-manual'
+    # Replaces all characters other than `a-zA-Z0-9` with `_` (underscore)
+    # Useful for substituting into #defines, filenames, etc.
+    underscored = name.underscorify()
+    # underscored now has the value 'Meson_Docs_txt_Reference_manual'
+    ```
+
+# str.version_compare
+- name: version_compare
+  returns: bool
+  description: Does semantic version comparison.
+  example: |
+    ```meson
+    version = '1.2.3'
+    # Compare version numbers semantically
+    is_new = version.version_compare('>=2.0')
+    # is_new now has the boolean value false
+    # Supports the following operators: '>', '<', '>=', '<=', '!=', '==', '='
+    ```
+
+    Meson version comparison conventions include:
+
+    ```meson
+    '3.6'.version_compare('>=3.6.0') == false
+    ```
+
+    It is best to be unambiguous and specify the full revision level to compare.
+
+  posargs:
+    compare_string:
+      type: str
+      description: The string to compare to.

docs/yaml/elementary/void.yml

@@ -0,0 +1,5 @@
+name: void
+long_name: void
+description: |
+  Indicates that the function does not return anything.
+  Similar to `void` in C and C++

docs/yaml/functions/_build_target_base.yaml

@@ -0,0 +1,278 @@
+name: _build_target_base
+returns: void
+description: PRIVATE
+
+posargs:
+  target_name:
+    description: The *unique* name of the build target
+    type: str
+
+varargs:
+  name: source
+  type: str | file | custom_tgt | custom_idx | generated_list
+  description: |
+    Input source to compile. The following types are supported:
+
+    - Strings relative to the current source directory
+    - [[@file]] objects defined in any preceding build file
+    - The return value of configure-time generators such as [[configure_file]]
+    - The return value of build-time generators such as
+      [[custom_target]] or [[generator.process]]
+
+    These input files can be sources, objects, libraries, or any other
+    file. Meson will automatically categorize them based on the extension
+    and use them accordingly. For instance, sources (`.c`, `.cpp`,
+    `.vala`, `.rs`, etc) will be compiled and objects (`.o`, `.obj`) and
+    libraries (`.so`, `.dll`, etc) will be linked.
+
+    With the Ninja backend, Meson will create a build-time [order-only
+    dependency](https://ninja-build.org/manual.html#ref_dependencies) on
+    all generated input files, including unknown files. This is needed to
+    bootstrap the generation of the real dependencies in the
+    [depfile](https://ninja-build.org/manual.html#ref_headers) generated
+    by your compiler to determine when to rebuild sources. Ninja relies on
+    this dependency file for all input files, generated and non-generated.
+    The behavior is similar for other backends.
+
+warnings:
+  - The `link_language` kwarg was broken until 0.55.0
+
+kwargs:
+  <lang>_pch:
+    type: str | file
+    description: precompiled header file to use for the given language
+
+  <lang>_args:
+    type: list[str]
+    description: |
+      compiler flags to use for the given language;
+      eg: `cpp_args` for C++
+
+  sources:
+    type: str | file | custom_tgt | custom_idx | generated_list
+    description: Additional source files. Same as the source varargs.
+
+  build_by_default:
+    type: bool
+    default: true
+    since: 0.38.0
+    description: |
+      Causes, when set to `true`, to have this target be built by default.
+      This means it will be built when `meson compile` is called without any
+      arguments. The default value is `true` for all built target types.
+
+  build_rpath:
+    type: str
+    description: |
+      A string to add to target's rpath definition in the build dir,
+      but which will be removed on install
+
+  dependencies:
+    type: list[dep]
+    description: |
+      one or more dependency objects
+      created with
+      [[dependency]] or [[compiler.find_library]]
+      (for external deps) or [[declare_dependency]]
+      (for deps built by the project)
+
+  extra_files:
+    type: str | file | custom_tgt | custom_idx
+    description: |
+      Not used for the build itself but are shown as source files in IDEs
+      that group files by targets (such as Visual Studio)
+
+  gui_app:
+    type: bool
+    deprecated: 0.56.0
+    default: false
+    description: |
+      When set to true flags this target as a GUI application
+      on platforms where this makes a differerence, **deprecated** since
+      0.56.0, use `win_subsystem` instead.
+
+  link_args:
+    type: list[str]
+    description: |
+      Flags to use during linking. You can use UNIX-style
+      flags here for all platforms.
+
+  link_depends:
+    type: str | file | custom_tgt | custom_idx
+    description: |
+      Strings, files, or custom targets the link step depends on
+      such as a symbol visibility map. The purpose is to
+      automatically trigger a re-link (but not a re-compile) of the target
+      when this file changes.
+
+  link_language:
+    type: str
+    since: 0.51.0
+    description: |
+      Makes the linker for this target be for the specified language.
+      It is generally unnecessary to set
+      this, as Meson will detect the right linker to use in most cases. There are
+      only two cases where this is needed. One, your main function in an
+      executable is not in the language Meson picked, or second you want to force
+      a library to use only one ABI.
+
+      *(broken until 0.55.0)*
+
+  link_whole:
+    type: list[lib | custom_tgt | custom_idx]
+    since: 0.40.0
+    description: |
+      Links all contents of the given static libraries
+      whether they are used by not, equivalent to the `-Wl,--whole-archive` argument flag of GCC.
+
+      *(since 0.41.0)* If passed a list that list will be flattened.
+
+      *(since 0.51.0)* This argument also accepts outputs produced by
+      custom targets. The user must ensure that the output is a library in
+      the correct format.
+
+  link_with:
+    type: list[lib | custom_tgt | custom_idx]
+    description: |
+      One or more shared or static libraries
+      (built by this project) that this target should be linked with. *(since 0.41.0)* If passed a
+      list this list will be flattened. *(since 0.51.0)* The arguments can also be custom targets.
+      In this case Meson will assume that merely adding the output file in the linker command
+      line is sufficient to make linking work. If this is not sufficient,
+      then the build system writer must write all other steps manually.
+
+  implicit_include_directories:
+    type: bool
+    since: 0.42.0
+    default: true
+    description: Controlls whether Meson adds the current source and build directories to the include path
+
+  include_directories:
+    type: list[inc | str]
+    description: |
+      one or more objects created with the [[include_directories]] function,
+      or *(since 0.50.0)* strings, which will be transparently expanded to include directory objects
+
+  install:
+    type: bool
+    default: false
+    description: When set to true, this executable should be installed.
+
+  install_dir:
+    type: str
+    description: |
+      override install directory for this file. The value is
+      relative to the `prefix` specified. F.ex, if you want to install
+      plugins into a subdir, you'd use something like this: `install_dir :
+      get_option('libdir') / 'projectname-1.0'`.
+
+  install_mode:
+    type: list[str | int]
+    since: 0.47.0
+    description: |
+      Specify the file mode in symbolic format
+      and optionally the owner/uid and group/gid for the installed files.
+
+      See the `install_mode` kwarg of [[install_data]] for more information.
+
+  install_tag:
+    type: str
+    since: 0.60.0
+    description: |
+      A string used by the `meson install --tags` command
+      to install only a subset of the files. By default all build targets have the
+      tag `runtime` except for static libraries that have the `devel` tag.
+
+  install_rpath:
+    type: str
+    description: |
+      A string to set the target's rpath to after install
+      (but *not* before that). On Windows, this argument has no effect.
+
+  objects:
+    type: list[extracted_obj]
+    description: |
+      List of prebuilt object files (usually for third party
+      products you don't have source to) that should be linked in this
+      target, **never** use this for object files that you build yourself.
+
+  name_prefix:
+    type: str | list[void]
+    description: |
+      The string that will be used as the prefix for the
+      target output filename by overriding the default (only used for
+      libraries). By default this is `lib` on all platforms and compilers,
+      except for MSVC shared libraries where it is omitted to follow
+      convention, and Cygwin shared libraries where it is `cyg`.
+
+      Set this to `[]`, or omit the keyword argument for the default behaviour.
+
+  name_suffix:
+    type: str | list[void]
+    description: |
+      The string that will be used as the extension for the
+      target by overriding the default. By default on Windows this is
+      `exe` for executables and on other platforms it is omitted.
+
+      For shared libraries, the default value
+      is `dylib` on macOS, `dll` on Windows, and `so` everywhere else.
+      For static libraries, it is `a` everywhere. By convention MSVC
+      static libraries use the `lib` suffix, but we use `a` to avoid a
+      potential name clash with shared libraries which also generate
+      import libraries with a `lib` suffix.
+
+      Set this to `[]`, or omit the keyword argument for the default behaviour.
+
+  override_options:
+    type: list[str]
+    since: 0.40.0
+    description: |
+      takes an array of strings in the same format as `project`'s `default_options`
+      overriding the values of these options
+      for this target only.
+
+  gnu_symbol_visibility:
+    type: str
+    since: 0.48.0
+    description: |
+      Specifies how symbols should be exported, see
+      e.g [the GCC Wiki](https://gcc.gnu.org/wiki/Visibility) for more
+      information. This value can either be an empty string or one of
+      `default`, `internal`, `hidden`, `protected` or `inlineshidden`, which
+      is the same as `hidden` but also includes things like C++ implicit
+      constructors as specified in the GCC manual. Ignored on compilers that
+      do not support GNU visibility arguments.
+
+  d_import_dirs:
+    type: list[str]
+    description: List of directories to look in for string imports used in the D programming language.
+
+  d_unittest:
+    type: bool
+    default: false
+    description: When set to true, the D modules are compiled in debug mode.
+
+  d_module_versions:
+    type: list[str]
+    description: List of module version identifiers set when compiling D sources.
+
+  d_debug:
+    type: list[str]
+    description: List of module debug identifiers set when compiling D sources.
+
+  native:
+    type: bool
+    default: false
+    description: Controls whether the target is compiled for the build or host machines.
+
+  win_subsystem:
+    type: str
+    default: "'console'"
+    since: 0.56.0
+    description: |
+      Specifies the subsystem type to use
+      on the Windows platform. Typical values include `console` for text
+      mode programs and `windows` for gui apps. The value can also contain
+      version specification such as `windows,6.0`. See [MSDN
+      documentation](https://docs.microsoft.com/en-us/cpp/build/reference/subsystem-specify-subsystem)
+      for the full list.

docs/yaml/functions/add_global_arguments.yaml

@@ -0,0 +1,38 @@
+name: add_global_arguments
+returns: void
+description: Adds global arguments to the compiler command line.
+
+notes:
+  - Usually you should use [[add_project_arguments]] instead,
+    because that works even when you project is used as a subproject.
+  - You must pass always arguments individually `arg1, arg2, ...`
+    rather than as a string `'arg1 arg2', ...`
+
+varargs:
+  type: str
+  name: Compiler argument
+  description: The commpiler arguments to add
+
+kwargs:
+  language:
+    type: list[str]
+    required: true
+    description: |
+      Specifies the language(s) that the arguments should be
+      applied to. If a list of languages is given, the arguments are added
+      to each of the corresponding compiler command lines. Note that there
+      is no way to remove an argument set in this way. If you have an
+      argument that is only used in a subset of targets, you have to specify
+      it in per-target flags.
+
+  native:
+    type: bool
+    default: false
+    since: 0.48.0
+    description: |
+      A boolean specifying whether the arguments should be
+      applied to the native or cross compilation. If `true` the arguments
+      will only be used for native compilations. If `false` the arguments
+      will only be used in cross compilations. If omitted, the flags are
+      added to native compilations if compiling natively and cross
+      compilations (only) when cross compiling.

docs/yaml/functions/add_global_link_arguments.yaml

@@ -0,0 +1,19 @@
+name: add_global_link_arguments
+returns: void
+description: |
+  Adds global arguments to the linker command line.
+
+  Like [[add_global_arguments]] but the arguments are passed to the linker.
+
+notes:
+  - Usually you should use [[add_project_link_arguments]] instead,
+    because that works even when you project is used as a subproject.
+  - You must pass always arguments individually `arg1, arg2, ...`
+    rather than as a string `'arg1 arg2', ...`
+
+varargs:
+  type: str
+  name: Linker argument
+  description: The linker arguments to add
+
+kwargs_inherit: add_global_arguments

docs/yaml/functions/add_languages.yaml

@@ -0,0 +1,51 @@
+name: add_languages
+returns: bool
+description: |
+  Add programming languages used by the project.
+
+  This is equivalent to having
+  them in the `project` declaration. This function is usually used to
+  add languages that are only used under some conditions.
+
+  Returns `true` if all languages specified were found and `false` otherwise.
+
+  If `native` is omitted, the languages may be used for either build or host
+  machine, but are never required for the build machine.  (i.e. it is equivalent
+  to `add_languages(*langs*, native: false, required: *required*) and
+  add_languages(*langs*, native: true, required: false)`. This default behaviour
+  may change to `native: false` in a future Meson version.
+
+example: |
+  ```meson
+  project('foobar', 'c')
+
+  if compiling_for_osx
+    add_languages('objc')
+  endif
+  if add_languages('cpp', required : false)
+    executable('cpp-app', 'main.cpp')
+  endif
+
+  # More code...
+  ```
+
+varargs:
+  type: str
+  name: Language
+  description: The languages to add
+
+kwargs:
+  required:
+    type: bool
+    default: true
+    description: |
+      If set to `true`, Meson will halt if any of the languages
+      specified are not found. *(since 0.47.0)* The value of a
+      [`feature`](Build-options.md#features) option can also be passed.
+  native:
+    type: bool
+    since: 0.54.0
+    description: |
+      If set to `true`, the language will be used to compile for the build
+      machine, if `false`, for the host machine.
+

docs/yaml/functions/add_project_arguments.yaml

@@ -0,0 +1,19 @@
+name: add_project_arguments
+returns: void
+description: |
+  Adds project specific arguments to the compiler command line.
+
+  This function behaves in the same way as [[add_global_arguments]] except
+  that the arguments are only used for the current project, they won't
+  be used in any other subproject.
+
+notes:
+  - You must pass always arguments individually `arg1, arg2, ...`
+    rather than as a string `'arg1 arg2', ...`
+
+varargs:
+  type: str
+  name: Compiler argument
+  description: The commpiler arguments to add
+
+kwargs_inherit: add_global_arguments

docs/yaml/functions/add_project_link_arguments.yaml

@@ -0,0 +1,17 @@
+name: add_project_link_arguments
+returns: void
+description: |
+  Adds global arguments to the linker command line.
+
+  Like [[add_global_arguments]] but the arguments are passed to the linker.
+
+notes:
+  - You must pass always arguments individually `arg1, arg2, ...`
+    rather than as a string `'arg1 arg2', ...`
+
+varargs:
+  type: str
+  name: Linker argument
+  description: The linker arguments to add
+
+kwargs_inherit: add_global_arguments

docs/yaml/functions/add_test_setup.yaml

@@ -0,0 +1,60 @@
+name: add_test_setup
+returns: void
+description: |
+  Add a custom test setup. This setup can be used to run the tests with a
+  custom setup, for example under Valgrind.
+
+  To use the test setup, run `meson test --setup=*name*` inside the
+  build dir.
+
+  Note that all these options are also available while running the
+  `meson test` script for running tests instead of `ninja test` or
+  `msbuild RUN_TESTS.vcxproj`, etc depending on the backend.
+
+posargs:
+  name:
+    type: str
+    description: The name of the test setup
+
+kwargs:
+  env:
+    type: env | list[str] | dict[str]
+    description: |
+      environment variables to set
+      , such as `['NAME1=value1', 'NAME2=value2']`,
+      or an [[@env]] object which allows more sophisticated
+      environment juggling. *(Since 0.52.0)* A dictionary is also accepted.
+
+  exe_wrapper:
+    type: list[str | external_program]
+    description: The command or script followed by the arguments to it
+
+  gdb:
+    type: bool
+    default: false
+    description: If `true`, the tests are also run under `gdb`
+
+  timeout_multiplier:
+    type: int
+    default: 1
+    description: |
+      A number to multiply the test timeout with.
+      *Since 0.57* if timeout_multiplier is `<= 0` the test has infinite duration,
+      in previous versions of Meson the test would fail with a timeout immediately.
+
+  is_default:
+    type: bool
+    since: 0.49.0
+    default: false
+    description: |
+      Set whether this is the default test setup.
+      If `true`, the setup will be used whenever `meson test` is run
+      without the `--setup` option.
+
+  exclude_suites:
+    type: list[str]
+    since: 0.57.0
+    description:
+      A list of test suites that should be excluded when using this setup.
+      Suites specified in the `--suite` option
+      to `meson test` will always run, overriding `add_test_setup` if necessary.

docs/yaml/functions/alias_target.yaml

@@ -0,0 +1,21 @@
+name: alias_target
+since: 0.52.0
+returns: alias_tgt
+description: |
+  This function creates a new top-level target. Like all top-level
+  targets, this integrates with the selected backend. For instance, with
+  you can run it as `meson compile target_name`. This is a dummy target
+  that does not execute any command, but ensures that all dependencies
+  are built. Dependencies can be any build target (e.g. return value of
+  [[executable]], [[custom_target]], etc)
+
+posargs:
+  target_name:
+    type: str
+    description: The name of the alias target
+
+varargs:
+  name: Dep
+  type: tgt
+  min_varargs: 1
+  description: The targets to depend on

docs/yaml/functions/assert.yaml

@@ -0,0 +1,17 @@
+name: assert
+returns: void
+description: Abort with an error message if `condition` evaluates to `false`.
+
+notes:
+  - The `message` argument is optional since 0.53.0 and defaults to print
+    the condition statement.
+
+posargs:
+  condition:
+    type: bool
+    description: Abort if this evaluates to `false`
+
+optargs:
+  message:
+    type: str
+    description: The error message to print.

docs/yaml/functions/benchmark.yaml

@@ -0,0 +1,106 @@
+name: benchmark
+returns: void
+description: |
+  Creates a benchmark item that will be run when the benchmark target is
+  run. The behavior of this function is identical to [[test]]
+  except for:
+
+  * benchmark() has no `is_parallel` keyword because benchmarks are not run in parallel
+  * benchmark() does not automatically add the `MALLOC_PERTURB_` environment variable
+
+  Defined tests can be run in a backend-agnostic way by calling
+  `meson test` inside the build dir, or by using backend-specific
+  commands, such as `ninja test` or `msbuild RUN_TESTS.vcxproj`.
+
+notes:
+  - Prior to 0.52.0 benchmark would warn that `depends` and
+    `priority` were unsupported, this is incorrect.
+
+posargs:
+  name:
+    type: str
+    description: The *unique* test id
+
+  executable:
+    type: exe | jar | external_program | file
+    description: The program to execute
+
+kwargs:
+  args:
+    type: list[str | file | tgt]
+    description: Arguments to pass to the executable
+
+  env:
+    type: env | list[str] | dict[str]
+    description: |
+      environment variables to set, such as `['NAME1=value1',
+      'NAME2=value2']`, or an [[@env]] object which allows more sophisticated
+      environment juggling. *(Since 0.52.0)* A dictionary is also accepted.
+
+  should_fail:
+    type: bool
+    default: false
+    description: |
+      when true the test is considered passed if the
+      executable returns a non-zero return value (i.e. reports an error)
+
+  suite:
+    type: str | list[str]
+    description: |
+      `'label'` (or list of labels `['label1', 'label2']`)
+      attached to this test. The suite name is qualified by a (sub)project
+      name resulting in `(sub)project_name:label`. In the case of a list
+      of strings, the suite names will be `(sub)project_name:label1`,
+      `(sub)project_name:label2`, etc.
+
+  timeout:
+    type: int
+    default: 30
+    description: |
+      the amount of seconds the test is allowed to run, a test
+      that exceeds its time limit is always considered failed, defaults to
+      30 seconds. *Since 0.57* if timeout is `<= 0` the test has infinite duration,
+      in previous versions of Meson the test would fail with a timeout immediately.
+
+  workdir:
+    type: str
+    description: |
+      absolute path that will be used as the working directory
+      for the test
+
+  depends:
+    type: list[build_tgt | custom_tgt]
+    since: 0.46.0
+    description: |
+      specifies that this test depends on the specified
+      target(s), even though it does not take any of them as a command
+      line argument. This is meant for cases where test finds those
+      targets internally, e.g. plugins or globbing. Those targets are built
+      before test is executed even if they have `build_by_default : false`.
+
+  protocol:
+    type: str
+    since: 0.50.0
+    default: "'exitcode'"
+    description: |
+      specifies how the test results are parsed and can
+      be one of `exitcode`, `tap`, or `gtest`. For more information about test
+      harness protocol read [Unit Tests](Unit-tests.md). The following values are
+      accepted:
+
+      - `exitcode`: the executable's exit code is used by the test harness
+        to record the outcome of the test).
+      - `tap`: [Test Anything Protocol](https://www.testanything.org/).
+      - `gtest` *(since 0.55.0)*: for Google Tests.
+      - `rust` *(since 0.56.0)*: for native rust tests
+
+  priority:
+    type: int
+    since: 0.52.0
+    default: 0
+    description: |
+      specifies the priority of a test. Tests with a
+      higher priority are *started* before tests with a lower priority.
+      The starting order of tests with identical priorities is
+      implementation-defined. The default priority is 0, negative numbers are
+      permitted.

docs/yaml/functions/both_libraries.yaml

@@ -0,0 +1,15 @@
+name: both_libraries
+returns: both_libs
+since: 0.46.0
+description: |
+  Builds both a static and shared library with the given sources.
+  Positional and keyword arguments are otherwise the same as for
+  [[library]]. Source files will be compiled only once and
+  object files will be reused to build both shared and static libraries,
+  unless `b_staticpic` user option or `pic` argument are set to false in
+  which case sources will be compiled twice.
+
+
+posargs_inherit: library
+varargs_inherit: library
+kwargs_inherit: library

docs/yaml/functions/build_target.yaml

@@ -0,0 +1,45 @@
+name: build_target
+returns: build_tgt
+description: |
+  Creates a build target whose type can be set dynamically with the
+  `target_type` keyword argument.
+
+  `target_type` may be set to one of:
+
+  - `executable` (see [[executable]])
+  - `shared_library` (see [[shared_library]])
+  - `shared_module` (see [[shared_module]])
+  - `static_library` (see [[static_library]])
+  - `both_libraries` (see [[both_libraries]])
+  - `library` (see [[library]])
+  - `jar` (see [[jar]])
+
+  This declaration:
+
+  ```meson
+  executable(<arguments and keyword arguments>)
+  ```
+
+  is equivalent to this:
+
+  ```meson
+  build_target(<arguments and keyword arguments>, target_type : 'executable')
+  ```
+
+  The lists for the kwargs (such as `sources`, `objects`, and `dependencies`) are
+  always flattened, which means you can freely nest and add lists while
+  creating the final list.
+
+  The returned object also has methods that are documented in [[@build_tgt]].
+
+posargs_inherit: _build_target_base
+varargs_inherit: _build_target_base
+kwargs_inherit:
+  - executable
+  - library
+  - jar
+
+kwargs:
+  target_type:
+    type: str
+    description: The actual target to build

docs/yaml/functions/configuration_data.yaml

@@ -0,0 +1,15 @@
+name: configuration_data
+returns: cfg_data
+description: |
+  Creates an empty configuration object. You should add your
+  configuration with the [[@cfg_data]] method calls and
+  finally use it in a call to [[configure_file]].
+
+optargs:
+  data:
+    type: dict[str | bool | int]
+    since: 0.49.0
+    description: |
+      Optional dictionary to specifiy an inital data set. If
+      provided, each key/value pair is added into the [[@cfg_data]] object
+      as if the [[cfg_data.set]] method was called for each of them.

docs/yaml/functions/configure_file.yaml

@@ -0,0 +1,136 @@
+name: configure_file
+returns: file
+description: |
+  This function can run in three modes depending on the keyword arguments
+  passed to it.
+
+  When a [[@cfg_data]] object is passed
+  to the `configuration:` keyword argument, it takes a template file as
+  the `input:` (optional) and produces the `output:` (required) by
+  substituting values from the configuration data as detailed in [the
+  configuration file documentation](Configuration.md). *(since 0.49.0)*
+  A dictionary can be passed instead of a
+  [[@cfg_data]] object.
+
+  When a list of strings is passed to the `command:` keyword argument,
+  it takes any source or configured file as the `input:` and assumes
+  that the `output:` is produced when the specified command is run.
+
+  *(since 0.47.0)* When the `copy:` keyword argument is set to `true`,
+  this function will copy the file provided in `input:` to a file in the
+  build directory with the name `output:` in the current directory.
+
+kwargs:
+  capture:
+    type: bool
+    since: 0.41.0
+    default: false
+    description: |
+      When this argument is set to true,
+      Meson captures `stdout` of the `command` and writes it to the target
+      file specified as `output`.
+
+  command:
+    type: list[str | file]
+    description: |
+      As explained above, if specified, Meson does not create
+      the file itself but rather runs the specified command, which allows
+      you to do fully custom file generation. *(since 0.52.0)* The command can contain
+      file objects and more than one file can be passed to the `input` keyword
+      argument, see [[custom_target]] for details about string
+      substitutions.
+
+  copy:
+    type: bool
+    default: false
+    since: 0.47.0
+    description: |
+      As explained above, if specified Meson only
+      copies the file from input to output.
+
+  depfile:
+    type: str
+    since: 0.52.0
+    description: |
+      A dependency file that the command can write listing
+      all the additional files this target depends on. A change
+      in any one of these files triggers a reconfiguration.
+
+  format:
+    type: str
+    since: 0.46.0
+    default: "'meson'"
+    description: |
+      The format of defines. It defaults to `'meson'`, and so substitutes
+      `#mesondefine` statements and variables surrounded by `@` characters, you can also use `'cmake'`
+      to replace `#cmakedefine` statements and variables with the `${variable}` syntax. Finally you can use
+      `'cmake@'` in which case substitutions will apply on `#cmakedefine` statements and variables with
+      the `@variable@` syntax.
+
+  input:
+    type: str | file
+    description: |
+      The input file name. If it's not specified in configuration
+      mode, all the variables in the `configuration:` object (see above)
+      are written to the `output:` file.
+
+  install:
+    type: bool
+    default: false
+    since: 0.50.0
+    description: |
+      When true, this generated file is installed during
+      the install step, and `install_dir` must be set and not empty. When false, this
+      generated file is not installed regardless of the value of `install_dir`.
+      When omitted it defaults to true when `install_dir` is set and not empty,
+      false otherwise.
+
+  install_dir:
+    type: str
+    description: |
+      The subdirectory to install the generated file to
+      (e.g. `share/myproject`), if omitted or given the value of empty
+      string, the file is not installed.
+
+  install_mode:
+    type: list[str | int]
+    since: 0.47.0
+    description: |
+      Specify the file mode in symbolic format
+      and optionally the owner/uid and group/gid for the installed files.
+
+      See the `install_mode` kwarg of [[install_data]] for more information.
+
+  install_tag:
+    type: str
+    since: 0.60.0
+    description: |
+      A string used by the `meson install --tags` command
+      to install only a subset of the files. By default the file has no install
+      tag which means it is not being installed when `--tags` argument is specified.
+
+  output:
+    type: str
+    description: |
+      The output file name. *(since 0.41.0)* may contain
+      `@PLAINNAME@` or `@BASENAME@` substitutions. In configuration mode,
+      the permissions of the input file (if it is specified) are copied to
+      the output file.
+
+  output_format:
+    type: str
+    since: 0.47.0
+    description: |
+      The format of the output to generate when no input
+      was specified. It defaults to `c`, in which case preprocessor directives
+      will be prefixed with `#`, you can also use `nasm`, in which case the
+      prefix will be `%`.
+
+  encoding:
+    type: str
+    default: "'utf-8'"
+    since: 0.47.0
+    description: |
+      Set the file encoding for the input and output file.
+      The supported encodings are those of python3, see
+      [standard-encodings](https://docs.python.org/3/library/codecs.html#standard-encodings).

docs/yaml/functions/custom_target.yaml

@@ -0,0 +1,230 @@
+name: custom_target
+returns: custom_tgt
+description: |
+  Create a custom top level build target. The only positional argument
+  is the name of this target and cannot contain path separators (`/` or `\`).
+  The name of custom target might not be used by every backends, for instance with
+  the Ninja backend, `subdir/meson.build` containing the example below,
+  `ninja -C builddir foo` or `ninja -C builddir subdir/foo` won't work,
+  it is instead `ninja -C builddir subdir/file.txt`. Howerver, `meson compile subdir/foo`
+  is accepted.
+  ```meson
+  custom_target('foo', output: 'file.txt', ...)
+  ```
+
+  *Since 0.60.0* the name argument is optional and defaults to the basename of the first
+  output (`file.txt` in the example above).
+
+  The list of strings passed to the `command` keyword argument accept
+  the following special string substitutions:
+
+  - `@INPUT@`: the full path to the input passed to `input`. If more than
+    one input is specified, all of them will be substituted as separate
+    arguments only if the command uses `'@INPUT@'` as a
+    standalone-argument. For instance, this would not work: `command :
+    ['cp', './@INPUT@']`, but this would: `command : ['cp', '@INPUT@']`.
+  - `@OUTPUT@`: the full path to the output passed to `output`. If more
+    than one outputs are specified, the behavior is the same as
+    `@INPUT@`.
+  - `@INPUT0@` `@INPUT1@` `...`: the full path to the input with the specified array index in `input`
+  - `@OUTPUT0@` `@OUTPUT1@` `...`: the full path to the output with the specified array index in `output`
+  - `@OUTDIR@`: the full path to the directory where the output(s) must be written
+  - `@DEPFILE@`: the full path to the dependency file passed to `depfile`
+  - `@PLAINNAME@`: the input filename, without a path
+  - `@BASENAME@`: the input filename, with extension removed
+  - `@PRIVATE_DIR@` *(since 0.50.1)*: path to a directory where the custom target must store all its intermediate files.
+  - `@SOURCE_ROOT@`: the path to the root of the source tree. Depending on the backend,
+    this may be an absolute or a relative to current workdir path.
+  - `@BUILD_ROOT@`: the path to the root of the build tree. Depending on the backend,
+    this may be an absolute or a relative to current workdir path.
+  - `@CURRENT_SOURCE_DIR@`: this is the directory where the currently
+    processed meson.build is located in.  Depending on the backend,
+    this may be an absolute or a relative to current workdir path.
+
+  *(since 0.47.0)* The `depfile` keyword argument also accepts the
+  `@BASENAME@` and `@PLAINNAME@` substitutions.
+
+  The returned object also has methods that are documented in [[@custom_tgt]].
+
+notes:
+  - |
+    Assuming that `command:` is executed by a POSIX `sh` shell
+    is not portable, notably to Windows. Instead, consider using a
+    `native: true` [[executable]], or a python script.
+
+optargs:
+  name:
+    type: str
+    description: |
+      The *unique* id of the custom target
+
+      This posarg is optional *since 0.60.0*. It defaults to the basename
+      of the first output.
+
+kwargs:
+  build_by_default:
+    type: bool
+    since: 0.38.0
+    description: |
+      Causes, when set to true, to
+      have this target be built by default. This means it will be built when
+      `meson compile` is called without any arguments. The default value is `false`.
+
+      *(since 0.50.0)* If `build_by_default` is explicitly set to false, `install`
+      will no longer override it. If `build_by_default` is not set, `install` will
+      still determine its default.
+
+  build_always:
+    type: bool
+    deprecated: 0.47.0
+    description: |
+      If `true` this target is always considered out of
+      date and is rebuilt every time.  Equivalent to setting both
+      `build_always_stale` and `build_by_default` to true.
+
+  build_always_stale:
+    type: bool
+    since: 0.47.0
+    default: false
+    description: |
+      If `true` the target is always considered out of date.
+      Useful for things such as build timestamps or revision control tags.
+      The associated command is run even if the outputs are up to date.
+
+  capture:
+    type: bool
+    default: false
+    description: |
+      There are some compilers that can't be told to write
+      their output to a file but instead write it to standard output. When
+      this argument is set to true, Meson captures `stdout` and writes it
+      to the target file. Note that your command argument list may not
+      contain `@OUTPUT@` when capture mode is active.
+
+  console:
+    type: bool
+    since: 0.48.0
+    description: |
+      Keyword argument conflicts with `capture`, and is meant
+      for commands that are resource-intensive and take a long time to
+      finish. With the Ninja backend, setting this will add this target
+      to [Ninja's `console` pool](https://ninja-build.org/manual.html#_the_literal_console_literal_pool),
+      which has special properties such as not buffering stdout and
+      serializing all targets in this pool.
+
+  command:
+    type: list[str | file | exe | external_program]
+    description: |
+      Command to run to create outputs from inputs. The command
+      may be strings or the return value of functions that return file-like
+      objects such as [[find_program]],
+      [[executable]], [[configure_file]],
+      [[files]], [[custom_target]], etc.
+      Meson will automatically insert the appropriate dependencies on
+      targets and files listed in this keyword argument.
+      Note: always specify commands in array form `['commandname',
+      '-arg1', '-arg2']` rather than as a string `'commandname -arg1
+      -arg2'` as the latter will *not* work.
+
+  depend_files:
+    type: list[str | file]
+    description: |
+      files ([[@str]],
+      [[@file]], or the return value of [[configure_file]] that
+      this target depends on but are not listed in the `command` keyword
+      argument. Useful for adding regen dependencies.
+
+  depends:
+    type: list[tgt]
+    description: |
+      Specifies that this target depends on the specified
+      target(s), even though it does not take any of them as a command
+      line argument. This is meant for cases where you have a tool that
+      e.g. does globbing internally. Usually you should just put the
+      generated sources as inputs and Meson will set up all dependencies
+      automatically.
+
+  depfile:
+    type: str
+    description: |
+      A dependency file that the command can write listing
+      all the additional files this target depends on, for example a C
+      compiler would list all the header files it included, and a change
+      in any one of these files triggers a recompilation.
+
+      *(since 0.47.0)* the `@BASENAME@` and `@PLAINNAME@` substitutions
+      are also accepted.
+
+  input:
+    type: list[str | file]
+    description: List of source files. *(since 0.41.0)* the list is flattened.
+
+  install:
+    type: bool
+    description: When true, this target is installed during the install step.
+
+  install_dir:
+    type: str | list[str]
+    description: |
+      If only one install_dir is provided, all outputs are installed there.
+      *Since 0.40.0* Allows you to specify the installation directory for each
+      corresponding output. For example:
+      ```meson
+      custom_target('different-install-dirs',
+        output : ['first.file', 'second.file'],
+        install : true,
+        install_dir : ['somedir', 'otherdir])
+      ```
+      This would install `first.file` to `somedir` and `second.file` to `otherdir`.
+
+      To only install some outputs, pass `false` for the outputs that you
+      don't want installed. For example:
+      ```meson
+          custom_target('only-install-second',
+            output : ['first.file', 'second.file'],
+            install : true,
+            install_dir : [false, 'otherdir])
+      ```
+      This would install `second.file` to `otherdir` and not install `first.file`.
+
+  install_mode:
+    type: list[str | int]
+    since: 0.47.0
+    description: |
+      The file mode and optionally the owner/uid and group/gid.
+      See the `install_mode` kwarg of [[install_data]] for more information.
+
+  install_tag:
+    type: list[str]
+    since: 0.60.0
+    description: |
+      A list of strings, one per output, used by the `meson install --tags` command
+      to install only a subset of the files.
+
+      By default all outputs have no install tag which means they are not being
+      installed when `--tags` argument is specified. If only one tag is specified,
+      it is assumed that all outputs have the same tag. `false` can be used for
+      outputs that have no tag or are not installed.
+
+  output:
+    type: list[str]
+    description: List of output files.
+
+  env:
+    since: 0.57.0
+    type: env | list[str] | dict[str]
+    description: |
+      environment variables to set, such as
+      `{'NAME1': 'value1', 'NAME2': 'value2'}` or `['NAME1=value1', 'NAME2=value2']`,
+      or an [[@env]] object which allows more
+      sophisticated environment juggling.
+
+  feed:
+    type: bool
+    since: 0.59.0
+    default: false
+    description: |
+      There are some compilers that can't be told to read
+      their input from a file and instead read it from standard input. When this
+      argument is set to `true`, Meson feeds the input file to `stdin`. Note that
+      your argument list may not contain `@INPUT@` when feed mode is active.

docs/yaml/functions/declare_dependency.yaml

@@ -0,0 +1,59 @@
+name: declare_dependency
+returns: dep
+description: |
+  This function returns a [[@dep]] object that
+  behaves like the return value of [[dependency]] but is
+  internal to the current build. The main use case for this is in
+  subprojects. This allows a subproject to easily specify how it should
+  be used. This makes it interchangeable with the same dependency that
+  is provided externally by the system.
+
+kwargs:
+  compile_args:
+    type: list[str]
+    description: Compile arguments to use.
+
+  dependencies:
+    type: list[dep]
+    description: Other dependencies needed to use this dependency.
+
+  include_directories:
+    type: list[inc | str]
+    description: |
+      the directories to add to header search path,
+      must be [[@inc]] objects or *(since 0.50.0)* plain strings.
+
+  link_args:
+    type: list[str]
+    description: Link arguments to use.
+
+  link_with:
+    type: list[lib]
+    description: Libraries to link against.
+
+  link_whole:
+    type: list[lib]
+    since: 0.46.0
+    description: Libraries to link fully, same as [[executable]].
+
+  sources:
+    type: list[str | file]
+    description: |
+      sources to add to targets
+      (or generated header files
+      that should be built before sources including them are built)
+
+  version:
+    type: str
+    description: |
+      the version of this dependency,
+      such as `1.2.3`. Defaults to the project version.
+
+  variables:
+    type: dict[str] | list[str]
+    since: 0.54.0
+    description: |
+      a dictionary of arbitrary strings,
+      this is meant to be used
+      in subprojects where special variables would be provided via cmake or
+      pkg-config. *since 0.56.0* it can also be a list of `'key=value'` strings.

docs/yaml/functions/dependency.yaml

@@ -0,0 +1,200 @@
+name: dependency
+returns: dep
+description: |
+  Finds an external dependency (usually a library installed on your
+  system) with the given name with `pkg-config` and [with
+  CMake](Dependencies.md#cmake) if `pkg-config` fails. Additionally,
+  frameworks (OSX only) and [library-specific fallback detection
+  logic](Dependencies.md#dependencies-with-custom-lookup-functionality)
+  are also supported.
+
+  *Since 0.60.0* more than one name can be provided, they will be tried in order
+  and the first name to be found will be used. The fallback subproject will be
+  used only if none of the names are found on the system. Once one of the name has
+  been found, all other names are added into the cache so subsequent calls for any
+  of those name will return the same value. This is useful in case a dependency
+  could have different names, such as `png` and `libpng`.
+
+  Dependencies can also be resolved in two other ways:
+
+  * if the same name was used in a `meson.override_dependency` prior to
+    the call to `dependency`, the overriding dependency will be returned
+    unconditionally; that is, the overriding dependency will be used
+    independent of whether an external dependency is installed in the system.
+    Typically, `meson.override_dependency` will have been used by a
+    subproject.
+
+  * by a fallback subproject which, if needed, will be brought into the current
+    build specification as if [`subproject()`](#subproject) had been called.
+    The subproject can be specified with the `fallback` argument.  Alternatively,
+    if the `fallback` argument is absent, *since 0.55.0* Meson can
+    automatically identify a subproject as a fallback if a wrap file
+    [provides](Wrap-dependency-system-manual.md#provide-section) the
+    dependency, or if a subproject has the same name as the dependency.
+    In the latter case, the subproject must use `meson.override_dependency` to
+    specify the replacement, or Meson will report a hard error.  See the
+    [Wrap documentation](Wrap-dependency-system-manual.md#provide-section)
+    for more details.  This automatic search can be controlled using the
+    `allow_fallback` keyword argument.
+
+  If `dependency_name` is `''`, the dependency is always not found. So
+  with `required: false`, this always returns a dependency object for
+  which the `found()` method returns `false`, and which can be passed
+  like any other dependency to the `dependencies:` keyword argument of a
+  `build_target`. This can be used to implement a dependency which is
+  sometimes not required e.g. in some branches of a conditional, or with
+  a `fallback:` kwarg, can be used to declare an optional dependency
+  that only looks in the specified subproject, and only if that's
+  allowed by `--wrap-mode`.
+
+  The returned object [[@dep]] also has additional methods.
+
+notes:
+  - This function supports additional [library-specific](Dependencies.md#dependencies-with-custom-lookup-functionality)
+    keyword arguments that may also be accepted (e.g. `modules` specifies submodules to use for
+    dependencies such as Qt5 or Boost. `components` allows the user to manually
+    add CMake `COMPONENTS` for the `find_package` lookup)
+
+varargs:
+  name: names
+  type: str
+  since: 0.60.0
+  min_varargs: 1
+  description: |
+    The names of the dependency too look up. The dependencies are looked up in
+    the order they are provided here. The first found dependency will then be
+    used. The fallback subproject will be used only if none of the names are
+    found on the system. Once one of the name has been found, all other names
+    are added into the cache so subsequent calls for any of those name will
+    return the same value. This is useful in case a dependency could have
+    different names, such as `png` and `libpng`.
+
+    **NOTE:** Before *0.60.0* only a single dependency name was allowed.
+
+kwargs:
+  default_options:
+    type: list[str]
+    since: 0.37.0
+    description: |
+      An array of default option values
+      that override those set in the subproject's `meson_options.txt`
+      (like `default_options` in [[project]], they only have
+      effect when Meson is run for the first time, and command line
+      arguments override any default options in build files)
+
+  allow_fallback:
+    type: bool
+    since: 0.56.0
+    description: |
+      Specifies whether Meson should automatically pick a fallback subproject
+      in case the dependency
+      is not found in the system.  If `true` and the dependency is not found
+      on the system, Meson will fallback to a subproject that provides this
+      dependency. If `false`, Meson will not fallback even if a subproject
+      provides this dependency.  By default, Meson will do so if `required`
+      is `true` or  [`enabled`](Build-options.md#features); see the [Wrap
+      documentation](Wrap-dependency-system-manual.md#provide-section)
+      for more details.
+
+  fallback:
+    type: list[str] | str
+    description: |
+      Manually specifies a subproject fallback
+      to use in case the dependency is not found in the system.
+      This is useful if the automatic search is not applicable or if you
+      want to support versions of Meson older than 0.55.0.  If the value is an
+      array `['subproj_name', 'subproj_dep']`, the first value is the name
+      of the subproject and the second is the variable name in that
+      subproject that contains a dependency object such as the return
+      value of [[declare_dependency]] or
+      [[dependency]], etc. Note that this means the
+      fallback dependency may be a not-found dependency, in which
+      case the value of the `required:` kwarg will be obeyed.
+      *Since 0.54.0* the value can be a single string, the subproject name;
+      in this case the subproject must use
+      `meson.override_dependency('dependency_name', subproj_dep)`
+      to specify the dependency object used in the superproject.
+      If the value is an empty list, it has the same effect as
+      `allow_fallback: false`.
+
+  language:
+    type: str
+    since: 0.42.0
+    description: |
+      Defines what language-specific dependency to find
+      if it's available for multiple languages.
+
+  method:
+    type: str
+    default: "'auto'"
+    description: |
+      Defines the way the dependency is detected, the default is
+      `auto` but can be overridden to be e.g. `qmake` for Qt development,
+      and [different dependencies support different values](
+      Dependencies.md#dependencies-with-custom-lookup-functionality)
+      for this (though `auto` will work on all of them)
+
+  native:
+    type: bool
+    default: false
+    description: |
+      If set to `true`, causes Meson to find the dependency on
+      the build machine system rather than the host system (i.e. where the
+      cross compiled binary will run on), usually only needed if you build
+      a tool to be used during compilation.
+
+  not_found_message:
+    type: str
+    since: 0.50.0
+    description: An optional string that will be printed as a [[message]] if the dependency was not found.
+
+  required:
+    type: bool | feature
+    default: true
+    description: |
+      when set to false, Meson will proceed with the build
+      even if the dependency is not found. *(since 0.47.0)* The value of a
+      [`feature`](Build-options.md#features) option can also be passed.
+
+  static:
+    type: bool
+    default: false
+    description: |
+      Tells the dependency provider to try to get static
+      libraries instead of dynamic ones (note that this is not supported
+      by all dependency backends)
+
+      *Since 0.60.0* it also sets `default_library` option accordingly on the fallback
+      subproject if it was not set explicitly in `default_options` keyword argument.
+
+  version:
+    type: str
+    since: 0.37.0
+    description: |
+      Specifies the required version,
+      a string containing a
+      comparison operator followed by the version string, examples include
+      `>1.0.0`, `<=2.3.5` or `3.1.4` for exact matching.
+      You can also specify multiple restrictions by passing a list to this
+      keyword argument, such as: `['>=3.14.0', '<=4.1.0']`.
+      These requirements are never met if the version is unknown.
+
+  include_type:
+    type: str
+    default: "'preserve'"
+    since: 0.52.0
+    description: |
+      An enum flag, marking how the dependency
+      flags should be converted. Supported values are `'preserve'`, `'system'` and
+      `'non-system'`. System dependencies may be handled differently on some
+      platforms, for instance, using `-isystem` instead of `-I`, where possible.
+      If `include_type` is set to `'preserve'`, no additional conversion will be
+      performed.
+
+  disabler:
+    type: bool
+    default: false
+    since: 0.49.0
+    description: |
+      Returns a [[disabler]] object instead of a not-found dependency
+      if this kwarg is set to `true` and the dependency couldn't be found.

docs/yaml/functions/disabler.yaml

@@ -0,0 +1,4 @@
+name: disabler
+returns: disabler
+description: Returns a [[@disabler]] object.
+since: 0.44.0

docs/yaml/functions/environment.yaml

@@ -0,0 +1,12 @@
+name: environment
+returns: env
+since: 0.35.0
+description: Returns an empty [[@env]] object.
+
+optargs:
+  env:
+    type: dict[str]
+    since: 0.52.0
+    description: |
+      If provided, each key/value pair is added into the [[@env]] object
+      as if [[env.set]] method was called for each of them.

docs/yaml/functions/error.yaml

@@ -0,0 +1,14 @@
+name: error
+returns: void
+description: Print the argument string and halts the build process.
+
+posargs:
+  message:
+    type: str
+    description: The message to print
+
+varargs:
+  name: msg
+  since: 0.58.0
+  type: str
+  description: Additional parameters will be seperated by spaces

docs/yaml/functions/executable.yaml

@@ -0,0 +1,46 @@
+name: executable
+returns: exe
+description: |
+  Creates a new executable. The first argument specifies its name and
+  the remaining positional arguments define the input files to use.
+
+  The lists for the kwargs (such as `sources`, `objects`, and `dependencies`) are
+  always flattened, which means you can freely nest and add lists while
+  creating the final list.
+
+  The returned object also has methods that are documented in [[@exe]].
+
+warnings:
+  - The `link_language` kwarg was broken until 0.55.0
+
+posargs_inherit: _build_target_base
+varargs_inherit: _build_target_base
+kwargs_inherit: _build_target_base
+
+kwargs:
+  export_dynamic:
+    type: bool
+    since: 0.45.0
+    description: |
+       when set to true causes the target's symbols to be
+        dynamically exported, allowing modules built using the
+        [[shared_module]] function to refer to functions,
+        variables and other symbols defined in the executable itself. Implies
+        the `implib` argument.
+
+  implib:
+    type: bool
+    since: 0.42.0
+    description: |
+      When set to true, an import library is generated for the
+      executable (the name of the import library is based on *exe_name*).
+      Alternatively, when set to a string, that gives the base name for
+      the import library.  The import library is used when the returned
+      build target object appears in `link_with:` elsewhere.  Only has any
+      effect on platforms where that is meaningful (e.g. Windows). Implies
+      the `export_dynamic` argument.
+
+  pie:
+    type: bool
+    since: 0.49.0
+    description: Build a position-independent executable.

docs/yaml/functions/files.yaml

@@ -0,0 +1,30 @@
+name: files
+returns: list[file]
+description: |
+  This command takes the strings given to it in arguments and returns
+  corresponding File objects that you can use as sources for build
+  targets. The difference is that file objects remember the subdirectory
+  they were defined in and can be used anywhere in the source tree.
+
+example: |
+  As an example suppose you have source file `foo.cpp` in subdirectory
+  `bar1` and you would like to use it in a build target that is defined
+  in `bar2`. To make this happen you first create the object in `bar1`
+  like this:
+
+  ```meson
+      foofile = files('foo.cpp')
+  ```
+
+  Then you can use it in `bar2` like this:
+
+  ```meson
+      executable('myprog', 'myprog.cpp', foofile, ...)
+  ```
+
+  Meson will then do the right thing.
+
+varargs:
+  name: file
+  type: str
+  description: Path to the file.

docs/yaml/functions/find_program.yaml

@@ -0,0 +1,108 @@
+name: find_program
+returns: external_program
+description: |
+  `program_name` here is a string that can be an executable or script
+  to be searched for in `PATH` or other places inside the project.
+  The search order is:
+
+  1. Program overrides set via [[meson.override_find_program]]
+  1. [`[provide]` sections](Wrap-dependency-system-manual.md#provide-section)
+    in subproject wrap files, if [`wrap_mode`](Builtin-options.md#core-options) is
+    set to `forcefallback`
+  1. [`[binaries]` section](Machine-files.md#binaries) in your machine files
+  1. Directories provided using the `dirs:` kwarg (see below)
+  1. Project's source tree relative to the current subdir
+    - If you use the return value of [[configure_file]], the
+      current subdir inside the build tree is used instead
+  1. `PATH` environment variable
+  1. [`[provide]` sections](Wrap-dependency-system-manual.md#provide-section) in
+    subproject wrap files, if [`wrap_mode`](Builtin-options.md#core-options) is
+    set to anything other than `nofallback`
+
+  Meson will also autodetect scripts with a shebang line and run them
+  with the executable/interpreter specified in it both on Windows
+  (because the command invocator will reject the command otherwise) and
+  Unixes (if the script file does not have the executable bit set).
+  Hence, you *must not* manually add the interpreter while using this
+  script as part of a list of commands.
+
+  If you need to check for a program in a non-standard location, you can
+  just pass an absolute path to `find_program`, e.g.
+
+  ```meson
+  setcap = find_program('setcap', '/usr/sbin/setcap', '/sbin/setcap', required : false)
+  ```
+
+  It is also possible to pass an array to `find_program` in case you
+  need to construct the set of paths to search on the fly:
+
+  ```meson
+  setcap = find_program(['setcap', '/usr/sbin/setcap', '/sbin/setcap'], required : false)
+  ```
+
+  The returned [[@external_program]] object also has documented methods.
+
+posargs:
+  program_name:
+    type: str
+    description: The name of the program to search
+
+varargs:
+  name: fallback
+  type: str
+  since: 0.37.0
+  description: |
+    These parameters are used as fallback strings to search for.
+    This is meant to be used for cases where the
+    program may have many alternative names, such as `foo` and
+    `foo.py`. The function will check for the arguments one by one and the
+    first one that is found is returned.
+
+kwargs:
+  required:
+    type: bool | feature
+    default: true
+    description: |
+      When `true`, Meson will abort if no program can be found.
+      If `required` is set to `false`,
+      Meson continue even if none of the programs can be found. You can
+      then use the `.found()` method on the returned [[@external_program]] to check
+      whether it was found or not. *(since 0.47.0)* The value of a
+      [`feature`](Build-options.md#features) option can also be passed to the
+      `required` keyword argument.
+
+  native:
+    type: bool
+    default: false
+    since: 0.43.0
+    description: |
+      Defines how this executable should be searched. By default
+      it is set to `false`, which causes Meson to first look for the
+      executable in the cross file (when cross building) and if it is not
+      defined there, then from the system. If set to `true`, the cross
+      file is ignored and the program is only searched from the system.
+
+  disabler:
+    type: bool
+    since: 0.49.0
+    default: false
+    description: |
+      If `true` and the program couldn't be found, return a [[@disabler]] object
+      instead of a not-found object.
+
+  version:
+    type: str
+    since: 0.52.0
+    description: |
+      specifies the required version, see
+      [[dependency]] for argument format. The version of the program
+      is determined by running `program_name --version` command. If stdout is empty
+      it fallbacks to stderr. If the output contains more text than simply a version
+      number, only the first occurrence of numbers separated by dots is kept.
+      If the output is more complicated than that, the version checking will have to
+      be done manually using [[run_command]].
+
+  dirs:
+    type: list[str]
+    since: 0.53.0
+    description: extra list of absolute paths where to look for program names.

docs/yaml/functions/generator.yaml

@@ -0,0 +1,83 @@
+name: generator
+returns: generator
+description: |
+  See also: [[custom_target]]
+
+  This function creates a [[@generator]] object that can
+  be used to run custom compilation commands. The only positional
+  argument is the executable to use. It can either be a self-built
+  executable or one returned by find_program.
+
+  The template strings passed to all the keyword arguments accept
+  the following special substitutions:
+
+  - `@PLAINNAME@`: the complete input file name, e.g: `foo.c` becomes `foo.c` (unchanged)
+  - `@BASENAME@`: the base of the input filename, e.g.: `foo.c.y` becomes `foo.c` (extension is removed)
+
+  Each string passed to the `output` keyword argument *must* be
+  constructed using one or both of these two substitutions.
+
+  In addition to the above substitutions, the `arguments` keyword
+  argument also accepts the following:
+
+  - `@OUTPUT@`: the full path to the output file
+  - `@INPUT@`: the full path to the input file
+  - `@DEPFILE@`: the full path to the depfile
+  - `@SOURCE_DIR@`: the full path to the root of the source tree
+  - `@CURRENT_SOURCE_DIR@`: this is the directory where the currently processed meson.build is located in
+  - `@BUILD_DIR@`: the full path to the root of the build dir where the output will be placed
+
+  NOTE: Generators should only be used for outputs that will ***only***
+  be used as inputs for a [[build_target]] or a [[custom_target]].
+  When you use the processed output of a
+  generator in multiple targets, the generator will be run multiple
+  times to create outputs for each target. Each output will be created
+  in a target-private directory `@BUILD_DIR@`.
+
+  If you want to generate files for general purposes such as for
+  generating headers to be used by several sources, or data that will be
+  installed, and so on, use a [[custom_target]] instead.
+
+posargs:
+  exe:
+    type: exe | external_program
+    description: Executable for the command to run
+
+kwargs:
+  arguments:
+    type: list[str]
+    description: A list of template strings that will be the command line arguments passed to the executable.
+
+  depends:
+    # Not sure why this is not just `target`
+    type: list[build_tgt | custom_tgt]
+    since: 0.51.0
+    description: |
+      An array of build targets that must be built before
+      this generator can be run. This is used if you have a generator that calls
+      a second executable that is built in this project.
+
+  depfile:
+    type: str
+    description: |
+      A template string pointing to a dependency file that a
+      generator can write listing all the additional files this target
+      depends on, for example a C compiler would list all the header files
+      it included, and a change in any one of these files triggers a
+      recompilation,
+
+  output:
+    type: list[str]
+    description: |
+      Template string (or list of template strings) defining
+      how an output file name is (or multiple output names are) generated
+      from a single source file name.
+
+  capture:
+    type: bool
+    default: false
+    since: 0.43.0
+    description: |
+      When this argument is set to true, Meson captures `stdout`
+      of the `executable` and writes it to the target file
+      specified as `output`.

docs/yaml/functions/get_option.yaml

@@ -0,0 +1,28 @@
+name: get_option
+returns: str | int | bool | feature | list[str | int | bool]
+description: |
+  Obtains the value of the [project build option](Build-options.md)
+  specified in the positional argument.
+
+  Note that the value returned for built-in options that end in `dir`
+  such as `bindir` and `libdir` is always a path relative to (and
+  inside) the `prefix`.
+
+  The only exceptions are: `sysconfdir`, `localstatedir`, and
+  `sharedstatedir` which will return the value passed during
+  configuration as-is, which may be absolute, or relative to `prefix`.
+  [`install_dir` arguments](Installing.md) handles that as expected, but
+  if you need the absolute path to one of these e.g. to use in a define
+  etc., you should use `get_option('prefix') /
+  get_option('localstatedir')`
+
+  For options of type `feature` a
+  [[@feature]] option object
+  is returned instead of a string.
+  See [`feature` options](Build-options.md#features)
+  documentation for more details.
+
+posargs:
+  option_name:
+    type: str
+    description: Name of the option to query

docs/yaml/functions/get_variable.yaml

@@ -0,0 +1,19 @@
+name: get_variable
+returns: any
+description: |
+  This function can be used to dynamically obtain a variable. `res =
+  get_variable(varname, fallback)` takes the value of `varname` (which
+  must be a string) and stores the variable of that name into `res`. If
+  the variable does not exist, the variable `fallback` is stored to
+  `res`instead. If a fallback is not specified, then attempting to read
+  a non-existing variable will cause a fatal error.
+
+posargs:
+  variable_name:
+    type: str
+    description: Name of the variable to get
+
+optargs:
+  default:
+    type: any
+    description: Fallback value to return when the variable does not exist

docs/yaml/functions/import.yaml

@@ -0,0 +1,28 @@
+name: import
+returns: module
+description: |
+  Imports the given extension module. Returns an object that can be used to call
+  the methods of the module. Here's an example for a hypothetical `testmod`
+  module.
+
+example: |
+  ```meson
+  tmod = import('testmod')
+  tmod.do_something()
+  ```
+
+posargs:
+  module_name:
+    type: str
+    description: Name of the module to import.
+
+kwargs:
+  required:
+    type: bool | feature
+    since: 0.59.0
+    description: Whether the mdule is required and Meson should abort if not found.
+
+  disabler:
+    type: bool
+    since: 0.59.0
+    description: Returns a [[@disabler]] object when not found.

docs/yaml/functions/include_directories.yaml

@@ -0,0 +1,72 @@
+name: include_directories
+returns: inc
+description: |
+  Returns an opaque object which contains the directories (relative to
+  the current directory) given in the positional arguments. The result
+  can then be passed to the `include_directories:` keyword argument when
+  building executables or libraries. You can use the returned object in
+  any subdirectory you want, Meson will make the paths work
+  automatically.
+
+  Note that this function call itself does not add the directories into
+  the search path, since there is no global search path. For something
+  like that, see [`add_project_arguments()`](#add_project_arguments).
+
+  See also `implicit_include_directories` parameter of
+  [[executable]], which adds current source and build
+  directories to include path.
+
+  Each directory given is converted to two include paths: one that is
+  relative to the source root and one relative to the build root.
+
+example: |
+  For example, with the following source tree layout in
+  `/home/user/project.git`:
+
+  `meson.build`:
+  ```meson
+  project(...)
+
+  subdir('include')
+  subdir('src')
+
+  ...
+  ```
+
+  `include/meson.build`:
+  ```meson
+  inc = include_directories('.')
+
+  ...
+  ```
+
+  `src/meson.build`:
+  ```meson
+  sources = [...]
+
+  executable('some-tool', sources,
+    include_directories : inc,
+    ...)
+
+  ...
+  ```
+
+  If the build tree is `/tmp/build-tree`, the following include paths
+  will be added to the `executable()` call: `-I/tmp/build-tree/include
+  -I/home/user/project.git/include`.
+
+varargs:
+  name: includes
+  type: str
+  description: Include paths to add.
+
+kwargs:
+  is_system:
+    type: bool
+    default: false
+    description: |
+      If set to `true`, flags the specified directories as system directories.
+      This means that
+      they will be used with the `-isystem` compiler argument rather than
+      `-I` on compilers that support this flag (in practice everything
+      except Visual Studio).

docs/yaml/functions/install_data.yaml

@@ -0,0 +1,57 @@
+name: install_data
+returns: void
+description: |
+  Installs files from the source tree that are listed as positional arguments.
+
+  See [Installing](Installing.md) for more examples.
+
+varargs:
+  name: file
+  type: file | str
+  description: Files to install.
+
+kwargs:
+  install_dir:
+    type: str
+    description: |
+      The absolute or relative path to the installation directory.
+      If this is a relative path, it is assumed to be relative to the prefix.
+
+      If omitted, the directory defaults to `{datadir}/{projectname}` *(since 0.45.0)*.
+
+  install_mode:
+    type: list[str | int]
+    since: 0.38.0
+    description: |
+      specify the file mode in symbolic format and
+      optionally the owner/uid and group/gid for the installed files. For
+      example:
+
+      `install_mode: 'rw-r--r--'` for just the file mode
+
+      `install_mode: ['rw-r--r--', 'nobody', 'nogroup']` for the file mode and the user/group
+
+      `install_mode: ['rw-r-----', 0, 0]` for the file mode and uid/gid
+
+      To leave any of these three as the default, specify `false`.
+
+  install_tag:
+    type: str
+    since: 0.60.0
+    description: |
+      A string used by the `meson install --tags` command
+      to install only a subset of the files. By default these files have no install
+      tag which means they are not being installed when `--tags` argument is specified.
+
+  rename:
+    type: list[str]
+    since: 0.46.0
+    description: |
+      If specified renames each source file into corresponding file from `rename` list.
+      Nested paths are allowed and they are
+      joined with `install_dir`. Length of `rename` list must be equal to
+      the number of sources.
+
+  sources:
+    type: list[file | str]
+    description: Additional files to install.

docs/yaml/functions/install_headers.yaml

@@ -0,0 +1,53 @@
+name: install_headers
+returns: void
+description: |
+  Installs the specified header files from the source tree into the
+  system header directory (usually `/{prefix}/include`) during the
+  install step. This directory can be overridden by specifying it with
+  the `install_dir` keyword argument. If you just want to install into a
+  subdirectory of the system header directory, then use the `subdir`
+  argument. As an example if this has the value `myproj` then the
+  headers would be installed to `/{prefix}/include/myproj`.
+
+example: |
+  For example, this will install `common.h` and `kola.h` into
+  `/{prefix}/include`:
+
+  ```meson
+  install_headers('common.h', 'proj/kola.h')
+  ```
+
+  This will install `common.h` and `kola.h` into `/{prefix}/include/myproj`:
+
+  ```meson
+  install_headers('common.h', 'proj/kola.h', subdir : 'myproj')
+  ```
+
+  This will install `common.h` and `kola.h` into `/{prefix}/cust/myproj`:
+
+  ```meson
+  install_headers('common.h', 'proj/kola.h', install_dir : 'cust', subdir : 'myproj')
+  ```
+
+varargs:
+  name: file
+  type: file | str
+  description: Header files to install.
+
+kwargs:
+  install_dir:
+    type: str
+    description: Where to install to
+
+  subdir:
+    type: str
+    description: Use the `subdir` in the `install_dir`
+
+  install_mode:
+    type: list[str | int]
+    since: 0.47.0
+    description: |
+      Specify the file mode in symbolic format
+      and optionally the owner/uid and group/gid for the installed files.
+
+      See the `install_mode` kwarg of [[install_data]] for more information.

docs/yaml/functions/install_man.yaml

@@ -0,0 +1,40 @@
+name: install_man
+returns: void
+description: |
+  Installs the specified man files from the source tree into system's man directory
+  during the install step. This directory can be
+  overridden by specifying it with the `install_dir` keyword argument.
+
+  *(since 0.49.0)* [manpages are no longer compressed implicitly][install_man_49].
+
+  [install_man_49]:
+  https://mesonbuild.com/Release-notes-for-0-49-0.html#manpages-are-no-longer-compressed-implicitly
+
+varargs:
+  name: file
+  type: file | str
+  description: Man pages to install.
+
+kwargs:
+  install_mode:
+    type: list[str | int]
+    since: 0.47.0
+    description: |
+      Specify the file mode in symbolic format
+      and optionally the owner/uid and group/gid for the installed files.
+
+      See the `install_mode` kwarg of [[install_data]] for more information.
+
+  install_dir:
+    type: str
+    description: Where to install to.
+
+  locale:
+    type: str
+    since: 0.58.0
+    description: |
+      Can be used to specify the locale
+      into which the
+      man page will be installed within the manual page directory tree.
+      An example manual might be `foo.fr.1` with a locale of `fr`, such
+      that `{mandir}/{locale}/man{num}/foo.1` becomes the installed file.

docs/yaml/functions/install_subdir.yaml

@@ -0,0 +1,102 @@
+name: install_subdir
+returns: void
+description: |
+  Installs the entire given subdirectory and its contents from the
+  source tree to the location specified by the keyword argument
+  `install_dir`.
+
+  If the subdirectory does not exist in the source tree, an empty directory is
+  created in the specified location. *(since 0.45.0)* A newly created
+  subdirectory may only be created in the keyword argument `install_dir`.
+
+example: |
+  For a given directory `foo`:
+  ```text
+  foo/
+    bar/
+      file1
+    file2
+  ```
+  `install_subdir('foo', install_dir : 'share', strip_directory : false)` creates
+  ```text
+  share/
+    foo/
+      bar/
+        file1
+      file2
+  ```
+
+  `install_subdir('foo', install_dir : 'share', strip_directory : true)` creates
+  ```text
+  share/
+    bar/
+      file1
+    file2
+  ```
+
+  `install_subdir('foo/bar', install_dir : 'share', strip_directory : false)` creates
+  ```text
+  share/
+    bar/
+      file1
+  ```
+
+  `install_subdir('foo/bar', install_dir : 'share', strip_directory : true)` creates
+  ```text
+  share/
+    file1
+  ```
+
+  `install_subdir('new_directory', install_dir : 'share')` creates
+  ```text
+  share/
+    new_directory/
+  ```
+
+posargs:
+  subdir_name:
+    type: str
+    description: The sub-directory to install
+
+kwargs:
+  install_mode:
+    type: list[str | int]
+    since: 0.47.0
+    description: |
+      Specify the file mode in symbolic format
+      and optionally the owner/uid and group/gid for the installed files.
+
+      See the `install_mode` kwarg of [[install_data]] for more information.
+
+  install_tag:
+    type: str
+    since: 0.60.0
+    description: |
+      A string used by the `meson install --tags` command
+      to install only a subset of the files. By default these files have no install
+      tag which means they are not being installed when `--tags` argument is specified.
+
+  exclude_files:
+    type: list[str]
+    description: |
+      A list of file names that should not be installed.
+      Names are interpreted as paths relative to the `subdir_name` location.
+
+  exclude_directories:
+    type: list[str]
+    since: 0.47.0
+    description: |
+      A list of directory names that should not be installed.
+      Names are interpreted as paths relative to the `subdir_name` location.
+
+  install_dir:
+    type: str
+    description: Where to install to.
+
+  strip_directory:
+    type: bool
+    since: 0.45.0
+    default: false
+    description: |
+      Install directory contents.
+      If `strip_directory=true` only the last component of the source path is used.

docs/yaml/functions/is_disabler.yaml

@@ -0,0 +1,9 @@
+name: is_disabler
+returns: bool
+since: 0.52.0
+description: Returns true if a variable is a disabler and false otherwise.
+
+posargs:
+  var:
+    type: any
+    description: The varaible to test