Avoid panics for implicitly concatenated forward references (#3700)

crates/ruff/resources/test/fixtures/pyflakes/F722.py

@@ -8,3 +8,6 @@ def f() -> "A":
 
 def g() -> "///":
     pass
+
+
+X: """List[int]"""'☃' = []

crates/ruff/src/checkers/ast/mod.rs

@@ -5216,7 +5216,8 @@ impl<'a> Checker<'a> {
                     continue;
                 }
 
-                let body = str::raw_contents(contents);
+                // SAFETY: Safe for docstrings that pass `should_ignore_docstring`.
+                let body = str::raw_contents(contents).unwrap();
                 let docstring = Docstring {
                     kind: definition.kind,
                     expr,

crates/ruff/src/rules/pyflakes/fixes.rs

@@ -30,7 +30,7 @@ pub fn remove_unused_format_arguments_from_dict(
         !matches!(e, DictElement::Simple {
             key: Expression::SimpleString(name),
             ..
-        } if unused_arguments.contains(&raw_contents(name.value)))
+        } if raw_contents(name.value).map_or(false, |name| unused_arguments.contains(&name)))
     });
 
     let mut state = CodegenState {

crates/ruff/src/rules/pyflakes/snapshots/ruff__rules__pyflakes__tests__F722_F722.py.snap

@@ -15,4 +15,17 @@ expression: diagnostics
     column: 16
   fix: ~
   parent: ~
+- kind:
+    name: ForwardAnnotationSyntaxError
+    body: "Syntax error in forward annotation: `List[int]☃`"
+    suggestion: ~
+    fixable: false
+  location:
+    row: 13
+    column: 3
+  end_location:
+    row: 13
+    column: 21
+  fix: ~
+  parent: ~
 

crates/ruff_python_ast/src/str.rs

@@ -17,25 +17,13 @@ pub const SINGLE_QUOTE_BYTE_PREFIXES: &[&str] = &[
 const TRIPLE_QUOTE_SUFFIXES: &[&str] = &["\"\"\"", "'''"];
 const SINGLE_QUOTE_SUFFIXES: &[&str] = &["\"", "'"];
 
-/// Strip the leading and trailing quotes from a docstring.
+/// Strip the leading and trailing quotes from a string.
-pub fn raw_contents(contents: &str) -> &str {
+/// Assumes that the string is a valid string literal, but does not verify that the string
-    for pattern in TRIPLE_QUOTE_STR_PREFIXES
+/// is a "simple" string literal (i.e., that it does not contain any implicit concatenations).
-        .iter()
+pub fn raw_contents(contents: &str) -> Option<&str> {
-        .chain(TRIPLE_QUOTE_BYTE_PREFIXES)
+    let leading_quote_str = leading_quote(contents)?;
-    {
+    let trailing_quote_str = trailing_quote(contents)?;
-        if contents.starts_with(pattern) {
+    Some(&contents[leading_quote_str.len()..contents.len() - trailing_quote_str.len()])
-            return &contents[pattern.len()..contents.len() - 3];
-        }
-    }
-    for pattern in SINGLE_QUOTE_STR_PREFIXES
-        .iter()
-        .chain(SINGLE_QUOTE_BYTE_PREFIXES)
-    {
-        if contents.starts_with(pattern) {
-            return &contents[pattern.len()..contents.len() - 1];
-        }
-    }
-    unreachable!("Expected docstring to start with a valid triple- or single-quote prefix")
 }
 
 /// Return the leading quote for a string or byte literal (e.g., `"""`).

crates/ruff_python_ast/src/typing.rs

@@ -93,15 +93,14 @@ pub fn parse_type_annotation(
     locator: &Locator,
 ) -> Result<(Expr, AnnotationKind)> {
     let expression = locator.slice(range);
-    let body = str::raw_contents(expression);
+    if str::raw_contents(expression).map_or(false, |body| body == value) {
-    if body == value {
         // The annotation is considered "simple" if and only if the raw representation (e.g.,
         // `List[int]` within "List[int]") exactly matches the parsed representation. This
         // isn't the case, e.g., for implicit concatenations, or for annotations that contain
         // escaped quotes.
         let leading_quote = str::leading_quote(expression).unwrap();
         let expr = parser::parse_expression_located(
-            body,
+            value,
             "<filename>",
             Location::new(
                 range.location.row(),