Enum MetricsError 

#[non_exhaustive]
pub enum MetricsError {
    EmptyRoot,
    LanguageDisabled(LANG),
    NonUtf8Path,
    ParseHasErrors,
}

Error returned by the library’s metric-computation entry points.

Stability

The variant set is additive: new variants may be introduced in minor versions, so the enum is marked #[non_exhaustive]. Existing variants will not be removed without a major version bump. The std::error::Error and std::fmt::Display impls are part of the stable surface; the exact wording of the Display output is not.

Examples

Most variants are reserved for features that have not yet landed (see each variant’s documentation for the issue tracking it). The exception is MetricsError::LanguageDisabled, which is produced by every dispatch entry point when the caller selects a LANG whose per-language Cargo feature is not enabled in the current build (see #252). The example exercises the happy path and demonstrates the exhaustive-with-_ match shape that callers should adopt to stay forward-compatible with future variants.

use big_code_analysis::{analyze, MetricsError, MetricsOptions, Source, LANG};

let source = Source::new(LANG::Cpp, b"int a = 42;");
let result = analyze(source, MetricsOptions::default());

// Today this call succeeds; the match below documents the shape
// callers must adopt so adding a future variant is non-breaking.
assert!(result.is_ok());

match result {
    Ok(_space) => {}
    Err(MetricsError::EmptyRoot) => {
        // Reserved: walker produced no top-level FuncSpace.
    }
    Err(MetricsError::ParseHasErrors) => {
        // Reserved: future strict-parsing toggle on `MetricsOptions`.
    }
    Err(MetricsError::LanguageDisabled(_lang)) => {
        // The `LANG` variant the caller asked for has no grammar
        // crate compiled in for this build (per-language feature
        // disabled — see the `[features]` table in Cargo.toml).
    }
    Err(MetricsError::NonUtf8Path) => {
        // Reserved: strict-identifier mode (see issue #254).
    }
    // `MetricsError` is `#[non_exhaustive]`; new variants may be added.
    Err(_) => {}
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

EmptyRoot

The walker produced no top-level FuncSpace.

Reserved — not produced today. metrics_with_options always pushes a synthetic top-level SpaceKind::Unit FuncSpace onto its state stack before walking the AST, so every parse — including empty input, whitespace-only input, and comment-only input — currently returns Ok(FuncSpace { kind: Unit, .. }). The variant is kept for a future walker change that lets the state stack legitimately drain to empty (e.g. an option that suppresses the synthetic root for sources with no parseable structure).

LanguageDisabled(LANG)

The requested LANG is not enabled in this build.

Produced by every dispatch entry point (crate::analyze, crate::metrics_from_tree, crate::action, crate::get_ops, the deprecated get_function_spaces* shims, and crate::LANG::get_tree_sitter_language) when the caller selects a LANG variant whose per-language Cargo feature is not enabled in the current build — see the [features] table in the root Cargo.toml for the list. The default feature set (default = ["all-languages"]) keeps every grammar compiled in, matching the library’s historical behaviour; callers that opt into a narrower set with --no-default-features --features rust,… are the only ones that observe this variant.

NonUtf8Path

The supplied path could not be losslessly converted to UTF-8.

Reserved for callers that opt into strict-identifier mode. As of #254, the recommended crate::analyze entry point accepts a crate::Source with an explicit Source::name: Option<String> so callers never need to round- trip a non-UTF-8 path through lossy conversion in the first place. The deprecated path-positional entry points (metrics, crate::get_function_spaces, …) still fall back to Path::to_string_lossy. This variant is not produced today; it is kept for future strict-identifier validators that reject lossy names up front.

ParseHasErrors

The tree-sitter parse tree contains syntax errors and the caller opted into strict mode.

Reserved for a future strict-parsing toggle on MetricsOptions; the current entry points still tolerate ERROR nodes and compute best-effort metrics, so this variant is not produced today.

Trait Implementations

impl Clone for MetricsError

fn clone(&self) -> MetricsError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MetricsError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for MetricsError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for MetricsError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for MetricsError

fn eq(&self, other: &MetricsError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for MetricsError

impl Eq for MetricsError

impl StructuralPartialEq for MetricsError