handle formatting options

examples/hot_reload.rs

@@ -14,7 +14,7 @@ fn app(cx: Scope) -> Element {
             },
 
             p {
-                "High-Five counter: {count}",
+                "High-Five counter: {count.to_string():?}",
             }
 
             div {
@@ -53,9 +53,7 @@ fn app(cx: Scope) -> Element {
 
             textarea {
                 width: "90%",
-                 value:
+                value: rsx_code,
-                    rsx_code
-                 ,
                 oninput: move |evt| {
                     rsx_code.set(evt.value.clone());
                 },
@@ -86,7 +84,7 @@ fn Editable(cx: Scope<EditableProps>) -> Element {
         rsx_index.insert(
             CodeLocation {
                 file: r"examples\hot_reload.rs".to_string(),
-                line: 95,
+                line: 93,
                 column: 15,
             },
             code.clone(),
@@ -101,7 +99,7 @@ fn Editable(cx: Scope<EditableProps>) -> Element {
             },
 
             p {
-                "High-Five counter: {count}",
+                "High-Five counter: {count.to_string():?}",
             }
 
             div {

packages/core-macro/src/lib.rs

@@ -188,7 +188,8 @@ pub fn rsx(s: TokenStream) -> TokenStream {
             {
                 use dioxus_rsx_interperter::captuered_context::CapturedContextBuilder;
 
-                let captured = CapturedContextBuilder::from_call_body(body);
+                match CapturedContextBuilder::from_call_body(body) {
+                    Ok(captured) => {
                         quote::quote! {
                             {
                                 let __line_num = get_line_num();
@@ -223,6 +224,9 @@ pub fn rsx(s: TokenStream) -> TokenStream {
                         }
                         .into()
                     }
+                    Err(err) => err.into_compile_error().into(),
+                }
+            }
             #[cfg(not(feature = "hot_reload"))]
             body.to_token_stream().into()
         }

packages/rsx/Cargo.toml

@@ -9,8 +9,4 @@ license = "MIT/Apache-2.0"
 [dependencies]
 proc-macro2 = { version = "1.0" }
 syn = { version = "1.0", features = ["full", "extra-traits"] }
-quote = { version = "1.0", optional = true }
+quote = { version = "1.0" }
-
-[features]
-default = ["to_tokens"]
-to_tokens = ["quote"]

packages/rsx/src/component.rs

@@ -14,7 +14,6 @@
 use super::*;
 
 use proc_macro2::TokenStream as TokenStream2;
-#[cfg(feature = "to_tokens")]
 use quote::{quote, ToTokens, TokenStreamExt};
 use syn::{
     ext::IdentExt,
@@ -73,7 +72,6 @@ impl Parse for Component {
     }
 }
 
-#[cfg(feature = "to_tokens")]
 impl ToTokens for Component {
     fn to_tokens(&self, tokens: &mut TokenStream2) {
         let name = &self.name;

packages/rsx/src/element.rs

@@ -1,7 +1,6 @@
 use super::*;
 
 use proc_macro2::TokenStream as TokenStream2;
-#[cfg(feature = "to_tokens")]
 use quote::{quote, ToTokens, TokenStreamExt};
 use syn::{
     parse::{Parse, ParseBuffer, ParseStream},
@@ -159,7 +158,6 @@ impl Parse for Element {
     }
 }
 
-#[cfg(feature = "to_tokens")]
 impl ToTokens for Element {
     fn to_tokens(&self, tokens: &mut TokenStream2) {
         let name = &self.name;
@@ -218,7 +216,6 @@ pub struct ElementAttrNamed {
     pub attr: ElementAttr,
 }
 
-#[cfg(feature = "to_tokens")]
 impl ToTokens for ElementAttrNamed {
     fn to_tokens(&self, tokens: &mut TokenStream2) {
         let ElementAttrNamed { el_name, attr } = self;

packages/rsx/src/ifmt.rs

@@ -1,24 +1,60 @@
-#[cfg(feature = "to_tokens")]
+use proc_macro2::{Span, TokenStream};
-use ::quote::{quote, ToTokens};
+
-use ::std::ops::Not;
+use quote::{quote, ToTokens};
-use ::syn::{
+use syn::{
     parse::{Parse, ParseStream},
-    punctuated::Punctuated,
     *,
 };
-use proc_macro2::TokenStream;
 
-#[cfg(feature = "to_tokens")]
 pub fn format_args_f_impl(input: IfmtInput) -> Result<TokenStream> {
-    let IfmtInput {
+    // build format_literal
-        format_literal,
+    let mut format_literal = String::new();
-        positional_args,
+    let mut expr_counter = 0;
-        named_args,
+    for segment in input.segments.iter() {
-    } = input;
+        match segment {
+            Segment::Literal(s) => format_literal += &s,
+            Segment::Formatted {
+                format_args,
+                segment,
+            } => {
+                format_literal += "{";
+                match segment {
+                    FormattedSegment::Expr(_) => {
+                        format_literal += &expr_counter.to_string();
+                        expr_counter += 1;
+                    }
+                    FormattedSegment::Ident(ident) => {
+                        format_literal += &ident.to_string();
+                    }
+                }
+                format_literal += ":";
+                format_literal += format_args;
+                format_literal += "}";
+            }
+        }
+    }
 
-    let named_args = named_args.into_iter().map(|(ident, expr)| {
+    let positional_args = input.segments.iter().filter_map(|seg| {
-        quote! {
+        if let Segment::Formatted { segment, .. } = seg {
-            #ident = #expr
+            if let FormattedSegment::Expr(expr) = segment {
+                Some(expr)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    });
+
+    let named_args = input.segments.iter().filter_map(|seg| {
+        if let Segment::Formatted { segment, .. } = seg {
+            if let FormattedSegment::Ident(ident) = segment {
+                Some(quote! {#ident = #ident})
+            } else {
+                None
+            }
+        } else {
+            None
         }
     });
 
@@ -34,219 +70,102 @@ pub fn format_args_f_impl(input: IfmtInput) -> Result<TokenStream> {
 #[allow(dead_code)] // dumb compiler does not see the struct being used...
 #[derive(Debug)]
 pub struct IfmtInput {
-    pub format_literal: LitStr,
+    pub segments: Vec<Segment>,
-    pub positional_args: Vec<Expr>,
-    pub named_args: Vec<(Ident, Expr)>,
 }
 
 impl IfmtInput {
-    fn parse_segments(self) -> Result<Self> {
+    pub fn from_str(input: &str) -> Result<Self> {
-        let IfmtInput {
+        let mut chars = input.chars().peekable();
-            mut format_literal,
+        let mut segments = Vec::new();
-            mut positional_args,
+        let mut current_literal = String::new();
-            mut named_args,
+        while let Some(c) = chars.next() {
-        } = self;
+            if c == '{' {
-
+                if let Some(c) = chars.next_if(|c| *c == '{') {
-        let s = format_literal.value();
+                    current_literal.push(c);
-        let out_format_literal = &mut String::with_capacity(s.len());
-
-        let mut iterator = s.char_indices().peekable();
-        while let Some((i, c)) = iterator.next() {
-            out_format_literal.push(c);
-            if c != '{' {
                     continue;
                 }
-            // encountered `{`, let's see if it was `{{`
+                segments.push(Segment::Literal(current_literal));
-            if let Some(&(_, '{')) = iterator.peek() {
+                current_literal = String::new();
-                let _ = iterator.next();
+                let mut current_captured = String::new();
-                out_format_literal.push('{');
+                while let Some(c) = chars.next() {
-                continue;
+                    if c == ':' {
-            }
+                        let mut current_format_args = String::new();
-            let (end, colon_or_closing_brace) = iterator
+                        while let Some(c) = chars.next() {
-                .find(|&(_, c)| c == '}' || c == ':')
+                            if c == '}' {
-                .expect(concat!(
+                                segments.push(Segment::Formatted {
-                    "Invalid format string literal\n",
+                                    format_args: current_format_args,
-                    "note: if you intended to print `{`, ",
+                                    segment: FormattedSegment::parse(&current_captured)?,
-                    "you can escape it using `{{`",
-                ));
-            // We use defer to ensure all the `continue`s append the closing char.
-            let mut out_format_literal = defer(&mut *out_format_literal, |it| {
-                it.push(colon_or_closing_brace)
                                 });
-            let out_format_literal: &mut String = *out_format_literal;
+                                break;
-            let mut arg = s[i + 1..end].trim();
+                            }
-            if let Some("=") = arg.get(arg.len().saturating_sub(1)..) {
+                            current_format_args.push(c);
-                assert_eq!(
+                        }
-                    out_format_literal.pop(), // Remove the opening brace
+                        break;
-                    Some('{'),
+                    }
-                );
+                    if c == '}' {
-                arg = &arg[..arg.len() - 1];
+                        segments.push(Segment::Formatted {
-                out_format_literal.push_str(arg);
+                            format_args: String::new(),
-                out_format_literal.push_str(" = {");
+                            segment: FormattedSegment::parse(&current_captured)?,
+                        });
+                        break;
+                    }
+                    current_captured.push(c);
+                }
+            } else {
+                current_literal.push(c);
+            }
+        }
+        segments.push(Segment::Literal(current_literal));
+        Ok(Self { segments })
     }
-            if arg.is_empty() {
-                continue;
 }
 
 #[derive(Debug)]
-            enum Segment {
+pub enum Segment {
+    Literal(String),
+    Formatted {
+        format_args: String,
+        segment: FormattedSegment,
+    },
+}
+
+#[derive(Debug)]
+pub enum FormattedSegment {
+    Expr(Expr),
     Ident(Ident),
-                LitInt(LitInt),
 }
-            let segments: Vec<Segment> = {
+
-                impl Parse for Segment {
+impl FormattedSegment {
-                    fn parse(input: ParseStream<'_>) -> Result<Self> {
+    fn parse(input: &str) -> Result<Self> {
-                        let lookahead = input.lookahead1();
+        if let Ok(ident) = parse_str::<Ident>(input) {
-                        if lookahead.peek(Ident) {
+            if &ident.to_string() == input {
-                            input.parse().map(Segment::Ident)
+                return Ok(Self::Ident(ident));
-                        } else if lookahead.peek(LitInt) {
+            }
-                            input.parse().map(Segment::LitInt)
+        }
+        if let Ok(expr) = parse_str(&("{".to_string() + input + "}")) {
+            Ok(Self::Expr(expr))
         } else {
-                            Err(lookahead.error())
+            Err(Error::new(
+                Span::call_site(),
+                "Expected Ident or Expression",
+            ))
         }
     }
 }
-                match ::syn::parse::Parser::parse_str(
-                    Punctuated::<Segment, Token![.]>::parse_separated_nonempty,
-                    arg,
-                ) {
-                    Ok(segments) => segments.into_iter().collect(),
-                    Err(err) => return Err(err),
-                }
-            };
-            match segments.len() {
-                0 => unreachable!("`parse_separated_nonempty` returned empty"),
-                1 => {
-                    out_format_literal.push_str(arg);
-                    match { segments }.pop().unwrap() {
-                        Segment::LitInt(_) => {
-                            // found something like `{0}`, let `format_args!`
-                            // handle it.
-                            continue;
-                        }
-                        Segment::Ident(ident) => {
-                            // if `ident = ...` is not yet among the extra args
-                            if named_args.iter().all(|(it, _)| *it != ident) {
-                                named_args.push((
-                                    ident.clone(),
-                                    parse_quote!(#ident), // Expr
-                                ));
-                            }
-                        }
-                    }
-                }
-                _ => {
-                    ::std::fmt::Write::write_fmt(
-                        out_format_literal,
-                        format_args!("{}", positional_args.len()),
-                    )
-                    .expect("`usize` or `char` Display impl cannot panic");
-                    let segments: Punctuated<TokenStream, Token![.]> = segments
-                        .into_iter()
-                        .map(|it| match it {
-                            Segment::Ident(ident) => ident.into_token_stream(),
-                            Segment::LitInt(literal) => literal.into_token_stream(),
-                        })
-                        .collect();
-                    positional_args.push(parse_quote! {
-                        #segments
-                    })
-                }
-            }
-        }
-        format_literal = LitStr::new(out_format_literal, format_literal.span());
-
-        Ok(Self {
-            format_literal,
-            positional_args,
-            named_args,
-        })
-    }
 
-    fn parse_positional_args(input: ParseStream) -> Result<Self> {
+impl ToTokens for FormattedSegment {
-        let format_literal = input.parse()?;
+    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let mut positional_args = vec![];
+        match self {
-        loop {
+            Self::Expr(expr) => expr.to_tokens(tokens),
-            if input.parse::<Option<Token![,]>>()?.is_none() {
+            Self::Ident(ident) => ident.to_tokens(tokens),
-                return Ok(Self {
-                    format_literal,
-                    positional_args,
-                    named_args: vec![],
-                });
         }
-            if input.peek(Ident) && input.peek2(Token![=]) && input.peek3(Token![=]).not() {
-                // Found a positional parameter
-                break;
-            }
-            positional_args.push(input.parse()?);
-        }
-        let named_args = Punctuated::<_, Token![,]>::parse_terminated_with(input, |input| {
-            Ok({
-                let name: Ident = input.parse()?;
-                let _: Token![=] = input.parse()?;
-                let expr: Expr = input.parse()?;
-                (name, expr)
-            })
-        })?
-        .into_iter()
-        .collect();
-
-        Ok(Self {
-            format_literal,
-            positional_args,
-            named_args,
-        })
     }
 }
 
 impl Parse for IfmtInput {
     fn parse(input: ParseStream) -> Result<Self> {
-        Self::parse_positional_args(input).and_then(|new| new.parse_segments())
+        let input: LitStr = input.parse()?;
+        let input_str = input.value();
+        IfmtInput::from_str(&input_str)
     }
 }
-
-pub fn defer<'a, T: 'a, Drop: 'a>(x: T, drop: Drop) -> impl ::core::ops::DerefMut<Target = T> + 'a
-where
-    Drop: FnOnce(T),
-{
-    use ::core::mem::ManuallyDrop;
-    struct Ret<T, Drop>(ManuallyDrop<T>, ManuallyDrop<Drop>)
-    where
-        Drop: FnOnce(T);
-    impl<T, Drop> ::core::ops::Drop for Ret<T, Drop>
-    where
-        Drop: FnOnce(T),
-    {
-        fn drop(&'_ mut self) {
-            use ::core::ptr;
-            unsafe {
-                // # Safety
-                //
-                //   - This is the canonical example of using `ManuallyDrop`.
-                let value = ManuallyDrop::into_inner(ptr::read(&self.0));
-                let drop = ManuallyDrop::into_inner(ptr::read(&self.1));
-                drop(value);
-            }
-        }
-    }
-    impl<T, Drop> ::core::ops::Deref for Ret<T, Drop>
-    where
-        Drop: FnOnce(T),
-    {
-        type Target = T;
-        #[inline]
-        fn deref(&'_ self) -> &'_ Self::Target {
-            &self.0
-        }
-    }
-    impl<T, Drop> ::core::ops::DerefMut for Ret<T, Drop>
-    where
-        Drop: FnOnce(T),
-    {
-        #[inline]
-        fn deref_mut(&'_ mut self) -> &'_ mut Self::Target {
-            &mut self.0
-        }
-    }
-    Ret(ManuallyDrop::new(x), ManuallyDrop::new(drop))
-}

packages/rsx/src/node.rs

@@ -1,7 +1,6 @@
 use super::*;
 
 use proc_macro2::TokenStream as TokenStream2;
-#[cfg(feature = "to_tokens")]
 use quote::{quote, ToTokens, TokenStreamExt};
 use syn::{
     parse::{Parse, ParseStream},
@@ -79,7 +78,6 @@ impl Parse for BodyNode {
     }
 }
 
-#[cfg(feature = "to_tokens")]
 impl ToTokens for BodyNode {
     fn to_tokens(&self, tokens: &mut TokenStream2) {
         match &self {

packages/rsx_interperter/src/captuered_context.rs

@@ -1,8 +1,10 @@
 use dioxus_core::{Listener, VNode};
-use dioxus_rsx::{BodyNode, CallBody, Component, ElementAttr, ElementAttrNamed, IfmtInput};
+use dioxus_rsx::{
+    BodyNode, CallBody, Component, ElementAttr, ElementAttrNamed, IfmtInput, Segment,
+};
 use quote::{quote, ToTokens, TokenStreamExt};
 use std::collections::HashMap;
-use syn::Expr;
+use syn::{Expr, Result};
 
 #[derive(Default)]
 pub struct CapturedContextBuilder {
@@ -24,15 +26,15 @@ impl CapturedContextBuilder {
         self.captured_expressions.extend(other.captured_expressions);
     }
 
-    pub fn from_call_body(body: CallBody) -> Self {
+    pub fn from_call_body(body: CallBody) -> Result<Self> {
         let mut new = Self::default();
         for node in body.roots {
-            new.extend(Self::find_captured(node));
+            new.extend(Self::find_captured(node)?);
         }
-        new
+        Ok(new)
     }
 
-    fn find_captured(node: BodyNode) -> Self {
+    fn find_captured(node: BodyNode) -> Result<Self> {
         let mut captured = CapturedContextBuilder::default();
         match node {
             BodyNode::Element(el) => {
@@ -40,7 +42,7 @@ impl CapturedContextBuilder {
                     match attr.attr {
                         ElementAttr::AttrText { name, value } => {
                             let (name, value_tokens) = (name.to_string(), value.to_token_stream());
-                            let formated: IfmtInput = syn::parse2(value_tokens).unwrap();
+                            let formated: IfmtInput = syn::parse2(value_tokens)?;
                             captured.attributes.insert(name, formated);
                         }
                         ElementAttr::AttrExpression { name: _, value } => {
@@ -48,7 +50,7 @@ impl CapturedContextBuilder {
                         }
                         ElementAttr::CustomAttrText { name, value } => {
                             let (name, value_tokens) = (name.value(), value.to_token_stream());
-                            let formated: IfmtInput = syn::parse2(value_tokens).unwrap();
+                            let formated: IfmtInput = syn::parse2(value_tokens)?;
                             captured.attributes.insert(name, formated);
                         }
                         ElementAttr::CustomAttrExpression { name: _, value } => {
@@ -58,7 +60,7 @@ impl CapturedContextBuilder {
                     }
                 }
                 for child in el.children {
-                    captured.extend(Self::find_captured(child));
+                    captured.extend(Self::find_captured(child)?);
                 }
             }
             BodyNode::Component(comp) => {
@@ -71,7 +73,7 @@ impl CapturedContextBuilder {
             }
             BodyNode::RawExpr(_) => captured.iterators.push(node),
         }
-        captured
+        Ok(captured)
     }
 }
 
@@ -95,34 +97,41 @@ impl ToTokens for CapturedContextBuilder {
             BodyNode::RawExpr(expr) => expr.to_token_stream().to_string(),
             _ => unreachable!(),
         });
-        let captured_named: Vec<_> = attributes
+        let captured: Vec<_> = attributes
-            .iter()
+            .values()
-            .map(|(_, fmt)| fmt.named_args.iter())
+            .chain(text.iter())
-            .chain(text.iter().map(|fmt| fmt.named_args.iter()))
+            .map(|input| input.segments.iter())
             .flatten()
+            .filter_map(|seg| match seg {
+                Segment::Formatted {
+                    format_args,
+                    segment,
+                } => {
+                    let expr = segment.to_token_stream();
+                    let as_string = expr.to_string();
+                    let format_expr = if format_args.is_empty() {
+                        "{".to_string() + format_args + "}"
+                    } else {
+                        "{".to_string() + ":" + format_args + "}"
+                    };
+                    Some(quote! {
+                        FormattedArg{
+                            expr: #as_string,
+                            format_args: #format_args,
+                            result: format!(#format_expr, #expr)
+                        }
+                    })
+                }
+                _ => None,
+            })
             .collect();
-        let captured_expr: Vec<_> = attributes
-            .iter()
-            .map(|(_, fmt)| fmt.positional_args.iter())
-            .chain(text.iter().map(|fmt| fmt.positional_args.iter()))
-            .flatten()
-            .collect();
-        let captured_names = captured_named.iter().map(|(n, _)| n.to_string()).chain(
-            captured_expr
-                .iter()
-                .map(|expr| expr.to_token_stream().to_string()),
-        );
-        let captured_expr = captured_named
-            .iter()
-            .map(|(_, e)| e)
-            .chain(captured_expr.iter().map(|expr| *expr));
         let captured_attr_expressions_text = captured_expressions
             .iter()
             .map(|e| format!("{}", e.to_token_stream()));
         tokens.append_all(quote! {
             CapturedContext {
                 captured: IfmtArgs{
-                    named_args: vec![#((#captured_names, #captured_expr.to_string())),*]
+                    named_args: vec![#(#captured),*]
                 },
                 components: vec![#((#compontents_str, #components)),*],
                 iterators: vec![#((#iterators_str, #iterators)),*],
@@ -149,6 +158,12 @@ pub struct CapturedContext<'a> {
 }
 
 pub struct IfmtArgs {
-    // live reload only supports named arguments
+    // map expressions to the value string they produced
-    pub named_args: Vec<(&'static str, String)>,
+    pub named_args: Vec<FormattedArg>,
+}
+
+pub struct FormattedArg {
+    pub expr: &'static str,
+    pub format_args: &'static str,
+    pub result: String,
 }

packages/rsx_interperter/src/interperter.rs

@@ -1,7 +1,6 @@
 use dioxus_core::{Attribute, AttributeValue, NodeFactory, VNode};
-use dioxus_rsx::{BodyNode, CallBody, ElementAttr};
+use dioxus_rsx::{BodyNode, CallBody, ElementAttr, IfmtInput, Segment};
 use quote::ToTokens;
-use std::str::FromStr;
 use syn::{parse2, parse_str, Expr};
 
 use crate::attributes::attrbute_to_static_str;
@@ -9,28 +8,31 @@ use crate::captuered_context::{CapturedContext, IfmtArgs};
 use crate::elements::element_to_static_str;
 use crate::error::{Error, RecompileReason};
 
-#[derive(Debug)]
+struct InterpertedIfmt(IfmtInput);
-enum Segment {
-    Ident(String),
-    Literal(String),
-}
 
-struct InterperedIfmt {
+impl InterpertedIfmt {
-    segments: Vec<Segment>,
-}
-
-impl InterperedIfmt {
     fn resolve(&self, captured: &IfmtArgs) -> String {
         let mut result = String::new();
-        for seg in &self.segments {
+        for seg in &self.0.segments {
             match seg {
-                Segment::Ident(name) => {
+                Segment::Formatted {
-                    let (_, value) = captured
+                    segment,
+                    format_args,
+                } => {
+                    let expr = segment.to_token_stream();
+                    let expr_str = expr.to_string();
+                    let expr: Expr = parse2(expr).unwrap();
+                    let formatted = captured
                         .named_args
                         .iter()
-                        .find(|(n, _)| *n == name)
+                        .find(|fmted| {
-                        .expect(format!("could not resolve {}", name).as_str());
+                            parse_str::<Expr>(fmted.expr).unwrap() == expr
-                    result.push_str(value);
+                                && fmted.format_args == format_args
+                        })
+                        .expect(
+                            format!("could not resolve {{{}:{}}}", expr_str, format_args).as_str(),
+                        );
+                    result.push_str(&formatted.result);
                 }
                 Segment::Literal(lit) => result.push_str(lit),
             }
@@ -39,52 +41,6 @@ impl InterperedIfmt {
     }
 }
 
-impl FromStr for InterperedIfmt {
-    type Err = ();
-    fn from_str(input: &str) -> Result<Self, ()> {
-        let mut segments = Vec::new();
-        let mut segment = String::new();
-        let mut chars = input.chars().peekable();
-        while let Some(c) = chars.next() {
-            if c == '{' {
-                if chars.peek().copied() != Some('{') {
-                    let old;
-                    (old, segment) = (segment, String::new());
-                    if !old.is_empty() {
-                        segments.push(Segment::Literal(old));
-                    }
-                    while let Some(c) = chars.next() {
-                        if c == '}' {
-                            let old;
-                            (old, segment) = (segment, String::new());
-                            if !old.is_empty() {
-                                segments.push(Segment::Ident(old));
-                            }
-                            break;
-                        }
-                        if c == ':' {
-                            while Some('}') != chars.next() {}
-                            let old;
-                            (old, segment) = (segment, String::new());
-                            if !old.is_empty() {
-                                segments.push(Segment::Ident(old));
-                            }
-                            break;
-                        }
-                        segment.push(c);
-                    }
-                }
-            } else {
-                segment.push(c);
-            }
-        }
-        if !segment.is_empty() {
-            segments.push(Segment::Literal(segment));
-        }
-        Ok(Self { segments })
-    }
-}
-
 pub fn build<'a>(
     rsx: CallBody,
     mut ctx: CapturedContext<'a>,
@@ -105,7 +61,9 @@ fn build_node<'a>(
     let bump = factory.bump();
     match node {
         BodyNode::Text(text) => {
-            let ifmt: InterperedIfmt = text.value().parse().unwrap();
+            let ifmt = InterpertedIfmt(
+                IfmtInput::from_str(&text.value()).map_err(|err| Error::ParseError(err))?,
+            );
             let text = bump.alloc(ifmt.resolve(&ctx.captured));
             Ok(factory.text(format_args!("{}", text)))
         }
@@ -114,13 +72,21 @@ fn build_node<'a>(
             for attr in &el.attributes {
                 match &attr.attr {
                     ElementAttr::AttrText { .. } | ElementAttr::CustomAttrText { .. } => {
-                        let (name, value): (String, InterperedIfmt) = match &attr.attr {
+                        let (name, value): (String, InterpertedIfmt) = match &attr.attr {
-                            ElementAttr::AttrText { name, value } => {
+                            ElementAttr::AttrText { name, value } => (
-                                (name.to_string(), value.value().parse().unwrap())
+                                name.to_string(),
-                            }
+                                InterpertedIfmt(
-                            ElementAttr::CustomAttrText { name, value } => {
+                                    IfmtInput::from_str(&value.value())
-                                (name.value(), value.value().parse().unwrap())
+                                        .map_err(|err| Error::ParseError(err))?,
-                            }
+                                ),
+                            ),
+                            ElementAttr::CustomAttrText { name, value } => (
+                                name.value(),
+                                InterpertedIfmt(
+                                    IfmtInput::from_str(&value.value())
+                                        .map_err(|err| Error::ParseError(err))?,
+                                ),
+                            ),
                             _ => unreachable!(),
                         };
 
@@ -145,7 +111,6 @@ fn build_node<'a>(
                             ElementAttr::CustomAttrExpression { name, value } => {
                                 (name.value(), value)
                             }
-
                             _ => unreachable!(),
                         };
                         if let Some((_, resulting_value)) = ctx
@@ -219,7 +184,9 @@ fn build_node<'a>(
                         None,
                     )),
                     Some(lit) => {
-                        let ifmt: InterperedIfmt = lit.value().parse().unwrap();
+                        let ifmt: InterpertedIfmt = InterpertedIfmt(
+                            parse_str(&lit.value()).map_err(|err| Error::ParseError(err))?,
+                        );
                         let key = bump.alloc(ifmt.resolve(&ctx.captured));
 
                         Ok(factory.raw_element(

src/lib.rs

@@ -61,7 +61,7 @@ pub mod prelude {
 
     #[cfg(feature = "hot_reload")]
     pub use dioxus_rsx_interperter::{
-        captuered_context::{CapturedContext, IfmtArgs},
+        captuered_context::{CapturedContext, FormattedArg, IfmtArgs},
         get_line_num, interpert_rsx, with_hot_reload, CodeLocation, RsxTextIndex,
     };
 }