Skip work on the error-free parse path

Return early from `prioritize_tokenizer_error` when there are no errors
instead of re-lexing the source, and track seen string prefixes in a
bitmask instead of allocating a `Vec` for every identifier.

Assisted-by: Claude Code:claude-opus-5-5

Author: youknowone

crates/ruff_python_parser/src/lexer.rs

@@ -780,24 +780,26 @@ impl<'src> Lexer<'src> {
             ('f', 't'),
         ];
 
-        let mut seen = Vec::with_capacity(PREFIXES.len());
+        let bit = |prefix: char| PREFIXES.iter().position(|&c| c == prefix).map(|i| 1u8 << i);
+        let mut seen = 0u8;
         let mut len = TextSize::new(0);
         let mut chars = std::iter::once(first).chain(self.cursor.rest().chars());
         loop {
             let c = chars.next()?;
             if is_quote(c) {
                 break;
             }
-            let prefix = c.to_ascii_lowercase();
-            if !PREFIXES.contains(&prefix) || seen.contains(&prefix) {
+            let prefix = bit(c.to_ascii_lowercase())?;
+            if seen & prefix != 0 {
                 return None;
             }
-            seen.push(prefix);
+            seen |= prefix;
             len += c.text_len();
         }
+        let has = |prefix: char| bit(prefix).is_some_and(|prefix| seen & prefix != 0);
         let (first, second) = INCOMPATIBLE
             .into_iter()
-            .find(|(first, second)| seen.contains(first) && seen.contains(second))?;
+            .find(|(first, second)| has(*first) && has(*second))?;
         Some(LexicalError::new(
             LexicalErrorType::IncompatibleStringPrefixes { first, second },
             TextRange::at(self.token_range().start(), len),

crates/ruff_python_parser/src/parser/mod.rs

@@ -1990,6 +1990,10 @@ fn prioritize_tokenizer_error(
     start_offset: TextSize,
     unclosed_bracket_recovery: Option<TextSize>,
 ) {
+    // The lexer reports every tokenizer error, so a source without errors has none to find.
+    if errors.is_empty() {
+        return;
+    }
     let is_tokenizer_error = |error: &ParseError| matches!(&error.error, ParseErrorType::Lexical(lexical) if lexical.is_tokenizer_error());
     let first = errors
         .iter()