Gate literal fromstr support on new enough compiler

build.rs

@@ -0,0 +1,33 @@
+use std::env;
+use std::process::Command;
+use std::str;
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let version = match rustc_version() {
+        Some(version) => version,
+        None => return,
+    };
+
+    if version.minor < 54 {
+        // https://github.com/rust-lang/rust/pull/84717
+        println!("cargo:rustc-cfg=no_literal_fromstr");
+    }
+}
+
+struct RustcVersion {
+    minor: u32,
+}
+
+fn rustc_version() -> Option<RustcVersion> {
+    let rustc = env::var_os("RUSTC")?;
+    let output = Command::new(rustc).arg("--version").output().ok()?;
+    let version = str::from_utf8(&output.stdout).ok()?;
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+    let minor = pieces.next()?.parse().ok()?;
+    Some(RustcVersion { minor })
+}

src/lib.rs

@@ -155,13 +155,10 @@ mod segment;
 use crate::attr::expand_attr;
 use crate::error::{Error, Result};
 use crate::segment::Segment;
-use proc_macro::{
-    Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
-};
+use proc_macro::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
 use std::char;
 use std::iter;
 use std::panic;
-use std::str::FromStr;
 
 #[proc_macro]
 pub fn paste(input: TokenStream) -> TokenStream {
@@ -414,23 +411,31 @@ fn parse_bracket_as_segments(input: TokenStream, scope: Span) -> Result<Vec<Segm
 fn pasted_to_tokens(mut pasted: String, span: Span) -> Result<TokenStream> {
     let mut tokens = TokenStream::new();
 
+    #[cfg(not(no_literal_fromstr))]
+    {
+        use proc_macro::{LexError, Literal};
+        use std::str::FromStr;
+
+        if pasted.starts_with(|ch: char| ch.is_ascii_digit()) {
+            let literal = match panic::catch_unwind(|| Literal::from_str(&pasted)) {
+                Ok(Ok(literal)) => TokenTree::Literal(literal),
+                Ok(Err(LexError { .. })) | Err(_) => {
+                    return Err(Error::new(
+                        span,
+                        &format!("`{:?}` is not a valid literal", pasted),
+                    ));
+                }
+            };
+            tokens.extend(iter::once(literal));
+            return Ok(tokens);
+        }
+    }
+
     if pasted.starts_with('\'') {
         let mut apostrophe = TokenTree::Punct(Punct::new('\'', Spacing::Joint));
         apostrophe.set_span(span);
         tokens.extend(iter::once(apostrophe));
         pasted.remove(0);
-    } else if pasted.starts_with(|ch: char| ch.is_ascii_digit()) {
-        let literal = match panic::catch_unwind(|| Literal::from_str(&pasted)) {
-            Ok(Ok(literal)) => TokenTree::Literal(literal),
-            Ok(Err(LexError { .. })) | Err(_) => {
-                return Err(Error::new(
-                    span,
-                    &format!("`{:?}` is not a valid literal", pasted),
-                ));
-            }
-        };
-        tokens.extend(iter::once(literal));
-        return Ok(tokens);
     }
 
     let ident = match panic::catch_unwind(|| Ident::new(&pasted, span)) {