Change:
None } } <ins> /// Multiply `Duration` by `f64`. /// /// # Examples /// ``` /// let dur = Duration::new(2, 700_000_000); /// assert_eq!(dur.mul_f64(3.14), Duration::new(8, 478_000_000)); /// assert_eq!(dur.mul_f64(3.14e5), Duration::new(847_800, 0)); /// ``` #[unstable(feature = "duration_float_ops", reason = "duration/floats operations are unstabe", issue = "0")] #[inline] pub fn mul_f64(self, rhs: f64) -> Duration { const NPS: f64 = NANOS_PER_SEC as f64; let nanos_f64 = rhs * (NPS * (self.secs as f64) + (self.nanos as f64)); if !nanos_f64.is_finite() { panic!("got non-finite value when multiplying duration by float"); } if nanos_f64 > MAX_NANOS_F64 { panic!("overflow when multiplying duration by float"); } if nanos_f64 < 0.0 { panic!("underflow when multiplying duration by float"); } let nanos_u128 = nanos_f64 as u128; Duration { secs: (nanos_u128 / (NANOS_PER_SEC as u128)) as u64, nanos: (nanos_u128 % (NANOS_PER_SEC as u128)) as u32, } } /// Divide `Duration` by `f64`. /// /// # Examples /// ``` /// let dur = Duration::new(2, 700_000_000); /// assert_eq!(dur.div_f64(3.14), Duration::new(0, 859_872_611)); /// // note that truncation is used, not rounding /// assert_eq!(dur.div_f64(3.14e5), Duration::new(0, 8_598)); /// ``` #[unstable(feature = "duration_float_ops", reason = "duration/floats operations are unstabe", issue = "0")] #[inline] pub fn div_f64(self, rhs: f64) -> Duration { const NPS: f64 = NANOS_PER_SEC as f64; let nanos_f64 = (NPS * (self.secs as f64) + (self.nanos as f64)) / rhs; if !nanos_f64.is_finite() { panic!("got non-finite value when dividing duration by float"); } if nanos_f64 > MAX_NANOS_F64 { panic!("overflow when dividing duration by float"); } if nanos_f64 < 0.0 { panic!("underflow when multiplying duration by float"); } let nanos_u128 = nanos_f64 as u128; Duration { secs: (nanos_u128 / (NANOS_PER_SEC as u128)) as u64, nanos: (nanos_u128 % (NANOS_PER_SEC as u128)) as u32, } } /// Divide `Duration` by `Duration` and return `f64`. /// /// # Examples /// ``` /// let dur1 = Duration::new(2, 700_000_000); /// let dur2 = Duration::new(5, 400_000_000); /// assert_eq!(dur1.div_duration(dur2), 0.5); /// ``` #[unstable(feature = "duration_float_ops", reason = "duration/floats operations are unstabe", issue = "0")] #[inline] pub fn div_duration(self, rhs: Duration) -> f64 { const NPS: f64 = NANOS_PER_SEC as f64; let nanos1 = NPS * (self.secs as f64) + (self.nanos as f64); let nanos2 = NPS * (rhs.secs as f64) + (rhs.nanos as f64); nanos1/nanos2 } </ins> } #[stable(feature = "duration", since = "1.3.0")]

Discussion:
Attempting to compile this: will give this error: I was thinking that a clearer error could be something along the lines of: and give this hint:
This should be straightforward to add a help message for. This error message is emitted here: The immediately afterwards is responsible for giving suggestions relevant to the particular type. You'd need to add a new case for () and emit an appropriate message (there are examples for other types in the expression), if the field is numeric. If anyone'd like to tackle this, just post a reply here — I can give more details as needed (but it's always useful to try working things out yourself first, to get a feel for where to find things).
I don't have any experience with Rustc's codebase, but I would be willing to give it a try.
great! If you need any help, you can post a comment here, or ask on or #rustc. Once you add the help message, you'll need to add a test for it (there are plenty of examples in — you can run to test and produce the output).

Do you have some more info? Is this something users experience? Or is it mostly custom drivers running into problems?
When implementing myself I accidentally tried to parse a different file type. This returned an error from , but the error was never printed to the user, instead it said ...`.
It's possible if an rlib/dylib gets corrupt, because then it won't say the file is corrupt. Yes