Merge pull request #379 from dtolnay/subspan

Implement Literal::subspan

build.rs

@@ -72,6 +72,10 @@ fn main() {
         println!("cargo:rustc-cfg=no_libprocmacro_unwind_safe");
     }
 
+    if version.minor < 34 {
+        println!("cargo:rustc-cfg=no_try_from");
+    }
+
     if version.minor < 39 {
         println!("cargo:rustc-cfg=no_bind_by_move_pattern_guard");
     }

src/convert.rs

@@ -0,0 +1,19 @@
+pub(crate) fn usize_to_u32(u: usize) -> Option<u32> {
+    #[cfg(not(no_try_from))]
+    {
+        use core::convert::TryFrom;
+
+        u32::try_from(u).ok()
+    }
+
+    #[cfg(no_try_from)]
+    {
+        use core::mem;
+
+        if mem::size_of::<usize>() <= mem::size_of::<u32>() || u <= u32::max_value() as usize {
+            Some(u as u32)
+        } else {
+            None
+        }
+    }
+}

src/fallback.rs

@@ -1012,8 +1012,46 @@ impl Literal {
         self.span = span;
     }
 
-    pub fn subspan<R: RangeBounds<usize>>(&self, _range: R) -> Option<Span> {
-        None
+    pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
+        #[cfg(not(span_locations))]
+        {
+            let _ = range;
+            None
+        }
+
+        #[cfg(span_locations)]
+        {
+            use crate::convert::usize_to_u32;
+            use core::ops::Bound;
+
+            let lo = match range.start_bound() {
+                Bound::Included(start) => {
+                    let start = usize_to_u32(*start)?;
+                    self.span.lo.checked_add(start)?
+                }
+                Bound::Excluded(start) => {
+                    let start = usize_to_u32(*start)?;
+                    self.span.lo.checked_add(start)?.checked_add(1)?
+                }
+                Bound::Unbounded => self.span.lo,
+            };
+            let hi = match range.end_bound() {
+                Bound::Included(end) => {
+                    let end = usize_to_u32(*end)?;
+                    self.span.lo.checked_add(end)?.checked_add(1)?
+                }
+                Bound::Excluded(end) => {
+                    let end = usize_to_u32(*end)?;
+                    self.span.lo.checked_add(end)?
+                }
+                Bound::Unbounded => self.span.hi,
+            };
+            if lo <= hi && hi <= self.span.hi {
+                Some(Span { lo, hi })
+            } else {
+                None
+            }
+        }
     }
 }
 

src/lib.rs

@@ -142,6 +142,8 @@ use crate::fallback as imp;
 #[cfg(wrap_proc_macro)]
 mod imp;
 
+#[cfg(span_locations)]
+mod convert;
 #[cfg(span_locations)]
 mod location;
 

tests/test.rs

@@ -268,11 +268,12 @@ fn literal_parse() {
 fn literal_span() {
     let positive = "0.1".parse::<Literal>().unwrap();
     let negative = "-0.1".parse::<Literal>().unwrap();
+    let subspan = positive.subspan(1..2);
 
     #[cfg(not(span_locations))]
     {
-        let _ = positive;
         let _ = negative;
+        assert!(subspan.is_none());
     }
 
     #[cfg(span_locations)]
@@ -281,7 +282,10 @@ fn literal_span() {
         assert_eq!(positive.span().end().column, 3);
         assert_eq!(negative.span().start().column, 0);
         assert_eq!(negative.span().end().column, 4);
+        assert_eq!(subspan.unwrap().source_text().unwrap(), ".");
     }
+
+    assert!(positive.subspan(1..4).is_none());
 }
 
 #[test]