_yaml: add 'get_mapping()' to MappingNode

This allows to get a mapping node from another 'MappingNode',
replacing 'node_get(my_mapping, key, type=dict)'

Also changes all places where 'node_get' was called like that by
the new API.

19 files changed, 101 insertions, 77 deletions

diff --git a/src/buildstream/_basecache.py b/src/buildstream/_basecache.py
index 49930d4ca..dbb053932 100644
--- a/src/buildstream/_basecache.py
+++ b/src/buildstream/_basecache.py
@@ -74,7 +74,7 @@ class BaseCache():
         cache_specs = []
 
         try:
-            artifacts = [_yaml.node_get(config_node, dict, cls.config_node_name)]
+            artifacts = [config_node.get_mapping(cls.config_node_name)]
         except LoadError:
             try:
                 artifacts = _yaml.node_get(config_node, list, cls.config_node_name, default_value=[])
diff --git a/src/buildstream/_context.py b/src/buildstream/_context.py
index 3f6e6ac3c..c44962d7e 100644
--- a/src/buildstream/_context.py
+++ b/src/buildstream/_context.py
@@ -251,7 +251,7 @@ class Context():
         # Load quota configuration
         # We need to find the first existing directory in the path of our
         # cachedir - the cachedir may not have been created yet.
-        cache = _yaml.node_get(defaults, dict, 'cache')
+        cache = defaults.get_mapping('cache')
         _yaml.node_validate(cache, ['quota', 'pull-buildtrees', 'cache-buildtrees'])
 
         self.config_cache_quota_string = _yaml.node_get(cache, str, 'quota')
@@ -280,7 +280,7 @@ class Context():
             cache, 'cache-buildtrees', ['always', 'auto', 'never'])
 
         # Load logging config
-        logging = _yaml.node_get(defaults, dict, 'logging')
+        logging = defaults.get_mapping('logging')
         _yaml.node_validate(logging, [
             'key-length', 'verbose',
             'error-lines', 'message-lines',
@@ -295,7 +295,7 @@ class Context():
         self.log_message_format = _yaml.node_get(logging, str, 'message-format')
 
         # Load scheduler config
-        scheduler = _yaml.node_get(defaults, dict, 'scheduler')
+        scheduler = defaults.get_mapping('scheduler')
         _yaml.node_validate(scheduler, [
             'on-error', 'fetchers', 'builders',
             'pushers', 'network-retries'
@@ -308,7 +308,7 @@ class Context():
         self.sched_network_retries = _yaml.node_get(scheduler, int, 'network-retries')
 
         # Load per-projects overrides
-        self._project_overrides = _yaml.node_get(defaults, dict, 'projects', default_value={})
+        self._project_overrides = defaults.get_mapping('projects', default={})
 
         # Shallow validation of overrides, parts of buildstream which rely
         # on the overrides are expected to validate elsewhere.
@@ -408,7 +408,7 @@ class Context():
     #    (dict): The overrides dictionary for the specified project
     #
     def get_overrides(self, project_name):
-        return _yaml.node_get(self._project_overrides, dict, project_name, default_value={})
+        return self._project_overrides.get_mapping(project_name, default={})
 
     # get_strict():
     #
diff --git a/src/buildstream/_gitsourcebase.py b/src/buildstream/_gitsourcebase.py
index 1f539d820..8c6b54e2d 100644
--- a/src/buildstream/_gitsourcebase.py
+++ b/src/buildstream/_gitsourcebase.py
@@ -412,9 +412,9 @@ class _GitSourceBase(Source):
         # and submodule_checkout_overrides dictionaries.
         self.submodule_overrides = {}
         self.submodule_checkout_overrides = {}
-        modules = self.node_get_member(node, dict, 'submodules', {})
+        modules = node.get_mapping('submodules', {})
         for path, _ in self.node_items(modules):
-            submodule = self.node_get_member(modules, dict, path)
+            submodule = modules.get_mapping(path)
             url = self.node_get_member(submodule, str, 'url', None)
 
             # Make sure to mark all URLs that are specified in the configuration
diff --git a/src/buildstream/_loader/loader.py b/src/buildstream/_loader/loader.py
index fa3539b22..6036f4f07 100644
--- a/src/buildstream/_loader/loader.py
+++ b/src/buildstream/_loader/loader.py
@@ -487,12 +487,12 @@ class Loader():
 
         meta_element = MetaElement(self.project, element.name, element_kind,
                                    elt_provenance, meta_sources,
-                                   _yaml.node_get(node, dict, Symbol.CONFIG, default_value={}),
-                                   _yaml.node_get(node, dict, Symbol.VARIABLES, default_value={}),
-                                   _yaml.node_get(node, dict, Symbol.ENVIRONMENT, default_value={}),
+                                   node.get_mapping(Symbol.CONFIG, default={}),
+                                   node.get_mapping(Symbol.VARIABLES, default={}),
+                                   node.get_mapping(Symbol.ENVIRONMENT, default={}),
                                    _yaml.node_get(node, list, Symbol.ENV_NOCACHE, default_value=[]),
-                                   _yaml.node_get(node, dict, Symbol.PUBLIC, default_value={}),
-                                   _yaml.node_get(node, dict, Symbol.SANDBOX, default_value={}),
+                                   node.get_mapping(Symbol.PUBLIC, default={}),
+                                   node.get_mapping(Symbol.SANDBOX, default={}),
                                    element_kind == 'junction')
 
         # Cache it now, make sure it's already there before recursing
diff --git a/src/buildstream/_project.py b/src/buildstream/_project.py
index 114d25054..e23689d99 100644
--- a/src/buildstream/_project.py
+++ b/src/buildstream/_project.py
@@ -600,7 +600,7 @@ class Project():
         self.config.options = OptionPool(self.element_path)
         self.first_pass_config.options = OptionPool(self.element_path)
 
-        defaults = _yaml.node_get(pre_config_node, dict, 'defaults')
+        defaults = pre_config_node.get_mapping('defaults')
         _yaml.node_validate(defaults, ['targets'])
         self._default_targets = _yaml.node_get(defaults, list, "targets")
 
@@ -677,14 +677,14 @@ class Project():
             self.remote_execution_specs = self._context.remote_execution_specs
 
         # Load sandbox environment variables
-        self.base_environment = _yaml.node_get(config, dict, 'environment')
+        self.base_environment = config.get_mapping('environment')
         self.base_env_nocache = _yaml.node_get(config, list, 'environment-nocache')
 
         # Load sandbox configuration
-        self._sandbox = _yaml.node_get(config, dict, 'sandbox')
+        self._sandbox = config.get_mapping('sandbox')
 
         # Load project split rules
-        self._splits = _yaml.node_get(config, dict, 'split-rules')
+        self._splits = config.get_mapping('split-rules')
 
         # Support backwards compatibility for fail-on-overlap
         fail_on_overlap = _yaml.node_get(config, bool, 'fail-on-overlap', default_value=None)
@@ -708,12 +708,12 @@ class Project():
             self.refs.load(self.options)
 
         # Parse shell options
-        shell_options = _yaml.node_get(config, dict, 'shell')
+        shell_options = config.get_mapping('shell')
         _yaml.node_validate(shell_options, ['command', 'environment', 'host-files'])
         self._shell_command = _yaml.node_get(shell_options, list, 'command')
 
         # Perform environment expansion right away
-        shell_environment = _yaml.node_get(shell_options, dict, 'environment', default_value={})
+        shell_environment = shell_options.get_mapping('environment', default={})
         for key in _yaml.node_keys(shell_environment):
             value = _yaml.node_get(shell_environment, str, key)
             self._shell_environment[key] = os.path.expandvars(value)
@@ -753,8 +753,8 @@ class Project():
         # Element and Source  type configurations will be composited later onto
         # element/source types, so we delete it from here and run our final
         # assertion after.
-        output.element_overrides = _yaml.node_get(config, dict, 'elements', default_value={})
-        output.source_overrides = _yaml.node_get(config, dict, 'sources', default_value={})
+        output.element_overrides = config.get_mapping('elements', default={})
+        output.source_overrides = config.get_mapping('sources', default={})
         _yaml.node_del(config, 'elements', safe=True)
         _yaml.node_del(config, 'sources', safe=True)
         _yaml.node_final_assertions(config)
@@ -762,7 +762,7 @@ class Project():
         self._load_plugin_factories(config, output)
 
         # Load project options
-        options_node = _yaml.node_get(config, dict, 'options', default_value={})
+        options_node = config.get_mapping('options', default={})
         output.options.load(options_node)
         if self.junction:
             # load before user configuration
@@ -770,7 +770,7 @@ class Project():
 
         # Collect option values specified in the user configuration
         overrides = self._context.get_overrides(self.name)
-        override_options = _yaml.node_get(overrides, dict, 'options', default_value={})
+        override_options = overrides.get_mapping('options', default={})
         output.options.load_yaml_values(override_options)
         if self._cli_options:
             output.options.load_cli_values(self._cli_options, ignore_unknown=ignore_unknown)
@@ -789,7 +789,7 @@ class Project():
         output.options.process_node(output.source_overrides)
 
         # Load base variables
-        output.base_variables = _yaml.node_get(config, dict, 'variables')
+        output.base_variables = config.get_mapping('variables')
 
         # Add the project name as a default variable
         _yaml.node_set(output.base_variables, 'project-name', self.name)
@@ -817,7 +817,7 @@ class Project():
             _yaml.node_validate(mirror, allowed_mirror_fields)
             mirror_name = _yaml.node_get(mirror, str, 'name')
             alias_mappings = {}
-            for alias_mapping, uris in _yaml.node_items(_yaml.node_get(mirror, dict, 'aliases')):
+            for alias_mapping, uris in _yaml.node_items(mirror.get_mapping('aliases')):
                 assert isinstance(uris, list)
                 alias_mappings[alias_mapping] = list(uris)
             output.mirrors[mirror_name] = alias_mappings
@@ -825,7 +825,7 @@ class Project():
                 output.default_mirror = mirror_name
 
         # Source url aliases
-        output._aliases = _yaml.node_get(config, dict, 'aliases', default_value={})
+        output._aliases = config.get_mapping('aliases', default={})
 
     # _find_project_dir()
     #
@@ -888,7 +888,7 @@ class Project():
                     .format(origin_value))
 
             # Store source versions for checking later
-            source_versions = _yaml.node_get(origin, dict, 'sources', default_value={})
+            source_versions = origin.get_mapping('sources', default={})
             for key in _yaml.node_keys(source_versions):
                 if key in source_format_versions:
                     raise LoadError(
@@ -897,7 +897,7 @@ class Project():
                 source_format_versions[key] = _yaml.node_get(source_versions, int, key)
 
             # Store element versions for checking later
-            element_versions = _yaml.node_get(origin, dict, 'elements', default_value={})
+            element_versions = origin.get_mapping('elements', default={})
             for key in _yaml.node_keys(element_versions):
                 if key in element_format_versions:
                     raise LoadError(
@@ -941,7 +941,7 @@ class Project():
         node_keys = [key for key in _yaml.node_keys(origin)]
         if plugin_group in node_keys:
             origin_node = _yaml.node_copy(origin)
-            plugins = _yaml.node_get(origin, dict, plugin_group, default_value={})
+            plugins = origin.get_mapping(plugin_group, default={})
             _yaml.node_set(origin_node, 'plugins', [k for k in _yaml.node_keys(plugins)])
             for group in expected_groups:
                 if group in origin_node:
diff --git a/src/buildstream/_projectrefs.py b/src/buildstream/_projectrefs.py
index 09205a7c3..847935c0b 100644
--- a/src/buildstream/_projectrefs.py
+++ b/src/buildstream/_projectrefs.py
@@ -123,8 +123,8 @@ class ProjectRefs():
     def _lookup(self, toplevel, project, element, source_index, *, ensure=False):
         # Fetch the project
         try:
-            projects = _yaml.node_get(toplevel, dict, 'projects')
-            project_node = _yaml.node_get(projects, dict, project)
+            projects = toplevel.get_mapping('projects')
+            project_node = projects.get_mapping(project)
         except LoadError:
             if not ensure:
                 return None
diff --git a/src/buildstream/_workspaces.py b/src/buildstream/_workspaces.py
index 9fbfb7e63..1adc52ac2 100644
--- a/src/buildstream/_workspaces.py
+++ b/src/buildstream/_workspaces.py
@@ -606,8 +606,7 @@ class Workspaces():
             }
 
         elif 1 <= version <= BST_WORKSPACE_FORMAT_VERSION:
-            workspaces = _yaml.node_get(workspaces, dict, "workspaces",
-                                        default_value=_yaml.new_empty_node())
+            workspaces = workspaces.get_mapping("workspaces", default={})
             res = {element: self._load_workspace(node)
                    for element, node in _yaml.node_items(workspaces)}
 
@@ -635,7 +634,7 @@ class Workspaces():
             'path': _yaml.node_get(node, str, 'path'),
             'last_successful': _yaml.node_get(node, str, 'last_successful', default_value=None),
             'running_files': _yaml.node_sanitize(
-                _yaml.node_get(node, dict, 'running_files', default_value=None),
+                node.get_mapping('running_files', default=None),
                 dict_type=dict),
         }
         return Workspace.from_dict(self._toplevel_project, dictionary)
diff --git a/src/buildstream/_yaml.pxd b/src/buildstream/_yaml.pxd
index 4b628016f..7d7e87d8d 100644
--- a/src/buildstream/_yaml.pxd
+++ b/src/buildstream/_yaml.pxd
@@ -29,7 +29,8 @@ cdef class Node:
 
 
 cdef class MappingNode(Node):
-    pass
+    cdef Node get(self, str key, default, default_constructor)
+    cpdef MappingNode get_mapping(self, str key, default=*)
 
 
 cdef class ProvenanceInformation:
diff --git a/src/buildstream/_yaml.pyx b/src/buildstream/_yaml.pyx
index 4ce10acd0..9d9a12400 100644
--- a/src/buildstream/_yaml.pyx
+++ b/src/buildstream/_yaml.pyx
@@ -40,6 +40,11 @@ from ._exceptions import LoadError, LoadErrorReason
 # pylint: disable=unidiomatic-typecheck
 
 
+# A sentinel to be used as a default argument for functions that need
+# to distinguish between a kwarg set to None and an unset kwarg.
+_sentinel = object()
+
+
 # Node()
 #
 # Container for YAML loaded data and its provenance
@@ -87,6 +92,33 @@ cdef class MappingNode(Node):
         self.line = line
         self.column = column
 
+    cdef Node get(self, str key, object default, object default_constructor):
+        value = self.value.get(key, _sentinel)
+
+        if value is _sentinel:
+            if default is _sentinel:
+                provenance = node_get_provenance(self)
+                raise LoadError(LoadErrorReason.INVALID_DATA,
+                                "{}: Dictionary did not contain expected key '{}'".format(provenance, key))
+
+            if default is None:
+                value = None
+            else:
+                value = default_constructor(default, _SYNTHETIC_FILE_INDEX, 0, next_synthetic_counter())
+
+        return value
+
+    cpdef MappingNode get_mapping(self, str key, object default=_sentinel):
+        value = self.get(key, default, MappingNode)
+
+        if type(value) is not MappingNode and value is not None:
+            provenance = node_get_provenance(value)
+            raise LoadError(LoadErrorReason.INVALID_DATA,
+                            "{}: Value of '{}' is not of the expected type 'Mapping'"
+                            .format(provenance, key))
+
+        return value
+
 
 class SequenceNode(Node):
     def __init__(self, list value, int file_index, int line, int column):
@@ -531,11 +563,6 @@ cpdef ProvenanceInformation node_get_provenance(Node node, str key=None, list in
     return ProvenanceInformation(nodeish)
 
 
-# A sentinel to be used as a default argument for functions that need
-# to distinguish between a kwarg set to None and an unset kwarg.
-_sentinel = object()
-
-
 # node_get()
 #
 # Fetches a value from a dictionary node and checks it for
diff --git a/src/buildstream/element.py b/src/buildstream/element.py
index 60aefecad..aaf8577a5 100644
--- a/src/buildstream/element.py
+++ b/src/buildstream/element.py
@@ -896,7 +896,7 @@ class Element(Plugin):
         if self.__dynamic_public is None:
             self.__load_public_data()
 
-        data = _yaml.node_get(self.__dynamic_public, dict, domain, default_value=None)
+        data = self.__dynamic_public.get_mapping(domain, default=None)
         if data is not None:
             data = _yaml.node_copy(data)
 
@@ -2539,9 +2539,9 @@ class Element(Plugin):
     @classmethod
     def __compose_default_splits(cls, project, defaults, is_junction):
 
-        element_public = _yaml.node_get(defaults, dict, 'public', default_value={})
-        element_bst = _yaml.node_get(element_public, dict, 'bst', default_value={})
-        element_splits = _yaml.node_get(element_bst, dict, 'split-rules', default_value={})
+        element_public = defaults.get_mapping("public", default={})
+        element_bst = element_public.get_mapping("bst", default={})
+        element_splits = element_bst.get_mapping("split-rules", default={})
 
         if is_junction:
             splits = _yaml.node_copy(element_splits)
@@ -2581,7 +2581,7 @@ class Element(Plugin):
             else:
                 elements = project.element_overrides
 
-            overrides = _yaml.node_get(elements, dict, kind, default_value=None)
+            overrides = elements.get_mapping(kind, default=None)
             if overrides:
                 _yaml.composite(defaults, overrides)
 
@@ -2593,7 +2593,7 @@ class Element(Plugin):
     #
     @classmethod
     def __extract_environment(cls, project, meta):
-        default_env = _yaml.node_get(cls.__defaults, dict, 'environment', default_value={})
+        default_env = cls.__defaults.get_mapping("environment", default={})
 
         if meta.is_junction:
             environment = _yaml.new_empty_node()
@@ -2639,8 +2639,7 @@ class Element(Plugin):
     #
     @classmethod
     def __extract_variables(cls, project, meta):
-        default_vars = _yaml.node_get(cls.__defaults, dict, 'variables',
-                                      default_value={})
+        default_vars = cls.__defaults.get_mapping('variables', default={})
 
         if meta.is_junction:
             variables = _yaml.node_copy(project.first_pass_config.base_variables)
@@ -2667,7 +2666,7 @@ class Element(Plugin):
     def __extract_config(cls, meta):
 
         # The default config is already composited with the project overrides
-        config = _yaml.node_get(cls.__defaults, dict, 'config', default_value={})
+        config = cls.__defaults.get_mapping('config', default={})
         config = _yaml.node_copy(config)
 
         _yaml.composite(config, meta.config)
@@ -2693,7 +2692,7 @@ class Element(Plugin):
         host_os = platform.get_host_os()
 
         # The default config is already composited with the project overrides
-        sandbox_defaults = _yaml.node_get(cls.__defaults, dict, 'sandbox', default_value={})
+        sandbox_defaults = cls.__defaults.get_mapping('sandbox', default={})
         sandbox_defaults = _yaml.node_copy(sandbox_defaults)
 
         _yaml.composite(sandbox_config, sandbox_defaults)
@@ -2720,15 +2719,15 @@ class Element(Plugin):
     #
     @classmethod
     def __extract_public(cls, meta):
-        base_public = _yaml.node_get(cls.__defaults, dict, 'public', default_value={})
+        base_public = cls.__defaults.get_mapping('public', default={})
         base_public = _yaml.node_copy(base_public)
 
-        base_bst = _yaml.node_get(base_public, dict, 'bst', default_value={})
-        base_splits = _yaml.node_get(base_bst, dict, 'split-rules', default_value={})
+        base_bst = base_public.get_mapping('bst', default={})
+        base_splits = base_bst.get_mapping('split-rules', default={})
 
         element_public = _yaml.node_copy(meta.public)
-        element_bst = _yaml.node_get(element_public, dict, 'bst', default_value={})
-        element_splits = _yaml.node_get(element_bst, dict, 'split-rules', default_value={})
+        element_bst = element_public.get_mapping('bst', default={})
+        element_splits = element_bst.get_mapping('split-rules', default={})
 
         # Allow elements to extend the default splits defined in their project or
         # element specific defaults
@@ -2743,8 +2742,8 @@ class Element(Plugin):
 
     # Expand the splits in the public data using the Variables in the element
     def __expand_splits(self, element_public):
-        element_bst = _yaml.node_get(element_public, dict, 'bst', default_value={})
-        element_splits = _yaml.node_get(element_bst, dict, 'split-rules', default_value={})
+        element_bst = element_public.get_mapping('bst', default={})
+        element_splits = element_bst.get_mapping('split-rules', default={})
 
         # Resolve any variables in the public split rules directly
         for domain, splits in self.node_items(element_splits):
@@ -2758,7 +2757,7 @@ class Element(Plugin):
 
     def __init_splits(self):
         bstdata = self.get_public_data('bst')
-        splits = self.node_get_member(bstdata, dict, 'split-rules')
+        splits = bstdata.get_mapping('split-rules')
         self.__splits = {
             domain: re.compile('^(?:' + '|'.join([utils._glob2re(r) for r in rules]) + ')$')
             for domain, rules in self.node_items(splits)
diff --git a/src/buildstream/plugins/elements/filter.py b/src/buildstream/plugins/elements/filter.py
index 45847e685..7fdb96d7a 100644
--- a/src/buildstream/plugins/elements/filter.py
+++ b/src/buildstream/plugins/elements/filter.py
@@ -217,7 +217,7 @@ class FilterElement(Element):
             for dep in self.dependencies(Scope.BUILD, recurse=False):
                 # Check that all the included/excluded domains exist
                 pub_data = dep.get_public_data('bst')
-                split_rules = self.node_get_member(pub_data, dict, 'split-rules', {})
+                split_rules = pub_data.get_mapping('split-rules', {})
                 unfound_includes = []
                 for domain in self.include:
                     if domain not in split_rules:
diff --git a/src/buildstream/plugins/elements/junction.py b/src/buildstream/plugins/elements/junction.py
index 4222de360..849df72be 100644
--- a/src/buildstream/plugins/elements/junction.py
+++ b/src/buildstream/plugins/elements/junction.py
@@ -176,7 +176,7 @@ class JunctionElement(Element):
 
     def configure(self, node):
         self.path = self.node_get_member(node, str, 'path', default='')
-        self.options = self.node_get_member(node, dict, 'options', default={})
+        self.options = node.get_mapping('options', default={})
         self.target = self.node_get_member(node, str, 'target', default=None)
         self.target_element = None
         self.target_junction = None
diff --git a/src/buildstream/sandbox/_sandboxremote.py b/src/buildstream/sandbox/_sandboxremote.py
index d90b164bc..75f2eb261 100644
--- a/src/buildstream/sandbox/_sandboxremote.py
+++ b/src/buildstream/sandbox/_sandboxremote.py
@@ -112,7 +112,7 @@ class SandboxRemote(Sandbox):
     def specs_from_config_node(config_node, basedir=None):
 
         def require_node(config, keyname):
-            val = _yaml.node_get(config, dict, keyname, default_value=None)
+            val = config.get_mapping(keyname, default=None)
             if val is None:
                 provenance = _yaml.node_get_provenance(remote_config, key=keyname)
                 raise _yaml.LoadError(_yaml.LoadErrorReason.INVALID_DATA,
@@ -121,7 +121,7 @@ class SandboxRemote(Sandbox):
                                       .format(str(provenance), keyname))
             return val
 
-        remote_config = _yaml.node_get(config_node, dict, 'remote-execution', default_value=None)
+        remote_config = config_node.get_mapping('remote-execution', default=None)
         if remote_config is None:
             return None
 
@@ -131,7 +131,7 @@ class SandboxRemote(Sandbox):
 
         exec_config = require_node(remote_config, 'execution-service')
         storage_config = require_node(remote_config, 'storage-service')
-        action_config = _yaml.node_get(remote_config, dict, 'action-cache-service', default_value={})
+        action_config = remote_config.get_mapping('action-cache-service', default={})
 
         tls_keys = ['client-key', 'client-cert', 'server-cert']
 
diff --git a/src/buildstream/source.py b/src/buildstream/source.py
index 9fc9cf17d..609836551 100644
--- a/src/buildstream/source.py
+++ b/src/buildstream/source.py
@@ -258,8 +258,7 @@ class Source(Plugin):
     All Sources derive from this class, this interface defines how
     the core will be interacting with Sources.
     """
-    __defaults = {}          # The defaults from the project
-    __defaults_set = False   # Flag, in case there are not defaults at all
+    __defaults = None        # The defaults from the project
 
     BST_REQUIRES_PREVIOUS_SOURCES_TRACK = False
     """Whether access to previous sources is required during track
@@ -1274,20 +1273,19 @@ class Source(Plugin):
 
     @classmethod
     def __init_defaults(cls, project, meta):
-        if not cls.__defaults_set:
+        if cls.__defaults is None:
             if meta.first_pass:
                 sources = project.first_pass_config.source_overrides
             else:
                 sources = project.source_overrides
-            cls.__defaults = _yaml.node_get(sources, dict, meta.kind, default_value={})
-            cls.__defaults_set = True
+            cls.__defaults = sources.get_mapping(meta.kind, default={})
 
     # This will resolve the final configuration to be handed
     # off to source.configure()
     #
     @classmethod
     def __extract_config(cls, meta):
-        config = _yaml.node_get(cls.__defaults, dict, 'config', default_value={})
+        config = cls.__defaults.get_mapping('config', default={})
         config = _yaml.node_copy(config)
 
         _yaml.composite(config, meta.config)
diff --git a/tests/elements/filter/basic/element_plugins/dynamic.py b/tests/elements/filter/basic/element_plugins/dynamic.py
index c6d128b72..b4a556244 100644
--- a/tests/elements/filter/basic/element_plugins/dynamic.py
+++ b/tests/elements/filter/basic/element_plugins/dynamic.py
@@ -5,7 +5,7 @@ from buildstream import Element, Scope
 class DynamicElement(Element):
     def configure(self, node):
         self.node_validate(node, ['split-rules'])
-        self.split_rules = self.node_get_member(node, dict, 'split-rules')
+        self.split_rules = node.get_mapping('split-rules')
 
     def preflight(self):
         pass
diff --git a/tests/format/include.py b/tests/format/include.py
index bfadce7ed..f2815ca31 100644
--- a/tests/format/include.py
+++ b/tests/format/include.py
@@ -213,7 +213,7 @@ def test_list_overide_does_not_fail_upon_first_composition(cli, datafiles):
     loaded = _yaml.load_data(result.output)
 
     # Assert that the explicitly overwritten public data is present
-    bst = _yaml.node_get(loaded, dict, 'bst')
+    bst = loaded.get_mapping('bst')
     assert 'foo-commands' in bst
     assert _yaml.node_get(bst, list, 'foo-commands') == ['need', 'this']
 
diff --git a/tests/frontend/project/sources/fetch_source.py b/tests/frontend/project/sources/fetch_source.py
index f17c14029..4c265f99b 100644
--- a/tests/frontend/project/sources/fetch_source.py
+++ b/tests/frontend/project/sources/fetch_source.py
@@ -42,7 +42,7 @@ class FetchSource(Source):
         self.output_file = self.node_get_member(node, str, 'output-text')
         self.fetch_succeeds = {}
         if 'fetch-succeeds' in node:
-            fetch_succeeds_node = self.node_get_member(node, dict, 'fetch-succeeds')
+            fetch_succeeds_node = node.get_mapping('fetch-succeeds')
             for key, value in self.node_items(fetch_succeeds_node):
                 self.fetch_succeeds[key] = value in ('True', 'true')
 
diff --git a/tests/internals/yaml.py b/tests/internals/yaml.py
index cd3bdc535..a553cbf0f 100644
--- a/tests/internals/yaml.py
+++ b/tests/internals/yaml.py
@@ -110,9 +110,9 @@ def test_node_get(datafiles):
     child = _yaml.node_get(base, dict, 'children', indices=[6])
     assert_provenance(filename, 20, 8, child, 'mood')
 
-    extra = _yaml.node_get(base, dict, 'extra')
+    extra = base.get_mapping('extra')
     with pytest.raises(LoadError) as exc:
-        _yaml.node_get(extra, dict, 'old')
+        extra.get_mapping('old')
 
     assert exc.value.reason == LoadErrorReason.INVALID_DATA
 
@@ -188,8 +188,8 @@ def test_composite_preserve_originals(datafiles):
     base_copy = _yaml.node_copy(base)
     _yaml.composite_dict(base_copy, overlay)
 
-    copy_extra = _yaml.node_get(base_copy, dict, 'extra')
-    orig_extra = _yaml.node_get(base, dict, 'extra')
+    copy_extra = base_copy.get_mapping('extra')
+    orig_extra = base.get_mapping('extra')
 
     # Test that the node copy has the overridden value...
     assert _yaml.node_get(copy_extra, str, 'old') == 'override'
diff --git a/tests/sources/previous_source_access.py b/tests/sources/previous_source_access.py
index 800e0ced5..50bfe383c 100644
--- a/tests/sources/previous_source_access.py
+++ b/tests/sources/previous_source_access.py
@@ -24,7 +24,7 @@ def test_custom_transform_source(cli, datafiles):
     # Set the project_dir alias in project.conf to the path to the tested project
     project_config_path = os.path.join(project, "project.conf")
     project_config = _yaml.load(project_config_path)
-    aliases = _yaml.node_get(project_config, dict, "aliases")
+    aliases = project_config.get_mapping("aliases")
     _yaml.node_set(aliases, "project_dir", "file://{}".format(project))
     _yaml.dump(project_config, project_config_path)