Fix (again) non-exhaustive matching on Number (#568)

* Try to fix non-exhaustive Number enum (again)

* Use compile_fail doctests

* Adjust docs for the Number::__NonExhaustive variant

* Add CHANGELOG entry

Author: juntyr

CHANGELOG.md

@@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Breaking: Added `no_std` support via a new `std` feature (enabled by default). With default features disabled, you must enable the `std` feature to access `de::from_reader`, and the `std::io` operations on `Options`, such as `from_reader`, `from_reader_seed`, `to_io_writer`, and `to_io_writer_pretty` ([#567](https://github.com/ron-rs/ron/pull/567))
 
+- Breaking: Fixed `ron::value::Number` to ensure it is non-exhaustive, to avoid breaking `match`es when feature unification enables more of its variants than expected ([#568](https://github.com/ron-rs/ron/pull/568))
+
 ## [0.10.1] - 2025-04-08
 
 ### API Changes

src/value/number.rs

@@ -17,7 +17,8 @@ use serde::{de::Visitor, Serialize, Serializer};
 /// <summary>Exhaustively matching on <code>Number</code> in tests</summary>
 ///
 /// If you want to ensure that you exhaustively handle every variant, you can
-/// match on the hidden `Number::__NonExhaustive` variant.
+/// match on the hidden `Number::__NonExhaustive(x)` variant by using the
+/// `x.never() -> !` method.
 ///
 /// <div class="warning">
 /// Matching on this variant means that your code may break when RON is
@@ -54,8 +55,61 @@ pub enum Number {
 }
 
 mod private {
+    #[derive(Debug, PartialEq, PartialOrd, Eq, Hash, Ord)]
+    enum _Never {}
+
     #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Hash, Ord)]
-    pub enum Never {}
+    pub struct Never {
+        never: &'static _Never,
+    }
+
+    impl Never {
+        pub fn never(self) -> ! {
+            match *self.never {}
+        }
+    }
+
+    #[cfg(not(feature = "integer128"))]
+    /// ```compile_fail
+    /// # use ron::Number;
+    /// fn match_number(x: Number) {
+    ///     match x {
+    ///         Number::I8(v) => println!("i8: {}", v),
+    ///         Number::I16(v) => println!("i16: {}", v),
+    ///         Number::I32(v) => println!("i32: {}", v),
+    ///         Number::I64(v) => println!("i64: {}", v),
+    ///         Number::U8(v) => println!("u8: {}", v),
+    ///         Number::U16(v) => println!("u16: {}", v),
+    ///         Number::U32(v) => println!("u32: {}", v),
+    ///         Number::U64(v) => println!("u64: {}", v),
+    ///         Number::F32(v) => println!("f32: {}", v.0),
+    ///         Number::F64(v) => println!("f64: {}", v.0),
+    ///     }
+    /// }
+    /// ```
+    fn _assert_non_exhaustive_check_fails_not_integer128() {}
+
+    #[cfg(feature = "integer128")]
+    /// ```compile_fail
+    /// # use ron::Number;
+    /// fn match_number(x: Number) {
+    ///     match x {
+    ///         Number::I8(v) => println!("i8: {}", v),
+    ///         Number::I16(v) => println!("i16: {}", v),
+    ///         Number::I32(v) => println!("i32: {}", v),
+    ///         Number::I64(v) => println!("i64: {}", v),
+    ///         Number::I128(v) => println!("i128: {}", v),
+    ///         Number::U8(v) => println!("u8: {}", v),
+    ///         Number::U16(v) => println!("u16: {}", v),
+    ///         Number::U32(v) => println!("u32: {}", v),
+    ///         Number::U64(v) => println!("u64: {}", v),
+    ///         Number::U128(v) => println!("u128: {}", v),
+    ///         Number::F32(v) => println!("f32: {}", v.0),
+    ///         Number::F64(v) => println!("f64: {}", v.0),
+    ///     }
+    /// }
+    /// ```
+    fn _assert_non_exhaustive_check_fails_integer128() {}
 }
 
 impl Serialize for Number {
@@ -76,7 +130,7 @@ impl Serialize for Number {
             Self::F32(v) => serializer.serialize_f32(v.get()),
             Self::F64(v) => serializer.serialize_f64(v.get()),
             #[cfg(not(doc))]
-            Self::__NonExhaustive(never) => match *never {},
+            Self::__NonExhaustive(never) => never.never(),
         }
     }
 }
@@ -102,7 +156,7 @@ impl Number {
             Self::F32(v) => visitor.visit_f32(v.get()),
             Self::F64(v) => visitor.visit_f64(v.get()),
             #[cfg(not(doc))]
-            Self::__NonExhaustive(never) => match *never {},
+            Self::__NonExhaustive(never) => never.never(),
         }
     }
 }
@@ -255,7 +309,7 @@ impl Number {
             Self::F32(v) => f64::from(v.get()),
             Self::F64(v) => v.get(),
             #[cfg(not(doc))]
-            Self::__NonExhaustive(never) => match never {},
+            Self::__NonExhaustive(never) => never.never(),
         }
     }
 }

tests/564_exhaustive_number.rs

@@ -18,7 +18,7 @@ fn exhaustive_number_match() {
         Number::F32(v) => println!("{}", v.0),
         Number::F64(v) => println!("{}", v.0),
         #[cfg(not(doc))]
-        Number::__NonExhaustive(never) => match never {},
+        Number::__NonExhaustive(never) => never.never(),
     }
 }