Don't do default port normalization by default

yescallop · yescallop · commit 371c57add329 · 2025-11-07T22:06:43.000+08:00
diff --git a/src/build/mod.rs b/src/build/mod.rs
@@ -348,11 +348,10 @@ impl<R, S: To<PortEnd>> Builder<R, S> {
     ///
     /// This method takes either a `u16` or <code>&amp;[EStr]&lt;[Port]&gt;</code> as argument.
     ///
-    /// For consistency, you should not produce an empty or [default] port.
+    /// For consistency, you should not produce an empty or default port.
     ///
     /// [port-spec]: https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.3
     /// [Port]: crate::pct_enc::encoder::Port
-    /// [default]: Scheme::default_port
     pub fn port(mut self, port: impl AsPort) -> Builder<R, PortEnd> {
         port.push_to(&mut self.inner.buf);
         self.cast()
diff --git a/src/component.rs b/src/component.rs
@@ -113,97 +113,6 @@ impl Scheme {
     }
 }
 
-macro_rules! default_port {
-    ($($name:literal, $bname:literal => $port:literal, rfc($rfc:literal))*) => {
-        impl Scheme {
-            /// Returns the optional default port of the scheme if it is
-            /// registered [at IANA][iana] with a permanent status.
-            ///
-            /// [iana]: https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml
-            ///
-            /// The following table lists all schemes concerned, their default ports, and references:
-            ///
-            /// | Scheme | Port | Reference |
-            /// | - | - | - |
-            $(#[doc = concat!("| ", $name, " | ", $port, " | [RFC ", $rfc, "](https://datatracker.ietf.org/doc/html/rfc", $rfc, ") |")])*
-            #[must_use]
-            pub fn default_port(&self) -> Option<u16> {
-                const MAX_LEN: usize = {
-                    let mut res = 0;
-                    $(
-                        if $name.len() > res {
-                            res = $name.len();
-                        }
-                    )*
-                    res
-                };
-
-                let len = self.inner.len();
-                if len > MAX_LEN {
-                    return None;
-                }
-
-                let mut buf = [0; MAX_LEN];
-                for (i, b) in self.inner.bytes().enumerate() {
-                    buf[i] = b | ASCII_CASE_MASK;
-                }
-
-                match &buf[..len] {
-                    $($bname => Some($port),)*
-                    _ => None,
-                }
-            }
-        }
-    };
-}
-
-default_port! {
-    "aaa", b"aaa" => 3868, rfc(6733)
-    "aaas", b"aaas" => 5658, rfc(6733)
-    "acap", b"acap" => 674, rfc(2244)
-    "cap", b"cap" => 1026, rfc(4324)
-    "coap", b"coap" => 5683, rfc(7252)
-    "coap+tcp", b"coap+tcp" => 5683, rfc(8323)
-    "coap+ws", b"coap+ws" => 80, rfc(8323)
-    "coaps", b"coaps" => 5684, rfc(7252)
-    "coaps+tcp", b"coaps+tcp" => 5684, rfc(8323)
-    "coaps+ws", b"coaps+ws" => 443, rfc(8323)
-    "dict", b"dict" => 2628, rfc(2229)
-    "dns", b"dns" => 53, rfc(4501)
-    "ftp", b"ftp" => 21, rfc(1738)
-    "go", b"go" => 1096, rfc(3368)
-    "gopher", b"gopher" => 70, rfc(4266)
-    "http", b"http" => 80, rfc(9110)
-    "https", b"https" => 443, rfc(9110)
-    "icap", b"icap" => 1344, rfc(3507)
-    "imap", b"imap" => 143, rfc(5092)
-    "ipp", b"ipp" => 631, rfc(3510)
-    "ipps", b"ipps" => 631, rfc(7472)
-    "ldap", b"ldap" => 389, rfc(4516)
-    "mtqp", b"mtqp" => 1038, rfc(3887)
-    "mupdate", b"mupdate" => 3905, rfc(3656)
-    "nfs", b"nfs" => 2049, rfc(2224)
-    "nntp", b"nntp" => 119, rfc(5538)
-    "pop", b"pop" => 110, rfc(2384)
-    "rtsp", b"rtsp" => 554, rfc(7826)
-    "rtsps", b"rtsps" => 322, rfc(7826)
-    "rtspu", b"rtspu" => 554, rfc(2326)
-    "snmp", b"snmp" => 161, rfc(4088)
-    "stun", b"stun" => 3478, rfc(7064)
-    "stuns", b"stuns" => 5349, rfc(7064)
-    "telnet", b"telnet" => 23, rfc(4248)
-    "tip", b"tip" => 3372, rfc(2371)
-    "tn3270", b"tn3270" => 23, rfc(6270)
-    "turn", b"turn" => 3478, rfc(7065)
-    "turns", b"turns" => 5349, rfc(7065)
-    "vemmi", b"vemmi" => 575, rfc(2122)
-    "vnc", b"vnc" => 5900, rfc(7869)
-    "ws", b"ws" => 80, rfc(6455)
-    "wss", b"wss" => 443, rfc(6455)
-    "z39.50r", b"z39.50r" => 210, rfc(2056)
-    "z39.50s", b"z39.50s" => 210, rfc(2056)
-}
-
 impl PartialEq for Scheme {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
@@ -461,7 +370,7 @@ impl<'a, UserinfoE: Encoder, RegNameE: Encoder> Authority<'a, UserinfoE, RegName
 
     /// Returns the optional [port] subcomponent.
     ///
-    /// A scheme may define a [default port] to use when the port is
+    /// A scheme may define a default port to use when the port is
     /// not present or is empty.
     ///
     /// Note that the port may be empty, with leading zeros, or larger than [`u16::MAX`].
@@ -470,7 +379,6 @@ impl<'a, UserinfoE: Encoder, RegNameE: Encoder> Authority<'a, UserinfoE, RegName
     /// mechanism that allows ports larger than [`u16::MAX`].
     ///
     /// [port]: https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.3
-    /// [default port]: Scheme::default_port
     ///
     /// # Examples
     ///
diff --git a/src/imp.rs b/src/imp.rs
@@ -569,7 +569,7 @@ macro_rules! ri_maybe_ref {
                 /// `self.resolve_against(base).map(|r| r.normalize()).ok()` equals
                 /// `self.normalize().resolve_against(&base.normalize()).ok()`.
                 ///
-                /// If you need to resolve multiple references against a common base or configure the behavior
+                /// If you need to resolve multiple references against a common base or customize the behavior
                 /// of resolution, consider using [`Resolver`](crate::resolve::Resolver) instead.
                 ///
                 /// # Errors
@@ -607,15 +607,15 @@ macro_rules! ri_maybe_ref {
             /// This method applies syntax-based normalization described in
             /// [Section 6.2.2 of RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986#section-6.2.2)
             /// and [Section 5.3.2 of RFC 3987](https://datatracker.ietf.org/doc/html/rfc3987#section-5.3.2),
-            /// along with IPv6 address and default port normalization.
+            /// along with IPv6 address normalization.
             /// This is effectively equivalent to taking the following steps in order:
             ///
             /// - Decode any percent-encoded octets that correspond to an allowed character which is not reserved.
             /// - Uppercase the hexadecimal digits within all percent-encoded octets.
             /// - Lowercase all ASCII characters within the scheme and the host except the percent-encoded octets.
             /// - Turn any IPv6 literal address into its canonical form as per
             ///   [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952).
-            /// - If the port is empty or equals the [scheme's default], remove it along with the `':'` delimiter.
+            /// - If the port is empty, remove the preceding `':'` delimiter.
             /// - If `self` has a scheme and an [absolute] path, apply the
             ///   [`remove_dot_segments`] algorithm to the path, taking account of
             ///   percent-encoded dot segments as described at [`UriRef::resolve_against`].
@@ -624,10 +624,9 @@ macro_rules! ri_maybe_ref {
             ///
             /// This method is idempotent: `self.normalize()` equals `self.normalize().normalize()`.
             ///
-            /// If you need to configure the behavior of normalization, consider using [`Normalizer`] instead.
+            /// If you need to customize the behavior of normalization, consider using [`Normalizer`] instead.
             ///
             /// [`UriRef::resolve_against`]: crate::UriRef::resolve_against
-            /// [scheme's default]: Scheme::default_port
             /// [absolute]: EStr::<Path>::is_absolute
             /// [`remove_dot_segments`]: https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
             ///
diff --git a/src/normalize.rs b/src/normalize.rs
@@ -1,7 +1,6 @@
 //! Module for normalization.
 
 use crate::{
-    component::Scheme,
     imp::{HostMeta, Meta, RiMaybeRef, RmrRef},
     parse,
     pct_enc::{
@@ -45,15 +44,15 @@ impl crate::Error for NormalizeError {}
 #[must_use]
 pub struct Normalizer {
     allow_path_underflow: bool,
-    default_port_f: fn(&Scheme) -> Option<u16>,
+    default_port_f: fn(&str) -> Option<u16>,
 }
 
 impl Normalizer {
     /// Creates a new `Normalizer` with default configuration.
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             allow_path_underflow: true,
-            default_port_f: Scheme::default_port,
+            default_port_f: |_| None,
         }
     }
 
@@ -68,41 +67,45 @@ impl Normalizer {
     /// ```
     /// use fluent_uri::{normalize::{Normalizer, NormalizeError}, Uri};
     ///
-    /// let normalizer = Normalizer::new().allow_path_underflow(false);
-    /// let uri = Uri::parse("http://example.com/..")?;
+    /// const NORMALIZER: Normalizer = Normalizer::new().allow_path_underflow(false);
     ///
-    /// assert_eq!(normalizer.normalize(&uri).unwrap_err(), NormalizeError::PathUnderflow);
+    /// let uri = Uri::parse("http://example.com/..")?;
+    /// assert_eq!(NORMALIZER.normalize(&uri).unwrap_err(), NormalizeError::PathUnderflow);
     /// # Ok::<_, fluent_uri::ParseError>(())
     /// ```
-    pub fn allow_path_underflow(mut self, value: bool) -> Self {
+    pub const fn allow_path_underflow(mut self, value: bool) -> Self {
         self.allow_path_underflow = value;
         self
     }
 
-    /// Sets the function with which to get the default port of a scheme.
+    /// Sets the function with which to get the default port for a scheme.
+    ///
+    /// This defaults to `|_| None`.
     ///
-    /// This defaults to [`Scheme::default_port`].
+    /// The scheme will be lowercased before being passed to the function.
     ///
     /// # Examples
     ///
     /// ```
-    /// use fluent_uri::{component::Scheme, normalize::Normalizer, Uri};
+    /// use fluent_uri::{normalize::Normalizer, Uri};
     ///
-    /// const SCHEME_FOO: &Scheme = Scheme::new_or_panic("foo");
-    ///
-    /// let normalizer = Normalizer::new().default_port_with(|scheme| {
-    ///     if scheme == SCHEME_FOO {
-    ///         Some(4673)
-    ///     } else {
-    ///         scheme.default_port()
+    /// const NORMALIZER: Normalizer = Normalizer::new().default_port_with(|scheme| {
+    ///     // Simply match on `scheme` as it's already in lowercase.
+    ///     match scheme {
+    ///         "http" | "ws" => Some(80),
+    ///         "https" | "wss" => Some(443),
+    ///         _ => None,
     ///     }
     /// });
-    /// let uri = Uri::parse("foo://localhost:4673")?;
     ///
-    /// assert_eq!(normalizer.normalize(&uri).unwrap(), "foo://localhost");
+    /// let uri = Uri::parse("http://example.com:80/")?;
+    /// assert_eq!(NORMALIZER.normalize(&uri).unwrap(), "http://example.com/");
+    ///
+    /// let uri = Uri::parse("foo://example.com:4673/")?;
+    /// assert_eq!(NORMALIZER.normalize(&uri).unwrap(), "foo://example.com:4673/");
     /// # Ok::<_, fluent_uri::ParseError>(())
     /// ```
-    pub fn default_port_with(mut self, f: fn(&Scheme) -> Option<u16>) -> Self {
+    pub const fn default_port_with(mut self, f: fn(&str) -> Option<u16>) -> Self {
         self.default_port_f = f;
         self
     }
@@ -141,7 +144,7 @@ pub(crate) fn normalize(
     r: RmrRef<'_, '_>,
     ascii_only: bool,
     allow_path_underflow: bool,
-    default_port_f: fn(&Scheme) -> Option<u16>,
+    default_port_f: fn(&str) -> Option<u16>,
 ) -> Result<(String, Meta), NormalizeError> {
     // For "a://[::ffff:5:9]/" the capacity is not enough,
     // but it's fine since this rarely happens.
@@ -206,8 +209,8 @@ pub(crate) fn normalize(
         if let Some(port) = auth.port() {
             if !port.is_empty() {
                 let mut eq_default = false;
-                if let Some(scheme) = r.scheme_opt() {
-                    if let Some(default) = default_port_f(scheme) {
+                if let Some(scheme_end) = meta.scheme_end {
+                    if let Some(default) = default_port_f(&buf[..scheme_end.get()]) {
                         eq_default = port.as_str().parse().ok() == Some(default);
                     }
                 }
diff --git a/tests/normalize.rs b/tests/normalize.rs
@@ -27,7 +27,7 @@ fn normalize() {
     assert_eq!(r.normalize(), "http://example.com/");
 
     let r = UriRef::parse("http://example.com:80/").unwrap();
-    assert_eq!(r.normalize(), "http://example.com/");
+    assert_eq!(r.normalize(), "http://example.com:80/");
 
     // Lowercase percent-encoded octet.
     let r = UriRef::parse("%3a").unwrap();
