Unable to construct match-all regex while opted out of unicode

[Fogapod]

fn main() -> Result<(), String> {
    use regex_automata::meta::Regex;
    use regex_automata::util::syntax;
    Regex::builder()
        .syntax(
            syntax::Config::new()
                .multi_line(true)
                .case_insensitive(true),
        )
        .build("(?-u).+")
        .unwrap();
}

This results in error: BuildError { kind: Syntax { pid: PatternID(0), err: Translate(Error { kind: InvalidUtf8, pattern: "(?-u).+", span: Span(Position(o: 5, l: 1, c: 6), Position(o: 6, l: 1, c: 7)) }) } }
with message: regex parse error:\n (?-u).+\n ^\nerror: pattern can match invalid UTF-8

I am matching entire string without any limitations which could stop mid codepoint. Is there a way to write this regex a different way? both + and * result in error

[BurntSushi]

(?-u:.) can match invalid UTF-8. It can absolutely match mid-codepoint because it matches any arbitrary byte. You either need to use something that won't match invalid UTF-8 or disable the requirement that regexes only match UTF-8.

"can match invalid UTF-8" is interpreted in a maximalist sense. It may be the case that the regex cannot match invalid UTF-8 for your particular haystack. But regex construction doesn't know that. In that case, it may indeed be appropriate to disable the requirement that the regex must always match valid UTF-8.

[Fogapod]

I was wondering if there is a way to disable this restriction inside regex itself but it makes sense why there isn't. The only reason I used (?-u) is to check if it somehow runs faster

[BurntSushi]

Yeah you can't because the regex itself can't know which APIs it's used in. If you could truly disable it within the regex, then someone could use regex::Regex to make a pattern that matches invalid UTF-8, and thus potentially result in panics when slicing a &str. There really does have to be an opt-in at the API level.

Sometimes (?-u) will help make things run faster, so it is indeed a fine thing to check. But it probably won't help a simple .+ too much. It could help in cases like (?m-u)^.+$ because that might compile down to a DFA with an accelerated state that looks for a \n.