-.1 is not recognized with allow_negative_numbers(true)

[cakebaker]

Hi,

I'm trying to upgrade clap from 4.4.2 to 4.5.22 and I noticed an issue in our CI where I'm not sure whether it's a bug or the intended behavior.

To reproduce the issue, here is a simple example that works fine with 4.4.2 but with 4.5.22 the first assert fails.

use clap::{Arg, Command};

fn main() {
    let res = Command::new("myprog")
        .arg(Arg::new("num").allow_negative_numbers(true))
        .try_get_matches_from(vec!["myprog", "-.1"]);
    assert!(res.is_ok());
    let m = res.unwrap();
    assert_eq!(m.get_one::<String>("num").unwrap(), "-.1");
}

[epage]

Our "is number" check is at

clap/clap_lex/src/lib.rs

Lines 492 to 522 in 5babafd

	fn is_number(arg: &str) -> bool {
	// Return true if this looks like an integer or a float where it's all
	// digits plus an optional single dot after some digits.
	//
	// For floats allow forms such as `1.`, `1.2`, `1.2e10`, etc.
	let mut seen_dot = false;
	let mut position_of_e = None;
	for (i, c) in arg.as_bytes().iter().enumerate() {
	match c {
	// Digits are always valid
	b'0'..=b'9' => {}
	// Allow a `.`, but only one, only if it comes before an
	// optional exponent, and only if it's not the first character.
	b'.' if !seen_dot && position_of_e.is_none() && i > 0 => seen_dot = true,
	// Allow an exponent `e` but only at most one after the first
	// character.
	b'e' if position_of_e.is_none() && i > 0 => position_of_e = Some(i),
	_ => return false,
	}
	}
	// Disallow `-1e` which isn't a valid float since it doesn't actually have
	// an exponent.
	match position_of_e {
	Some(i) => i != arg.len() - 1,
	None => true,
	}
	}

A year ago, #5181 was merged to reduce the code size by avoiding the expense of s.parse::<f64>().

Huh, hadn't realized that Rust supports -.1 (e.g. toml disallows it) and apparently the author of that change overlooked it too.
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=a46f1a0721683e87108251e61cffcd8c

If/when someone fixes this, we should probably add a basic property test that anything a float parser can parse, we can parse also.