Initial commit for frontend

src/lib.rs

@@ -0,0 +1,146 @@
+use syn::{bracketed, parse::Parse, punctuated::Punctuated, token, Token};
+
+struct Command {
+    program: Program,
+    args: Option<Punctuated<Arg, Token![,]>>,
+}
+
+impl Parse for Command {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let program = input.parse()?;
+
+        if input.is_empty() {
+            Ok(Command {
+                program,
+                args: None,
+            })
+        } else {
+            _ = input.parse::<Token![,]>()?;
+            Ok(Command {
+                program,
+                args: Some(input.parse_terminated(Arg::parse, Token![,])?),
+            })
+        }
+    }
+}
+
+struct Program(syn::LitStr);
+
+impl Parse for Program {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        input.parse().map(Self)
+    }
+}
+
+enum Arg {
+    Expression(syn::Expr),
+    ForIter {
+        for_key: Token![for],
+        expr: syn::Expr,
+    },
+    ForInIterMulti {
+        for_iter: ForIter,
+        arrow_token: Token![=>],
+        args: MultiArg,
+    },
+    ForInIterSingle {
+        for_iter: ForIter,
+        arrow_token: Token![=>],
+        arg: SingleArg,
+    },
+    IfLetMulti {
+        if_let: IfLet,
+        arrow_token: Token![=>],
+        args: MultiArg,
+    },
+    IfLetSingle {
+        if_let: IfLet,
+        arrow_token: Token![=>],
+        arg: SingleArg,
+    },
+    IfMulti {
+        expr: syn::Expr,
+        arrow_token: Token![=>],
+        args: MultiArg,
+    },
+    IfSingle {
+        expr: syn::Expr,
+        arrow_token: Token![=>],
+        arg: SingleArg,
+    },
+}
+
+impl Parse for Arg {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        input.parse()
+    }
+}
+
+struct Pattern(syn::Pat);
+
+impl Parse for Pattern {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        input.call(syn::Pat::parse_single).map(Self)
+    }
+}
+
+struct ForIter {
+    for_token: Token![for],
+    pattern: Pattern,
+    in_token: Token![in],
+    iter: syn::Expr,
+}
+
+impl Parse for ForIter {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        Ok(ForIter {
+            for_token: input.parse()?,
+            pattern: input.parse()?,
+            in_token: input.parse()?,
+            iter: input.parse()?,
+        })
+    }
+}
+
+struct IfLet {
+    if_token: Token![if],
+    let_token: Token![let],
+    pattern: Pattern,
+    eq_token: Token![=],
+    expr: syn::Expr,
+}
+
+impl Parse for IfLet {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        Ok(IfLet {
+            if_token: input.parse()?,
+            let_token: input.parse()?,
+            pattern: input.parse()?,
+            eq_token: input.parse()?,
+            expr: input.parse()?,
+        })
+    }
+}
+
+struct SingleArg(syn::Expr);
+
+impl Parse for SingleArg {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        input.parse().map(Self)
+    }
+}
+
+struct MultiArg {
+    bracket: token::Bracket,
+    args: Punctuated<SingleArg, Token![,]>,
+}
+
+impl Parse for MultiArg {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let args;
+        Ok(MultiArg {
+            bracket: bracketed!(args in input),
+            args: input.parse_terminated(SingleArg::parse, Token![,])?,
+        })
+    }
+}