Incorrect alternation chosen when .*.* occurs in pattern

[orlp]

What version of regex are you using?

regex = "1.12.3"

Describe the bug at a high level.

If the pattern contains .*.* then regex gets confused and no longer chooses the first-matching alternation.

What are the steps to reproduce the behavior?

let pattern = ".*ab|.*.*";
let haystack = "abc";
dbg!(regex::Regex::new(pattern).unwrap().find_iter(haystack).collect::<Vec<_>>());

What is the actual behavior?

We see that regex returns one match:

[
    Match {
        start: 0,
        end: 3,
        string: "abc",
    },
]

What is the expected behavior?

The correct behavior is found in regex-lite:

[
    Match {
        start: 0,
        end: 2,
        string: "ab",
    },
    Match {
        start: 2,
        end: 3,
        string: "c",
    },
]

The first alteration (.*ab) matches starting at position 0, so it must be chosen.

If the pattern is changed from .*ab|.*.* to .*ab|.* then regex behaves correctly, returning two matches.

[tgross35]

Is this perhaps related to firasdib/Regex101#2655?

fn main() {
    let pattern = "0*|a";
    let haystack = "0a";
    dbg!(regex::Regex::new(pattern).unwrap().find_iter(haystack).collect::<Vec<_>>());
}

[src/main.rs:4:5] regex::Regex::new(pattern).unwrap().find_iter(haystack).collect::<Vec<_>>() = [
    Match {
        start: 0,
        end: 1,
        string: "0",
    },
    Match {
        start: 2,
        end: 2,
        string: "",
    },
]