tmp

src/lib.rs

@@ -53,6 +53,7 @@ pub mod types;
 
 mod lexer;
 mod tokens;
+mod writer;
 
 use lexer::lex;
 use tokens::LexedSlice;
@@ -118,7 +119,7 @@ pub trait Parse<'token>: Sized {
         Ok((unread, def))
     }
 
-    fn write(&self) -> String;
+    fn write<T: writer::MarkupCallback>(&self, callback: &T) -> T::ReturnType;
 }
 
 /// Parses WebIDL definitions. It is the root struct for a complete WebIDL definition.

src/literal.rs

@@ -1,7 +1,7 @@
 use nom::Parser;
 use weedle_derive::Weedle;
 
-use crate::{term::Token, Parse};
+use crate::{term::Token, Parse, writer::MarkupElement};
 
 /// Parses `-?[1-9][0-9]*`
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -68,14 +68,14 @@ impl<'a> IntegerLit<'a> {
 impl<'a> Parse<'a> for Token<'a, IntegerLit<'a>> {
     parser!(eat!(Integer));
 
-    fn write(&self) -> String {
+    fn write<T: crate::writer::MarkupCallback>(&self, callback: &T) -> T::ReturnType {
         let trivia = self.trivia;
         let variant = match self.value {
             IntegerLit::Dec(lit) => lit.0,
             IntegerLit::Hex(lit) => lit.0,
             IntegerLit::Oct(lit) => lit.0,
         };
-        format!("{trivia}{variant}")
+        T::ReturnType::wrap(&[T::ReturnType::new(trivia), T::ReturnType::new(variant)])
     }
 }
 

src/writer.rs

@@ -0,0 +1,24 @@
+use crate::Parsed;
+
+pub fn walk_markup<T: MarkupCallback>(parsed: &Parsed, callback: &T) -> T::ReturnType {
+    // TODO: Can't write() do the walk?
+    // Pass `Vec<dyn Parse>` to callbacks so that they can get the current tree ancestors
+    // Both webidl2.js and widlparser support construct-level markup but I don't think neither of ReSpec/bikeshed need it
+    // ReSpec: it's used but it doesn't really have to be a block?
+    // Let's just defer it as theoretically it's still possible to implement it later
+    for def in parsed.definitions.iter() {}
+}
+
+// TODO: I don't think this kind of fancy structure can work with Wasm... or can it?
+// take a look at wasm-bindgen
+
+pub trait MarkupElement : Sized {
+  fn new(s: &str) -> Self;
+  fn wrap(items: &[Self]) -> Self;
+}
+
+pub trait MarkupCallback {
+    type ReturnType: MarkupElement;
+
+    fn identifier(&self) -> Self::ReturnType;
+}