miniextendr_macros/

crate_config.rs

//! Crate-level `#[miniextendr]` defaults read from the user crate's manifest.
//!
//! Proc-macro invocations share no state, so a default meant for every
//! `#[miniextendr]` item in a crate cannot be declared on one macro call:
//! `miniextendr_init!` expands with no knowledge of the functions and vice
//! versa. The one place every expansion can see is the manifest. Cargo sets
//! `CARGO_MANIFEST_DIR` for the crate being compiled and the proc macro runs
//! inside that `rustc` process, so it can read `Cargo.toml` at expansion time.
//! Cargo refingerprints a package when its manifest changes, so an edit takes
//! effect on the next build with no stale expansions.
//!
//! Supported spelling (the table header; dotted keys under `[package]` or
//! `[package.metadata]` are accepted too, inline tables are rejected):
//!
//! ```toml
//! [package.metadata.miniextendr]
//! noexport_postfix = "_impl"
//! source_tags = true
//! call_attribution = "caller"
//! conversion_error_class = ["pkg_error_argument", "pkg_error"]
//! preconditions = false
//! roxygen_prose_links = "keep"
//! ```
//!
//! The reader is a deliberately small line-based scanner rather than a TOML
//! dependency: the macro crate ships in every downstream build, and the only
//! values it needs are strings, booleans and a single-line string array
//! under one well-known table.

use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::{Mutex, OnceLock};

use crate::r_wrapper_builder::CallAttribution;
use crate::roxygen::ProseLinks;

/// Dotted path of the `noexport_postfix` key.
const NOEXPORT_POSTFIX_KEY: &str = "package.metadata.miniextendr.noexport_postfix";
/// Dotted path of the `source_tags` key.
const SOURCE_TAGS_KEY: &str = "package.metadata.miniextendr.source_tags";
/// Dotted path of the `call_attribution` key.
const CALL_ATTRIBUTION_KEY: &str = "package.metadata.miniextendr.call_attribution";
/// Dotted path of the `conversion_error_class` key.
const CONVERSION_ERROR_CLASS_KEY: &str = "package.metadata.miniextendr.conversion_error_class";
/// Dotted path of the `preconditions` key.
const PRECONDITIONS_KEY: &str = "package.metadata.miniextendr.preconditions";
/// Dotted path of the `roxygen_prose_links` key.
const ROXYGEN_PROSE_LINKS_KEY: &str = "package.metadata.miniextendr.roxygen_prose_links";
/// The classes the R raise helper appends to every Rust error. A crate-level
/// class naming one of them would duplicate a layer of the vector.
const FRAMEWORK_ERROR_CLASSES: [&str; 4] = ["rust_error", "simpleError", "error", "condition"];
/// Dotted path of the table itself, used to reject the inline-table spelling.
const TABLE_KEY: &str = "package.metadata.miniextendr";

/// Crate-wide defaults declared under `[package.metadata.miniextendr]`.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct CrateConfig {
    /// `noexport_postfix = "..."`: appended to the Rust name of every
    /// `noexport` / `internal` free function that sets neither `r_name` nor
    /// its own `postfix`. Exported functions keep their Rust names.
    pub(crate) noexport_postfix: Option<String>,
    /// `source_tags = true`: every generated roxygen block carries a
    /// `@source Generated by miniextendr from …` provenance tag. Off by
    /// default (#1552): the tag collects one paragraph per function on a
    /// shared Rd page, and the `# Generated from Rust fn … (file:line:col)`
    /// comment above each wrapper remains the navigation pointer.
    pub(crate) source_tags: bool,
    /// `call_attribution = "wrapper" | "caller" | "none"`: the condition-call
    /// attribution of every free function that neither takes a `Call` /
    /// `CallerCall` parameter nor sets `call = ...` (#1566). `caller` applies
    /// to `noexport` / `internal` functions; exported ones keep `wrapper`.
    /// `none` (#1851) applies to every free function: its conditions carry
    /// no call. Unset means the framework default, `wrapper`.
    pub(crate) call_attribution: Option<CallAttribution>,
    /// `conversion_error_class = "..." | ["...", ...]`: classes added to every
    /// argument-conversion condition of the crate, after the error type's own
    /// `RConditionData` classes (duplicates skipped) and before the
    /// `rust_error` layering. Empty when unset.
    pub(crate) conversion_error_class: Vec<String>,
    /// `preconditions = true | false`: whether the generated R wrappers of
    /// the crate keep their type-derived argument checks (#1566). Below every
    /// item-level and per-parameter spelling, above the
    /// `no-preconditions-default` feature (see
    /// `crate::r_preconditions::resolve_type_checks`). Unset means the feature
    /// decides, and without it the checks are kept.
    pub(crate) preconditions: Option<bool>,
    /// `roxygen_prose_links = "strip" | "keep"`: whether the leading prose of
    /// a doc comment keeps its `[...]` links on its way to `@description`
    /// (see [`ProseLinks`]). Unset means the framework default, `strip`.
    pub(crate) roxygen_prose_links: Option<ProseLinks>,
}

/// A malformed `[package.metadata.miniextendr]` entry, reported as a compile
/// error on the `#[miniextendr]` item that tried to use it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct CrateConfigError {
    manifest: PathBuf,
    message: String,
}

impl std::fmt::Display for CrateConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}: [package.metadata.miniextendr] {}",
            self.manifest.display(),
            self.message
        )
    }
}

/// The crate config for the crate currently being compiled.
///
/// Returns the defaults when `CARGO_MANIFEST_DIR` is unset or its `Cargo.toml`
/// cannot be read; only a present-but-malformed entry is an error. Results are
/// cached per manifest directory, so a single proc-macro server process serving
/// several crates (rust-analyzer) never leaks one crate's default into another.
pub(crate) fn crate_config() -> Result<CrateConfig, CrateConfigError> {
    let Some(dir) = std::env::var_os("CARGO_MANIFEST_DIR") else {
        return Ok(CrateConfig::default());
    };
    crate_config_for_dir(Path::new(&dir))
}

/// Whether generated roxygen blocks carry `@source` provenance tags.
///
/// Read by the impl-block and derive generators, which have no single item to
/// hang a manifest error on; a malformed table reads as the default here and
/// is reported as a compile error by the first `#[miniextendr]` function,
/// which goes through [`crate_config`].
pub(crate) fn source_tags_enabled() -> bool {
    crate_config().map(|c| c.source_tags).unwrap_or(false)
}

/// The crate-level classes of argument-conversion conditions
/// (`conversion_error_class`), empty when unset.
///
/// Read by the argument-conversion codegen, which runs for free functions,
/// impl methods, trait methods and sidecar setters alike; a malformed table
/// reads as the default here and is reported as a compile error by the first
/// `#[miniextendr]` function, which goes through [`crate_config`].
pub(crate) fn conversion_error_class() -> Vec<String> {
    crate_config()
        .map(|c| c.conversion_error_class)
        .unwrap_or_default()
}

/// The crate default of the type-derived R-side checks (`preconditions`),
/// `None` when unset.
///
/// Read by the impl-block and trait-impl generators, which have no single
/// item to hang a manifest error on; a malformed table reads as unset here and
/// is reported as a compile error by the first `#[miniextendr]` function,
/// which goes through [`crate_config`].
pub(crate) fn preconditions_default() -> Option<bool> {
    crate_config().ok().and_then(|c| c.preconditions)
}

/// What leading doc-comment prose does with its `[...]` links
/// (`roxygen_prose_links`), [`ProseLinks::Strip`] when unset.
///
/// Read by the roxygen extraction every generator shares, which has no single
/// item to hang a manifest error on; a malformed table reads as the default
/// here and is reported as a compile error by the first `#[miniextendr]`
/// function, which goes through [`crate_config`].
pub(crate) fn roxygen_prose_links() -> ProseLinks {
    crate_config()
        .ok()
        .and_then(|c| c.roxygen_prose_links)
        .unwrap_or_default()
}

/// [`crate_config`] for an explicit manifest directory (the cached entry point).
pub(crate) fn crate_config_for_dir(dir: &Path) -> Result<CrateConfig, CrateConfigError> {
    static CACHE: OnceLock<Mutex<HashMap<PathBuf, Result<CrateConfig, CrateConfigError>>>> =
        OnceLock::new();
    let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
    let mut cache = cache
        .lock()
        .unwrap_or_else(|poisoned| poisoned.into_inner());
    cache
        .entry(dir.to_path_buf())
        .or_insert_with(|| read_crate_config(&dir.join("Cargo.toml")))
        .clone()
}

/// Read and parse one manifest. Missing or unreadable files yield the defaults.
fn read_crate_config(manifest: &Path) -> Result<CrateConfig, CrateConfigError> {
    match std::fs::read_to_string(manifest) {
        Ok(text) => parse_crate_config(&text).map_err(|message| CrateConfigError {
            manifest: manifest.to_path_buf(),
            message,
        }),
        Err(_) => Ok(CrateConfig::default()),
    }
}

/// Parse the `[package.metadata.miniextendr]` table out of manifest text.
///
/// Tracks the current table header and resolves every `key = value` line to a
/// dotted path, so the header form, `miniextendr.noexport_postfix = "..."`
/// under `[package.metadata]`, and `metadata.miniextendr.noexport_postfix`
/// under `[package]` all resolve to the same key. Everything else in the
/// manifest is skipped without interpretation.
pub(crate) fn parse_crate_config(text: &str) -> Result<CrateConfig, String> {
    let mut config = CrateConfig::default();
    let mut source_tags_seen = false;
    let mut conversion_error_class_seen = false;
    let mut table = String::new();

    for raw_line in text.lines() {
        let line = raw_line.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        if let Some(header) = line.strip_prefix('[') {
            // `[[array.of.tables]]` and `[table]`: keys below belong to it.
            let header = header.strip_prefix('[').unwrap_or(header);
            let end = header
                .find(']')
                .ok_or_else(|| format!("unterminated table header `{line}`"))?;
            table = normalize_key(&header[..end]);
            continue;
        }
        let Some((key, value)) = line.split_once('=') else {
            continue;
        };
        let key = normalize_key(key);
        let full = if table.is_empty() {
            key
        } else {
            format!("{table}.{key}")
        };
        if full == TABLE_KEY && value.trim_start().starts_with('{') {
            return Err(
                "inline tables are not supported here; write a `[package.metadata.miniextendr]` \
                 table with each key on its own line"
                    .to_string(),
            );
        }
        if full == CALL_ATTRIBUTION_KEY {
            if config.call_attribution.is_some() {
                return Err("`call_attribution` is set more than once".to_string());
            }
            let value = value.trim();
            let attribution = parse_string_value(value)
                .as_deref()
                .and_then(CallAttribution::parse_name)
                .ok_or_else(|| {
                    format!(
                        "`call_attribution` must be one of \"wrapper\", \"caller\", \"none\", found \
                         `{value}`"
                    )
                })?;
            config.call_attribution = Some(attribution);
            continue;
        }
        if full == CONVERSION_ERROR_CLASS_KEY {
            if conversion_error_class_seen {
                return Err("`conversion_error_class` is set more than once".to_string());
            }
            let value = value.trim();
            let classes = parse_string_value(value)
                .map(|class| vec![class])
                .or_else(|| parse_string_array_value(value))
                .ok_or_else(|| {
                    format!(
                        "`conversion_error_class` must be a string or a single-line array of \
                         strings, found `{value}`"
                    )
                })?;
            validate_conversion_error_class(&classes)?;
            config.conversion_error_class = classes;
            conversion_error_class_seen = true;
            continue;
        }
        if full == ROXYGEN_PROSE_LINKS_KEY {
            if config.roxygen_prose_links.is_some() {
                return Err("`roxygen_prose_links` is set more than once".to_string());
            }
            let value = value.trim();
            let links = parse_string_value(value)
                .as_deref()
                .and_then(ProseLinks::parse_name)
                .ok_or_else(|| {
                    format!(
                        "`roxygen_prose_links` must be one of \"strip\", \"keep\", found \
                         `{value}`"
                    )
                })?;
            config.roxygen_prose_links = Some(links);
            continue;
        }
        if full == PRECONDITIONS_KEY {
            if config.preconditions.is_some() {
                return Err("`preconditions` is set more than once".to_string());
            }
            config.preconditions = Some(parse_bool_value(value.trim()).ok_or_else(|| {
                format!(
                    "`preconditions` must be `true` or `false`, found `{}`",
                    value.trim()
                )
            })?);
            continue;
        }
        if full == SOURCE_TAGS_KEY {
            if source_tags_seen {
                return Err("`source_tags` is set more than once".to_string());
            }
            config.source_tags = parse_bool_value(value.trim()).ok_or_else(|| {
                format!(
                    "`source_tags` must be `true` or `false`, found `{}`",
                    value.trim()
                )
            })?;
            source_tags_seen = true;
            continue;
        }
        if full != NOEXPORT_POSTFIX_KEY {
            continue;
        }
        if config.noexport_postfix.is_some() {
            return Err("`noexport_postfix` is set more than once".to_string());
        }
        let value = parse_string_value(value.trim()).ok_or_else(|| {
            format!(
                "`noexport_postfix` must be a string, found `{}`",
                value.trim()
            )
        })?;
        validate_noexport_postfix(&value)?;
        config.noexport_postfix = Some(value);
    }

    Ok(config)
}

/// Collapse a dotted key or table header to `a.b.c`: trims each segment and
/// strips one layer of quotes so `[ "package" . metadata ]` compares equal to
/// `[package.metadata]`.
fn normalize_key(key: &str) -> String {
    key.split('.')
        .map(|segment| {
            let segment = segment.trim();
            segment
                .strip_prefix('"')
                .and_then(|s| s.strip_suffix('"'))
                .or_else(|| {
                    segment
                        .strip_prefix('\'')
                        .and_then(|s| s.strip_suffix('\''))
                })
                .unwrap_or(segment)
        })
        .collect::<Vec<_>>()
        .join(".")
}

/// Parse a single-line TOML basic (`"..."`) or literal (`'...'`) string.
///
/// Escape sequences are not accepted: the value must be an R identifier
/// fragment, which never needs one. Multi-line strings and non-string values
/// return `None`.
fn parse_string_value(value: &str) -> Option<String> {
    let (quote, rest) = match value.chars().next()? {
        c @ ('"' | '\'') => (c, &value[1..]),
        _ => return None,
    };
    if rest.starts_with(quote) && rest[1..].starts_with(quote) {
        // `"""` / `'''`: multi-line strings are not supported.
        return None;
    }
    let end = rest.find(quote)?;
    let body = &rest[..end];
    if body.contains('\\') {
        return None;
    }
    let trailing = rest[end + 1..].trim_start();
    if !(trailing.is_empty() || trailing.starts_with('#')) {
        return None;
    }
    Some(body.to_string())
}

/// Parse a single-line TOML array of strings (`["a", 'b']`, a trailing comma
/// and a trailing `# comment` allowed), each element under the
/// [`parse_string_value`] rules. Multi-line arrays and non-string elements
/// return `None`.
fn parse_string_array_value(value: &str) -> Option<Vec<String>> {
    let mut rest = value.strip_prefix('[')?.trim_start();
    let mut items = Vec::new();
    loop {
        if let Some(after) = rest.strip_prefix(']') {
            let trailing = after.trim_start();
            return (trailing.is_empty() || trailing.starts_with('#')).then_some(items);
        }
        let quote = rest.chars().next().filter(|c| matches!(c, '"' | '\''))?;
        let body_and_rest = &rest[1..];
        let end = body_and_rest.find(quote)?;
        let body = &body_and_rest[..end];
        if body.contains('\\') {
            return None;
        }
        items.push(body.to_string());
        rest = body_and_rest[end + 1..].trim_start();
        if let Some(after) = rest.strip_prefix(',') {
            rest = after.trim_start();
        } else if !rest.starts_with(']') {
            return None;
        }
    }
}

/// Parse a TOML boolean, allowing a trailing `# comment`.
fn parse_bool_value(value: &str) -> Option<bool> {
    let (literal, rest) = match value.split_once(char::is_whitespace) {
        Some((literal, rest)) => (literal, rest.trim_start()),
        None => (value, ""),
    };
    if !(rest.is_empty() || rest.starts_with('#')) {
        return None;
    }
    match literal {
        "true" => Some(true),
        "false" => Some(false),
        _ => None,
    }
}

/// `conversion_error_class` must name at least one class, each non-empty,
/// distinct, and not one of the framework's own layers (`rust_error`,
/// `simpleError`, `error`, `condition`), which are always appended.
fn validate_conversion_error_class(classes: &[String]) -> Result<(), String> {
    if classes.is_empty() {
        return Err("`conversion_error_class` must name at least one class".to_string());
    }
    for (i, class) in classes.iter().enumerate() {
        if class.trim().is_empty() {
            return Err("`conversion_error_class` entries must not be empty".to_string());
        }
        if FRAMEWORK_ERROR_CLASSES.contains(&class.as_str()) {
            return Err(format!(
                "`conversion_error_class` must not name `{class}`: every conversion error already \
                 carries `rust_error`, `simpleError`, `error` and `condition`"
            ));
        }
        if classes[..i].contains(class) {
            return Err(format!(
                "`conversion_error_class` names `{class}` more than once"
            ));
        }
    }
    Ok(())
}

/// Mirror of `miniextendr_fn::validate_postfix` for the manifest value.
fn validate_noexport_postfix(value: &str) -> Result<(), String> {
    if value.is_empty() {
        return Err("`noexport_postfix` must not be empty".to_string());
    }
    if !value
        .chars()
        .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '.')
    {
        return Err(
            "`noexport_postfix` must be a valid R identifier fragment (letters, digits, `_`, `.`)"
                .to_string(),
        );
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    fn postfix(text: &str) -> Result<Option<String>, String> {
        parse_crate_config(text).map(|c| c.noexport_postfix)
    }

    #[test]
    fn header_form_is_read() {
        let text = r#"
[package]
name = "demo"

[package.metadata.miniextendr]
noexport_postfix = "_impl" # trailing comment

[dependencies]
miniextendr-api = "0.1"
"#;
        assert_eq!(postfix(text), Ok(Some("_impl".to_string())));
    }

    #[test]
    fn dotted_forms_are_read() {
        let under_metadata = "[package.metadata]\nminiextendr.noexport_postfix = '_impl'\n";
        assert_eq!(postfix(under_metadata), Ok(Some("_impl".to_string())));

        let under_package = "[package]\nmetadata.miniextendr.noexport_postfix = \"_rs\"\n";
        assert_eq!(postfix(under_package), Ok(Some("_rs".to_string())));

        let quoted_header =
            "[ \"package\" . metadata . 'miniextendr' ]\nnoexport_postfix = \"_impl\"\n";
        assert_eq!(postfix(quoted_header), Ok(Some("_impl".to_string())));
    }

    #[test]
    fn unrelated_tables_and_keys_are_ignored() {
        let text = r#"
[package.metadata.docs.rs]
noexport_postfix = "not-ours"

[package.metadata.miniextendr]
other_key = "ignored"

[[bin]]
name = "x"
noexport_postfix = "also not ours"
"#;
        assert_eq!(postfix(text), Ok(None));
        assert_eq!(postfix(""), Ok(None));
        assert_eq!(postfix("[package]\nname = \"demo\"\n"), Ok(None));
    }

    #[test]
    fn source_tags_is_read_and_defaults_off() {
        let source_tags = |text: &str| parse_crate_config(text).map(|c| c.source_tags);
        assert_eq!(source_tags(""), Ok(false));
        assert_eq!(
            source_tags("[package.metadata.miniextendr]\nsource_tags = true # provenance\n"),
            Ok(true)
        );
        assert_eq!(
            source_tags("[package.metadata]\nminiextendr.source_tags = false\n"),
            Ok(false)
        );
        // Both keys in one table.
        let both =
            "[package.metadata.miniextendr]\nnoexport_postfix = \"_impl\"\nsource_tags = true\n";
        let config = parse_crate_config(both).unwrap();
        assert_eq!(config.noexport_postfix.as_deref(), Some("_impl"));
        assert!(config.source_tags);
        assert!(
            source_tags("[package.metadata.miniextendr]\nsource_tags = \"yes\"\n")
                .unwrap_err()
                .contains("must be `true` or `false`")
        );
        assert!(
            source_tags("[package.metadata.miniextendr]\nsource_tags = true\nsource_tags = true\n")
                .unwrap_err()
                .contains("more than once")
        );
    }

    #[test]
    fn preconditions_is_read_and_defaults_unset() {
        let preconditions = |text: &str| parse_crate_config(text).map(|c| c.preconditions);
        assert_eq!(preconditions(""), Ok(None));
        assert_eq!(
            preconditions("[package.metadata.miniextendr]\npreconditions = false # hot paths\n"),
            Ok(Some(false))
        );
        assert_eq!(
            preconditions("[package.metadata]\nminiextendr.preconditions = true\n"),
            Ok(Some(true))
        );
        assert!(
            preconditions("[package.metadata.miniextendr]\npreconditions = \"no\"\n")
                .unwrap_err()
                .contains("`preconditions` must be `true` or `false`, found `\"no\"`")
        );
        assert!(
            preconditions(
                "[package.metadata.miniextendr]\npreconditions = false\npreconditions = true\n"
            )
            .unwrap_err()
            .contains("`preconditions` is set more than once")
        );
        // Next to the other keys.
        let all = "[package.metadata.miniextendr]\nsource_tags = true\npreconditions = false\ncall_attribution = \"caller\"\n";
        let config = parse_crate_config(all).unwrap();
        assert_eq!(config.preconditions, Some(false));
        assert!(config.source_tags);
    }

    #[test]
    fn roxygen_prose_links_is_read_and_validated() {
        let links = |text: &str| parse_crate_config(text).map(|c| c.roxygen_prose_links);
        assert_eq!(links(""), Ok(None));
        assert_eq!(
            links(
                "[package.metadata.miniextendr]\nroxygen_prose_links = \"keep\" # R-first docs\n"
            ),
            Ok(Some(ProseLinks::Keep))
        );
        assert_eq!(
            links("[package.metadata]\nminiextendr.roxygen_prose_links = 'strip'\n"),
            Ok(Some(ProseLinks::Strip))
        );
        assert_eq!(
            links("[package]\nmetadata.miniextendr.roxygen_prose_links = \"keep\"\n"),
            Ok(Some(ProseLinks::Keep))
        );
        for value in ["\"preserve\"", "true", "keep"] {
            let bad = links(&format!(
                "[package.metadata.miniextendr]\nroxygen_prose_links = {value}\n"
            ))
            .unwrap_err();
            assert!(
                bad.contains("`roxygen_prose_links` must be one of \"strip\", \"keep\"")
                    && bad.contains(&format!("found `{value}`")),
                "{bad}"
            );
        }
        let twice = links(
            "[package.metadata.miniextendr]\nroxygen_prose_links = \"keep\"\nroxygen_prose_links = \"strip\"\n",
        )
        .unwrap_err();
        assert!(
            twice.contains("`roxygen_prose_links` is set more than once"),
            "{twice}"
        );
        // Alongside the other keys.
        let all = "[package.metadata.miniextendr]\nnoexport_postfix = \"_impl\"\nroxygen_prose_links = \"keep\"\nsource_tags = true\n";
        let config = parse_crate_config(all).unwrap();
        assert_eq!(config.noexport_postfix.as_deref(), Some("_impl"));
        assert_eq!(config.roxygen_prose_links, Some(ProseLinks::Keep));
        assert!(config.source_tags);
    }

    #[test]
    fn call_attribution_is_read_and_validated() {
        let attribution = |text: &str| parse_crate_config(text).map(|c| c.call_attribution);
        assert_eq!(attribution(""), Ok(None));
        assert_eq!(
            attribution(
                "[package.metadata.miniextendr]\ncall_attribution = \"caller\" # internal entry points\n"
            ),
            Ok(Some(CallAttribution::Caller))
        );
        assert_eq!(
            attribution("[package.metadata]\nminiextendr.call_attribution = 'wrapper'\n"),
            Ok(Some(CallAttribution::Wrapper))
        );
        assert_eq!(
            attribution("[package]\nmetadata.miniextendr.call_attribution = \"wrapper\"\n"),
            Ok(Some(CallAttribution::Wrapper))
        );
        assert_eq!(
            attribution("[package.metadata.miniextendr]\ncall_attribution = 'none'\n"),
            Ok(Some(CallAttribution::NoCall))
        );
        for value in ["\"parent\"", "'self'"] {
            let bad = attribution(&format!(
                "[package.metadata.miniextendr]\ncall_attribution = {value}\n"
            ))
            .unwrap_err();
            assert!(
                bad.contains("must be one of \"wrapper\", \"caller\", \"none\"")
                    && bad.contains(&format!("`{value}`")),
                "{bad}"
            );
        }
        let bare =
            attribution("[package.metadata.miniextendr]\ncall_attribution = caller\n").unwrap_err();
        assert!(bare.contains("must be one of"), "{bare}");
        let twice = attribution(
            "[package.metadata.miniextendr]\ncall_attribution = \"wrapper\"\ncall_attribution = \"caller\"\n",
        )
        .unwrap_err();
        assert!(twice.contains("more than once"), "{twice}");
        // Alongside the other keys.
        let all = "[package.metadata.miniextendr]\nnoexport_postfix = \"_impl\"\nsource_tags = true\ncall_attribution = \"caller\"\n";
        let config = parse_crate_config(all).unwrap();
        assert_eq!(config.noexport_postfix.as_deref(), Some("_impl"));
        assert!(config.source_tags);
        assert_eq!(config.call_attribution, Some(CallAttribution::Caller));
    }

    #[test]
    fn conversion_error_class_is_read_and_validated() {
        let classes = |text: &str| parse_crate_config(text).map(|c| c.conversion_error_class);
        let owned = |v: &[&str]| v.iter().map(|s| s.to_string()).collect::<Vec<_>>();
        assert_eq!(classes(""), Ok(Vec::new()));
        // A single string and the array spellings.
        assert_eq!(
            classes("[package.metadata.miniextendr]\nconversion_error_class = \"pkg_error\"\n"),
            Ok(owned(&["pkg_error"]))
        );
        assert_eq!(
            classes(
                "[package.metadata.miniextendr]\nconversion_error_class = [\"pkg_error_argument\", 'pkg_error'] # family last\n"
            ),
            Ok(owned(&["pkg_error_argument", "pkg_error"]))
        );
        assert_eq!(
            classes(
                "[package.metadata]\nminiextendr.conversion_error_class = [ \"a\" , \"b\" , ]\n"
            ),
            Ok(owned(&["a", "b"]))
        );
        assert_eq!(
            classes("[package]\nmetadata.miniextendr.conversion_error_class = ['pkg.error']\n"),
            Ok(owned(&["pkg.error"]))
        );

        let err = |text: &str| classes(text).unwrap_err();
        let table = "[package.metadata.miniextendr]\n";
        for bad in [
            "conversion_error_class = pkg_error\n",
            "conversion_error_class = 1\n",
            "conversion_error_class = [\"a\", 1]\n",
            "conversion_error_class = [\"a\" \"b\"]\n",
            "conversion_error_class = [\"a\"] trailing\n",
            "conversion_error_class = [\"a\\tb\"]\n",
            "conversion_error_class = [\n",
        ] {
            let msg = err(&format!("{table}{bad}"));
            assert!(msg.contains("single-line array of strings"), "{bad}: {msg}");
        }
        assert!(err(&format!("{table}conversion_error_class = []\n")).contains("at least one"));
        assert!(err(&format!("{table}conversion_error_class = [\"\"]\n")).contains("not be empty"));
        let layered = err(&format!(
            "{table}conversion_error_class = [\"pkg_error\", \"rust_error\"]\n"
        ));
        assert!(layered.contains("must not name `rust_error`"), "{layered}");
        let dup = err(&format!("{table}conversion_error_class = [\"a\", \"a\"]\n"));
        assert!(dup.contains("more than once"), "{dup}");
        let twice = err(&format!(
            "{table}conversion_error_class = \"a\"\nconversion_error_class = \"b\"\n"
        ));
        assert!(twice.contains("is set more than once"), "{twice}");

        // Alongside the other keys.
        let all = "[package.metadata.miniextendr]\nnoexport_postfix = \"_impl\"\nconversion_error_class = [\"pkg_error_argument\", \"pkg_error\"]\ncall_attribution = \"caller\"\n";
        let config = parse_crate_config(all).unwrap();
        assert_eq!(config.noexport_postfix.as_deref(), Some("_impl"));
        assert_eq!(config.call_attribution, Some(CallAttribution::Caller));
        assert_eq!(
            config.conversion_error_class,
            owned(&["pkg_error_argument", "pkg_error"])
        );
    }

    #[test]
    fn malformed_values_are_errors() {
        let empty = "[package.metadata.miniextendr]\nnoexport_postfix = \"\"\n";
        assert!(postfix(empty).unwrap_err().contains("must not be empty"));

        let bad_chars = "[package.metadata.miniextendr]\nnoexport_postfix = \"-impl\"\n";
        assert!(
            postfix(bad_chars)
                .unwrap_err()
                .contains("identifier fragment")
        );

        let not_a_string = "[package.metadata.miniextendr]\nnoexport_postfix = 1\n";
        assert!(
            postfix(not_a_string)
                .unwrap_err()
                .contains("must be a string")
        );

        let escaped = "[package.metadata.miniextendr]\nnoexport_postfix = \"a\\tb\"\n";
        assert!(postfix(escaped).unwrap_err().contains("must be a string"));

        let multiline = "[package.metadata.miniextendr]\nnoexport_postfix = \"\"\"_impl\"\"\"\n";
        assert!(postfix(multiline).unwrap_err().contains("must be a string"));

        let twice = "[package.metadata.miniextendr]\nnoexport_postfix = \"_a\"\nnoexport_postfix = \"_b\"\n";
        assert!(postfix(twice).unwrap_err().contains("more than once"));

        let inline = "[package.metadata]\nminiextendr = { noexport_postfix = \"_impl\" }\n";
        assert!(postfix(inline).unwrap_err().contains("inline tables"));
    }

    #[test]
    fn manifest_dir_lookup_reads_and_caches() {
        let dir = std::env::temp_dir().join(format!(
            "miniextendr-crate-config-{}-{}",
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .map(|d| d.as_nanos())
                .unwrap_or_default()
        ));
        std::fs::create_dir_all(&dir).unwrap();
        std::fs::write(
            dir.join("Cargo.toml"),
            "[package]\nname = \"demo\"\n\n[package.metadata.miniextendr]\nnoexport_postfix = \"_impl\"\n",
        )
        .unwrap();

        let first = crate_config_for_dir(&dir).unwrap();
        assert_eq!(first.noexport_postfix.as_deref(), Some("_impl"));

        // The cache answers subsequent lookups; a later edit is not observed
        // within one process (Cargo starts a new rustc per manifest change).
        std::fs::write(dir.join("Cargo.toml"), "[package]\nname = \"demo\"\n").unwrap();
        let second = crate_config_for_dir(&dir).unwrap();
        assert_eq!(second, first);

        let missing = crate_config_for_dir(&dir.join("does-not-exist")).unwrap();
        assert_eq!(missing, CrateConfig::default());

        let _ = std::fs::remove_dir_all(&dir);
    }
}