How does helix merge toml config?

[eli-yip]

I found the following merge functions in codebase: https://github.com/helix-editor/helix/blob/master/helix-loader/src/lib.rs#L187

/// Merge two TOML documents, merging values from `right` onto `left`
///
/// `merge_depth` sets the nesting depth up to which values are merged instead
/// of overridden.
///
/// When a table exists in both `left` and `right`, the merged table consists of
/// all keys in `left`'s table unioned with all keys in `right` with the values
/// of `right` being merged recursively onto values of `left`.
///
/// `crate::merge_toml_values(a, b, 3)` combines, for example:
///
/// b:
/// ```toml
/// [[language]]
/// name = "toml"
/// language-server = { command = "taplo", args = ["lsp", "stdio"] }
/// ```
/// a:
/// ```toml
/// [[language]]
/// language-server = { command = "/usr/bin/taplo" }
/// ```
///
/// into:
/// ```toml
/// [[language]]
/// name = "toml"
/// language-server = { command = "/usr/bin/taplo" }
/// ```
///
/// thus it overrides the third depth-level of b with values of a if they exist,
/// but otherwise merges their values
pub fn merge_toml_values(left: toml::Value, right: toml::Value, merge_depth: usize) -> toml::Value {
    use toml::Value;

    fn get_name(v: &Value) -> Option<&str> {
        v.get("name").and_then(Value::as_str)
    }

    match (left, right) {
        (Value::Array(mut left_items), Value::Array(right_items)) => {
            if merge_depth > 0 {
                left_items.reserve(right_items.len());
                for rvalue in right_items {
                    let lvalue = get_name(&rvalue)
                        .and_then(|rname| {
                            left_items.iter().position(|v| get_name(v) == Some(rname))
                        })
                        .map(|lpos| left_items.remove(lpos));
                    let mvalue = match lvalue {
                        Some(lvalue) => merge_toml_values(lvalue, rvalue, merge_depth - 1),
                        None => rvalue,
                    };
                    left_items.push(mvalue);
                }
                Value::Array(left_items)
            } else {
                Value::Array(right_items)
            }
        }
        (Value::Table(mut left_map), Value::Table(right_map)) => {
            if merge_depth > 0 {
                for (rname, rvalue) in right_map {
                    match left_map.remove(&rname) {
                        Some(lvalue) => {
                            let merged_value = merge_toml_values(lvalue, rvalue, merge_depth - 1);
                            left_map.insert(rname, merged_value);
                        }
                        None => {
                            left_map.insert(rname, rvalue);
                        }
                    }
                }
                Value::Table(left_map)
            } else {
                Value::Table(right_map)
            }
        }
        // Catch everything else we didn't handle, and use the right value
        (_, value) => value,
    }
}

I have the following questions:

1. Why the example result is that? I have tested with a program like this:

use clap::Parser;
use helix_loader::merge_toml_values;
use std::fs;
use std::path::PathBuf;
use toml::Value;

#[derive(Parser)]
#[clap(name = "toml-merge", about = "merge 2 toml file")]
struct Args {
    #[clap(value_parser)]
    left: PathBuf,

    #[clap(value_parser)]
    right: PathBuf,

    #[clap(short, long, default_value = "3")]
    depth: usize,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = Args::parse();

    let left_content = fs::read_to_string(&args.left)?;
    let left_value: Value = toml::from_str(&left_content)?;

    let right_content = fs::read_to_string(&args.right)?;
    let right_value: Value = toml::from_str(&right_content)?;

    let merged = merge_toml_values(left_value, right_value, args.depth);

    let output = toml::to_string_pretty(&merged)?;
    println!("{}", output);

    Ok(())
}

Then I used the same a.toml and b.toml as args, got this result:

[[language]]

[language.language-server]
command = "/usr/bin/taplo"

[[language]]
name = "toml"

[language.language-server]
args = [
    "lsp",
    "stdio",
]
command = "taplo"

Does the function doc have a mistake?

And one more question, how does key remapping works. For the following config.toml:

[keys.normal.space]
f = "select_line_above"

As space depth is 3, then it should override the default keybindings. But when I use this config, default d &c still works.