Remove ParseErrorKind::InvalidPctEncodedOctet

yescallop · yescallop · commit 4124275629ce · 2025-11-19T15:54:16.000+08:00
diff --git a/src/fmt.rs b/src/fmt.rs
@@ -21,8 +21,7 @@ impl<E: Encoder> Display for EStr<E> {
 impl Display for ParseError {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         let msg = match self.kind {
-            ParseErrorKind::InvalidPctEncodedOctet => "invalid percent-encoded octet at index ",
-            ParseErrorKind::UnexpectedChar => "unexpected character at index ",
+            ParseErrorKind::UnexpectedCharOrEnd => "unexpected character or end of input at index ",
             ParseErrorKind::InvalidIpv6Addr => "invalid IPv6 address at index ",
         };
         write!(f, "{}{}", msg, self.index)
diff --git a/src/parse.rs b/src/parse.rs
@@ -12,14 +12,10 @@ use core::{
 /// Detailed cause of a [`ParseError`].
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum ParseErrorKind {
-    /// Invalid percent-encoded octet that is either non-hexadecimal or incomplete.
+    /// Unexpected character or end of input.
     ///
-    /// The error index points to the percent character "%" of the octet.
-    InvalidPctEncodedOctet,
-    /// Unexpected character that is not allowed by the URI/IRI syntax.
-    ///
-    /// The error index points to the first byte of the character.
-    UnexpectedChar,
+    /// The error index points to the first byte of the character or the end of input.
+    UnexpectedCharOrEnd,
     /// Invalid IPv6 address.
     ///
     /// The error index points to the first byte of the address.
@@ -50,14 +46,14 @@ impl ParseError {
 #[cfg(feature = "impl-error")]
 impl crate::Error for ParseError {}
 
-type Result<T> = core::result::Result<T, crate::parse::ParseError>;
+type Result<T> = core::result::Result<T, ParseError>;
 
 /// Returns immediately with an error.
 macro_rules! err {
     ($index:expr, $kind:ident) => {
-        return Err(crate::parse::ParseError {
+        return Err(ParseError {
             index: $index,
-            kind: crate::parse::ParseErrorKind::$kind,
+            kind: ParseErrorKind::$kind,
         })
     };
 }
@@ -163,6 +159,17 @@ impl<'a> Reader<'a> {
         Ok(self.pos > start)
     }
 
+    #[cold]
+    fn invalid_pct(&self) -> Result<()> {
+        let mut i = self.pos + 1;
+        if let Some(&x) = self.bytes.get(i) {
+            if pct_enc::is_hexdig(x) {
+                i += 1;
+            }
+        }
+        err!(i, UnexpectedCharOrEnd);
+    }
+
     fn read_with(&mut self, table: Table, mut f: impl FnMut(usize, u32)) -> Result<()> {
         let mut i = self.pos;
 
@@ -172,10 +179,10 @@ impl<'a> Reader<'a> {
                     let x = self.bytes[i];
                     if $allow_pct_encoded && x == b'%' {
                         let [hi, lo, ..] = self.bytes[i + 1..] else {
-                            err!(i, InvalidPctEncodedOctet);
+                            return self.invalid_pct();
                         };
-                        if !pct_enc::is_valid_octet(hi, lo) {
-                            err!(i, InvalidPctEncodedOctet);
+                        if !pct_enc::is_hexdig_pair(hi, lo) {
+                            return self.invalid_pct();
                         }
                         i += 3;
                     } else if $allow_non_ascii {
@@ -395,7 +402,7 @@ impl<'a> Reader<'a> {
         };
 
         if !self.read_str("]") {
-            err!(self.pos, UnexpectedChar);
+            err!(self.pos, UnexpectedCharOrEnd);
         }
         Ok(Some(meta))
     }
@@ -408,7 +415,7 @@ impl<'a> Reader<'a> {
                 return Ok(());
             }
         }
-        err!(self.pos, UnexpectedChar);
+        err!(self.pos, UnexpectedCharOrEnd);
     }
 }
 
@@ -463,7 +470,7 @@ impl Parser<'_> {
             if self.pos > 0 && self.bytes[0].is_ascii_alphabetic() {
                 self.out.scheme_end = NonZeroUsize::new(self.pos);
             } else {
-                err!(0, UnexpectedChar);
+                err!(0, UnexpectedCharOrEnd);
             }
 
             // INVARIANT: Skipping ":" is fine.
@@ -474,7 +481,7 @@ impl Parser<'_> {
                 self.parse_from_path(PathKind::General)
             };
         } else if self.constraints.scheme_required {
-            err!(self.pos, UnexpectedChar);
+            err!(self.pos, UnexpectedCharOrEnd);
         } else if self.pos == 0 {
             // Nothing read.
             if self.read_str("//") {
@@ -530,13 +537,13 @@ impl Parser<'_> {
                 1 => {
                     for i in colon_idx + 1..self.pos {
                         if !self.bytes[i].is_ascii_digit() {
-                            err!(i, UnexpectedChar);
+                            err!(i, UnexpectedCharOrEnd);
                         }
                     }
                     colon_idx
                 }
                 // Multiple colons.
-                _ => err!(colon_idx, UnexpectedChar),
+                _ => err!(colon_idx, UnexpectedCharOrEnd),
             };
 
             let meta = parse_v4_or_reg_name(&self.bytes[auth_start..host_end]);
@@ -562,7 +569,7 @@ impl Parser<'_> {
                 let start = self.pos;
                 // Either empty or starting with '/'.
                 if self.read(path_table)? && self.bytes[start] != b'/' {
-                    err!(start, UnexpectedChar);
+                    err!(start, UnexpectedCharOrEnd);
                 }
                 (start, self.pos)
             }
@@ -573,7 +580,7 @@ impl Parser<'_> {
                 if self.peek(0) == Some(b':') {
                     // In a relative reference, the first path
                     // segment cannot contain a colon character.
-                    err!(self.pos, UnexpectedChar);
+                    err!(self.pos, UnexpectedCharOrEnd);
                 }
 
                 self.read(path_table)?;
@@ -593,7 +600,7 @@ impl Parser<'_> {
         }
 
         if self.has_remaining() {
-            err!(self.pos, UnexpectedChar);
+            err!(self.pos, UnexpectedCharOrEnd);
         }
         Ok(())
     }
diff --git a/src/pct_enc/mod.rs b/src/pct_enc/mod.rs
@@ -487,7 +487,11 @@ pub(crate) fn decode_hexdigit(x: u8) -> Option<u8> {
     Some(OCTET_TABLE_LO[x as usize]).filter(|&v| v < 128)
 }
 
-pub(crate) const fn is_valid_octet(hi: u8, lo: u8) -> bool {
+pub(crate) const fn is_hexdig(x: u8) -> bool {
+    OCTET_TABLE_LO[x as usize] < 128
+}
+
+pub(crate) const fn is_hexdig_pair(hi: u8, lo: u8) -> bool {
     OCTET_TABLE_LO[hi as usize] | OCTET_TABLE_LO[lo as usize] < 128
 }
 
diff --git a/src/pct_enc/table.rs b/src/pct_enc/table.rs
@@ -154,7 +154,7 @@ impl Table {
                         }
                         let (hi, lo) = (s[i + 1], s[i + 2]);
 
-                        if !pct_enc::is_valid_octet(hi, lo) {
+                        if !pct_enc::is_hexdig_pair(hi, lo) {
                             return false;
                         }
                         i += 3;
diff --git a/tests/parse.rs b/tests/parse.rs
@@ -249,20 +249,20 @@ fn parse_error_uri() {
     }
 
     // No scheme
-    fail("foo", 3, UnexpectedChar);
+    fail("foo", 3, UnexpectedCharOrEnd);
 
     // Empty scheme
-    fail(":hello", 0, UnexpectedChar);
+    fail(":hello", 0, UnexpectedCharOrEnd);
 
     // Scheme starts with non-letter
-    fail("3ttp://a.com", 0, UnexpectedChar);
+    fail("3ttp://a.com", 0, UnexpectedCharOrEnd);
 
     // Unexpected char in scheme
-    fail("exam=ple:foo", 4, UnexpectedChar);
-    fail("(:", 0, UnexpectedChar);
+    fail("exam=ple:foo", 4, UnexpectedCharOrEnd);
+    fail("(:", 0, UnexpectedCharOrEnd);
 
     // Percent-encoded scheme
-    fail("a%20:foo", 1, UnexpectedChar);
+    fail("a%20:foo", 1, UnexpectedCharOrEnd);
 }
 
 #[track_caller]
@@ -275,64 +275,64 @@ fn fail(input: &str, index: usize, kind: ParseErrorKind) {
 #[test]
 fn parse_error_uri_ref() {
     // Empty scheme
-    fail(":hello", 0, UnexpectedChar);
+    fail(":hello", 0, UnexpectedCharOrEnd);
 
     // Scheme starts with non-letter
-    fail("3ttp://a.com", 0, UnexpectedChar);
+    fail("3ttp://a.com", 0, UnexpectedCharOrEnd);
 
     // After rewriting the parser, the following two cases are interpreted as
     // containing colon in the first path segment of a relative reference.
 
     // Unexpected char in scheme
-    fail("exam=ple:foo", 8, UnexpectedChar);
-    fail("(:", 1, UnexpectedChar);
+    fail("exam=ple:foo", 8, UnexpectedCharOrEnd);
+    fail("(:", 1, UnexpectedCharOrEnd);
 
     // Percent-encoded scheme
-    fail("a%20:foo", 4, UnexpectedChar);
+    fail("a%20:foo", 4, UnexpectedCharOrEnd);
 
     // Unexpected char in path
-    fail("foo\\bar", 3, UnexpectedChar);
+    fail("foo\\bar", 3, UnexpectedCharOrEnd);
 
     // Non-hexadecimal percent-encoded octet
-    fail("foo%xxd", 3, InvalidPctEncodedOctet);
+    fail("foo%xxd", 4, UnexpectedCharOrEnd);
 
     // Incomplete percent-encoded octet
-    fail("text%a", 4, InvalidPctEncodedOctet);
+    fail("text%a", 6, UnexpectedCharOrEnd);
 
     // A single percent
-    fail("%", 0, InvalidPctEncodedOctet);
+    fail("%", 1, UnexpectedCharOrEnd);
 
     // Non-decimal port
-    fail("http://example.com:80ab", 21, UnexpectedChar);
-    fail("http://user@example.com:80ab", 26, UnexpectedChar);
+    fail("http://example.com:80ab", 21, UnexpectedCharOrEnd);
+    fail("http://user@example.com:80ab", 26, UnexpectedCharOrEnd);
 
     // Multiple colons in authority
-    fail("http://user:pass:example.com/", 16, UnexpectedChar);
+    fail("http://user:pass:example.com/", 16, UnexpectedCharOrEnd);
 
     // Unclosed bracket
-    fail("https://[::1/", 12, UnexpectedChar);
+    fail("https://[::1/", 12, UnexpectedCharOrEnd);
 
     // Not port after IP literal
-    fail("https://[::1]wrong", 13, UnexpectedChar);
+    fail("https://[::1]wrong", 13, UnexpectedCharOrEnd);
 
     // IP literal too short
     fail("http://[:]", 8, InvalidIpv6Addr);
-    fail("http://[]", 8, UnexpectedChar);
+    fail("http://[]", 8, UnexpectedCharOrEnd);
 
     // Non-hexadecimal version in IPvFuture
-    fail("http://[vG.addr]", 9, UnexpectedChar);
+    fail("http://[vG.addr]", 9, UnexpectedCharOrEnd);
 
     // Empty version in IPvFuture
-    fail("http://[v.addr]", 9, UnexpectedChar);
+    fail("http://[v.addr]", 9, UnexpectedCharOrEnd);
 
     // Empty address in IPvFuture
-    fail("ftp://[vF.]", 10, UnexpectedChar);
+    fail("ftp://[vF.]", 10, UnexpectedCharOrEnd);
 
     // Percent-encoded address in IPvFuture
-    fail("ftp://[vF.%20]", 10, UnexpectedChar);
+    fail("ftp://[vF.%20]", 10, UnexpectedCharOrEnd);
 
     // With zone identifier
-    fail("ftp://[fe80::abcd%eth0]", 17, UnexpectedChar);
+    fail("ftp://[fe80::abcd%eth0]", 17, UnexpectedCharOrEnd);
 
     // Invalid IPv6 address
     fail("example://[44:55::66::77]", 11, InvalidIpv6Addr);

Original file line number	Diff line number	Diff line change
`@@ -487,7 +487,11 @@ pub(crate) fn decode_hexdigit(x: u8) -> Option<u8> {`
`487`	`487`	`Some(OCTET_TABLE_LO[x as usize]).filter(\|&v\| v < 128)`
`488`	`488`	`}`
`489`	`489`
`490`		`-pub(crate) const fn is_valid_octet(hi: u8, lo: u8) -> bool {`
	`490`	`+pub(crate) const fn is_hexdig(x: u8) -> bool {`
	`491`	`+ OCTET_TABLE_LO[x as usize] < 128`
	`492`	`+}`
	`493`	`+`
	`494`	`+pub(crate) const fn is_hexdig_pair(hi: u8, lo: u8) -> bool {`
`491`	`495`	`OCTET_TABLE_LO[hi as usize] \| OCTET_TABLE_LO[lo as usize] < 128`
`492`	`496`	`}`
`493`	`497`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ impl Table {`
`154`	`154`	`}`
`155`	`155`	`let (hi, lo) = (s[i + 1], s[i + 2]);`
`156`	`156`
`157`		`- if !pct_enc::is_valid_octet(hi, lo) {`
	`157`	`+ if !pct_enc::is_hexdig_pair(hi, lo) {`
`158`	`158`	`return false;`
`159`	`159`	`}`
`160`	`160`	`i += 3;`