Add NodeName::Block

README.md

@@ -69,6 +69,7 @@ assert_eq!(nodes[0].children[0].value_as_string().unwrap(), "hi");
 - **Braced blocks are parsed as arbitrary Rust code**
 
   ```html
+  <{ let block = "in node name position"; } />
   <div>{ let block = "in node position"; }</div>
   <div { let block="in attribute position" ; } />
   <div key="{" let block="in attribute value position" ; } />

src/node.rs

@@ -45,14 +45,23 @@ pub struct Node {
 }
 
 impl Node {
-    /// Returns `String` if `name` is `Some`
+    /// Returns `String` if `name` is `Some` and not `NodeName::Block`
     pub fn name_as_string(&self) -> Option<String> {
         match self.name.as_ref() {
+            Some(NodeName::Block(_)) => None,
             Some(name) => Some(name.to_string()),
             None => None,
         }
     }
 
+    /// Returns `ExprBlock` if `name` is `NodeName::Block(Expr::Block)`
+    pub fn name_as_block(&self) -> Option<ExprBlock> {
+        match self.name.as_ref() {
+            Some(NodeName::Block(Expr::Block(expr))) => Some(expr.to_owned()),
+            _ => None,
+        }
+    }
+
     /// Returns `Span` if `name` is `Some`
     pub fn name_span(&self) -> Option<Span> {
         match self.name.as_ref() {
@@ -144,6 +153,9 @@ pub enum NodeName {
 
     /// Name separated by colons, e.g. `<div on:click={foo} />`
     Colon(Punctuated<Ident, Colon>),
+
+    /// Arbitrary rust code in braced `{}` blocks
+    Block(Expr),
 }
 
 impl NodeName {
@@ -153,6 +165,7 @@ impl NodeName {
             NodeName::Path(name) => name.span(),
             NodeName::Dash(name) => name.span(),
             NodeName::Colon(name) => name.span(),
+            NodeName::Block(name) => name.span(),
         }
     }
 }
@@ -180,6 +193,7 @@ impl fmt::Display for NodeName {
                     .map(|ident| ident.to_string())
                     .collect::<Vec<String>>()
                     .join(":"),
+                NodeName::Block(_) => String::from(""),
             }
         )
     }
@@ -200,6 +214,10 @@ impl PartialEq for NodeName {
                 Self::Colon(other) => this == other,
                 _ => false,
             },
+            Self::Block(this) => match other {
+                Self::Block(other) => this == other,
+                _ => false,
+            },
         }
     }
 }
@@ -210,6 +228,7 @@ impl ToTokens for NodeName {
             NodeName::Path(name) => name.to_tokens(tokens),
             NodeName::Dash(name) => name.to_tokens(tokens),
             NodeName::Colon(name) => name.to_tokens(tokens),
+            NodeName::Block(name) => name.to_tokens(tokens),
         }
     }
 }

src/parser.rs

@@ -508,6 +508,11 @@ impl Parser {
         } else if input.peek2(Dash) {
             self.node_name_punctuated_ident::<Dash, fn(_) -> Dash, Ident>(input, Dash)
                 .map(|ok| NodeName::Dash(ok))
+        } else if input.peek(Brace) {
+            let fork = &input.fork();
+            let value = self.block_expr(fork)?;
+            input.advance_to(fork);
+            Ok(NodeName::Block(value))
         } else if input.peek(Ident::peek_any) {
             let mut segments = Punctuated::new();
             let ident = Ident::parse_any(input)?;

tests/test.rs

@@ -81,6 +81,26 @@ fn test_path_as_tag_name() {
     assert_eq!(nodes[0].name_as_string().unwrap(), "some::path");
 }
 
+#[test]
+fn test_block_as_tag_name() {
+    let tokens = quote! {
+        <{some_logic(block)} />
+    };
+
+    let nodes = parse2(tokens).unwrap();
+    assert_eq!(nodes[0].name_as_block().is_some(), true);
+}
+
+#[test]
+fn test_block_as_tag_name_with_closing_tag() {
+    let tokens = quote! {
+        <{some_logic(block)}>"Test"</{some_logic(block)}>
+    };
+
+    let nodes = parse2(tokens).unwrap();
+    assert_eq!(nodes[0].name_as_block().is_some(), true);
+}
+
 #[test]
 fn test_dashed_attribute_name() {
     let tokens = quote! {