From b9a315d043cbc1e3ac0d8bb9e03553ad1c0028af Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 30 Mar 2026 17:59:30 +0000
Subject: [PATCH 1/2] Initial plan


From 83e6521d96ec17613d39a06ad6744f5366ff4d9d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 30 Mar 2026 18:10:22 +0000
Subject: [PATCH 2/2] Fix: Support f32/f64 float literal generation in paste!
 macro

Agent-Logs-Url: https://github.com/AS1100K/pastey/sessions/3d48cd89-2b04-4e98-bb16-d809ad37be2a

Co-authored-by: AS1100K <117935160+AS1100K@users.noreply.github.com>
---
 pastey-test-suite/tests/test_expr.rs | 27 +++++++++++++++++++
 src/lib.rs                           | 40 ++++++++++++++++++++++++++--
 src/segment.rs                       |  4 +++
 3 files changed, 69 insertions(+), 2 deletions(-)

diff --git a/pastey-test-suite/tests/test_expr.rs b/pastey-test-suite/tests/test_expr.rs
index f5a3417..37ac835 100644
--- a/pastey-test-suite/tests/test_expr.rs
+++ b/pastey-test-suite/tests/test_expr.rs
@@ -59,6 +59,33 @@ fn test_literal_suffix() {
     assert_eq!(literal!(32), 1);
 }
 
+#[test]
+fn test_float_literal() {
+    let x: f32 = paste!([<0.0 f32>]);
+    assert_eq!(x, 0.0f32);
+
+    let y: f64 = paste!([<1.5 f64>]);
+    assert_eq!(y, 1.5f64);
+
+    macro_rules! typed_float {
+        ($ty:tt) => {
+            paste!([<1.0 $ty>])
+        };
+    }
+
+    let _: f32 = typed_float!(f32);
+    let _: f64 = typed_float!(f64);
+}
+
+#[test]
+fn test_negative_float_literal() {
+    let x: f32 = paste!([< -1.5 f32>]);
+    assert_eq!(x, -1.5f32);
+
+    let y: f64 = paste!([<-0.5 f64>]);
+    assert_eq!(y, -0.5f64);
+}
+
 #[test]
 fn test_underscore() {
     paste! {
diff --git a/src/lib.rs b/src/lib.rs
index fb8e62c..e6552e6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -251,7 +251,12 @@ fn parse_bracket_as_segments(input: TokenStream, scope: Span) -> Result<Vec<Segm
                     }
                 }
             }
-            if string.value.contains(&['\\', '.', '+'][..])
+            // Numeric literals (e.g. `0.0`, `1.5f32`) start with a digit and may
+            // contain `.`. Allow them through; reject other literals that contain
+            // unsupported characters such as `\`, `+`, or `.`.
+            let is_numeric_literal = string.value.starts_with(|ch: char| ch.is_ascii_digit())
+                && !string.value.contains('+');
+            if (!is_numeric_literal && string.value.contains(&['\\', '.', '+'][..]))
                 || string.value.starts_with("b'")
                 || string.value.starts_with("b\"")
                 || string.value.starts_with("br\"")
@@ -259,6 +264,8 @@ fn parse_bracket_as_segments(input: TokenStream, scope: Span) -> Result<Vec<Segm
                 return Err(Error::new(string.span, "unsupported literal"));
             }
             let mut range = 0..string.value.len();
+            let is_quoted = string.value.starts_with("r\"")
+                || string.value.starts_with(&['"', '\''][..]);
             if string.value.starts_with("r\"") {
                 range.start += 2;
                 range.end -= 1;
@@ -266,7 +273,13 @@ fn parse_bracket_as_segments(input: TokenStream, scope: Span) -> Result<Vec<Segm
                 range.start += 1;
                 range.end -= 1;
             }
-            string.value = string.value[range].replace('-', "_");
+            // Only replace `-` with `_` in quoted string/char literal content.
+            // Numeric literals and bare `-` punct segments must not be altered.
+            string.value = if is_quoted {
+                string.value[range].replace('-', "_")
+            } else {
+                string.value[range].to_string()
+            };
         }
     }
 
@@ -291,6 +304,29 @@ fn pasted_to_tokens(mut pasted: String, span: Span) -> Result<TokenStream> {
         return Ok(tokens);
     }
 
+    if pasted.starts_with('-') {
+        let rest = &pasted[1..];
+        if rest.starts_with(|ch: char| ch.is_ascii_digit()) {
+            let mut minus = TokenTree::Punct(Punct::new('-', Spacing::Alone));
+            minus.set_span(span);
+            tokens.extend(iter::once(minus));
+            let literal = match panic::catch_unwind(|| Literal::from_str(rest)) {
+                Ok(Ok(mut literal)) => {
+                    literal.set_span(span);
+                    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);
diff --git a/src/segment.rs b/src/segment.rs
index 99804a1..1ee849e 100644
--- a/src/segment.rs
+++ b/src/segment.rs
@@ -136,6 +136,10 @@ pub(crate) fn parse(tokens: &mut Peekable<token_stream::IntoIter>) -> Result<Vec
                     value: "#".to_string(),
                     span: punct.span(),
                 })),
+                '-' => segments.push(Segment::String(LitStr {
+                    value: "-".to_owned(),
+                    span: punct.span(),
+                })),
                 _ => return Err(Error::new(punct.span(), "unexpected punct")),
             },
             TokenTree::Group(group) => {