Overriding default ValueEnum::from_str implementation

[oddg]

Hello,

I wrote an override for the ValueEnum::from_str method. However this does not seem to change the behavior of the arguments parser. So I have two questions:

1. What's the expected impact of overriding that method?
2. How can I provide a custom parser for a type implementing ValueEnum? (I tried the value_parser annotation with no success.)

Below is a simple version of my attempt.

use clap::{builder::PossibleValue, Parser, ValueEnum};

#[derive(Parser)]
struct Cli {
    #[arg(long, value_enum)]
    foo: MyEnum,
}

#[derive(Clone, Debug, PartialEq, Eq)]
enum MyEnum {
    A,
    B(usize),
}

impl ValueEnum for MyEnum {
    fn value_variants<'a>() -> &'a [Self] {
        &[Self::A, Self::B(0)]
    }

    fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
        Some(match self {
            Self::A => PossibleValue::new("a"),
            Self::B(_) => PossibleValue::new("b-42"),
        })
    }

    fn from_str(input: &str, _ignore_case: bool) -> Result<Self, String> {
        match input.as_ref() {
            "a" => Ok(Self::A),
            _ => {
                if input.starts_with("b-") {
                    let i: usize = input
                        .strip_prefix("b-")
                        .unwrap()
                        .parse::<usize>()
                        .map_err(|e| e.to_string())?;
                    Ok(Self::B(i))
                } else {
                    Err(format!("Invalid value: {}", input))
                }
            }
        }
    }
}

#[test]
fn successful_test() {
    assert_eq!(MyEnum::from_str("b-3", true), Ok(MyEnum::B(3)));
}

#[test]
fn failing_test() {
    let cli = Cli::parse_from(vec!["program", "--foo=b-3"]);
    assert_eq!(cli.foo, MyEnum::B(3));
}

[epage]

It looks like we forgot to remove ValueEnum::from_str when we switched from v3's parse attribute to v4's value_parser. I do not remember if we had kept it around to help people implement FromStr which it looks like we don't even take advantage of it when we implement our own FromStrs.

How can I provide a custom parser for a type implementing ValueEnum? (I tried the value_parser annotation with no success.)

That sounds strange as a custom value parser should have higher precedence than the built-in one. Have a reproduction case?