Reduce max hash in raw strings from u16 to u8

compiler/rustc_ast/src/ast.rs

@@ -1616,7 +1616,7 @@ pub enum StrStyle {
  /// A raw string, like `r##"foo"##`.
  ///
  /// The value is the number of `#` symbols used.
- Raw(u16),
+ Raw(u8),
 }
 
 /// An AST literal.

compiler/rustc_ast/src/token.rs

@@ -60,9 +60,9 @@ pub enum LitKind {
  Integer,
  Float,
  Str,
- StrRaw(u16), // raw string delimited by `n` hash symbols
+ StrRaw(u8), // raw string delimited by `n` hash symbols
  ByteStr,
- ByteStrRaw(u16), // raw byte string delimited by `n` hash symbols
+ ByteStrRaw(u8), // raw byte string delimited by `n` hash symbols
  Err,
 }
 

compiler/rustc_lexer/src/lib.rs

@@ -161,15 +161,15 @@ pub enum LiteralKind {
  /// "b"abc"", "b"abc"
  ByteStr { terminated: bool },
  /// "r"abc"", "r#"abc"#", "r####"ab"###"c"####", "r#"a"
- RawStr { n_hashes: u16, err: Option<RawStrError> },
+ RawStr { n_hashes: u8, err: Option<RawStrError> },
  /// "br"abc"", "br#"abc"#", "br####"ab"###"c"####", "br#"a"
- RawByteStr { n_hashes: u16, err: Option<RawStrError> },
+ RawByteStr { n_hashes: u8, err: Option<RawStrError> },
 }
 
 /// Error produced validating a raw string. Represents cases like:
 /// - `r##~"abcde"##`: `InvalidStarter`
 /// - `r###"abcde"##`: `NoTerminator { expected: 3, found: 2, possible_terminator_offset: Some(11)`
-/// - Too many `#`s (>65535): `TooManyDelimiters`
+/// - Too many `#`s (>255): `TooManyDelimiters`
 // perf note: It doesn't matter that this makes `Token` 36 bytes bigger. See #77629
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum RawStrError {
@@ -178,7 +178,7 @@ pub enum RawStrError {
  /// The string was never terminated. `possible_terminator_offset` is the number of characters after `r` or `br` where they
  /// may have intended to terminate it.
  NoTerminator { expected: usize, found: usize, possible_terminator_offset: Option<usize> },
- /// More than 65535 `#`s exist.
+ /// More than 255 `#`s exist.
  TooManyDelimiters { found: usize },
 }
 
@@ -698,12 +698,12 @@ impl Cursor<'_> {
  }
 
  /// Eats the double-quoted string and returns `n_hashes` and an error if encountered.
- fn raw_double_quoted_string(&mut self, prefix_len: usize) -> (u16, Option<RawStrError>) {
+ fn raw_double_quoted_string(&mut self, prefix_len: usize) -> (u8, Option<RawStrError>) {
  // Wrap the actual function to handle the error with too many hashes.
  // This way, it eats the whole raw string.
  let (n_hashes, err) = self.raw_string_unvalidated(prefix_len);
- // Only up to 65535 `#`s are allowed in raw strings
- match u16::try_from(n_hashes) {
+ // Only up to 255 `#`s are allowed in raw strings
+ match u8::try_from(n_hashes) {
  Ok(num) => (num, err),
  // We lie about the number of hashes here :P
  Err(_) => (0, Some(RawStrError::TooManyDelimiters { found: n_hashes })),

compiler/rustc_lexer/src/tests.rs

@@ -2,7 +2,7 @@ use super::*;
 
 use expect_test::{expect, Expect};
 
-fn check_raw_str(s: &str, expected_hashes: u16, expected_err: Option<RawStrError>) {
+fn check_raw_str(s: &str, expected_hashes: u8, expected_err: Option<RawStrError>) {
  let s = &format!("r{}", s);
  let mut cursor = Cursor::new(s);
  cursor.bump();
@@ -68,13 +68,13 @@ fn test_unterminated_no_pound() {
 
 #[test]
 fn test_too_many_hashes() {
- let max_count = u16::MAX;
+ let max_count = u8::MAX;
  let mut hashes: String = "#".repeat(max_count.into());
 
- // Valid number of hashes (65535 = 2^16 - 1), but invalid string.
+ // Valid number of hashes (255 = 2^8 - 1 = u8::MAX), but invalid string.
  check_raw_str(&hashes, max_count, Some(RawStrError::InvalidStarter { bad_char: '\u{0}' }));
 
- // One more hash sign (65536 = 2^16) becomes too many.
+ // One more hash sign (256 = 2^8) becomes too many.
  hashes.push('#');
  check_raw_str(
  &hashes,

src/tools/clippy/clippy_lints/src/regex.rs

@@ -81,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for Regex {
 
 #[allow(clippy::cast_possible_truncation)] // truncation very unlikely here
 #[must_use]
-fn str_span(base: Span, c: regex_syntax::ast::Span, offset: u16) -> Span {
+fn str_span(base: Span, c: regex_syntax::ast::Span, offset: u8) -> Span {
  let offset = u32::from(offset);
  let end = base.lo() + BytePos(u32::try_from(c.end.offset).expect("offset too large") + offset);
  let start = base.lo() + BytePos(u32::try_from(c.start.offset).expect("offset too large") + offset);