Attribute AST

parser/src/ast.rs

@@ -17,6 +17,27 @@ pub enum TypePostfix {
     RefMut,
 }
 
+#[derive(Debug, Clone, Serialize)]
+pub struct Attribute {
+    pub path: StaticPath,
+    pub args: Vec<AttributeArg>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub enum AttributeArg {
+    Named(String, Literal),
+    Positional(Literal),
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub enum Literal {
+    String(String),
+    Int(i64),
+    Float(f64),
+    Bool(bool),
+    Tuple(Vec<Expression>),
+}
+
 #[derive(Debug, Clone, Serialize)]
 pub enum TypeExprKind {
     Path(StaticPath),
@@ -137,12 +158,8 @@ pub struct ForStmt {
 
 #[derive(Debug, Clone, Serialize)]
 pub enum Expression {
+    Literal(Literal),
     Path(StaticPath),
-    IntLiteral(i64),
-    FloatLiteral(f64),
-    BoolLiteral(bool),
-    StringLiteral(String),
-    TupleLiteral(Vec<Expression>),
     Fix {
         initial: Box<Expression>,
         prefixes: Vec<Prefix>,

parser/src/lib.rs

@@ -293,11 +293,19 @@ impl From<pest::iterators::Pair<'_, Rule>> for Expression {
             }
             Rule::primary => Expression::from(inner.next().unwrap()),
             Rule::static_path => Expression::Path(StaticPath::from(pair)),
-            Rule::integer => Expression::IntLiteral(pair.as_str().parse::<i64>().unwrap()),
-            Rule::float => Expression::FloatLiteral(pair.as_str().parse::<f64>().unwrap()),
-            Rule::boolean => Expression::BoolLiteral(pair.as_str().parse::<bool>().unwrap()),
-            Rule::string_lit => Expression::StringLiteral(inner.as_str().to_string()),
-            Rule::tuple => Expression::TupleLiteral(inner.map(Expression::from).collect()),
+            Rule::integer => {
+                Expression::Literal(Literal::Int(pair.as_str().parse::<i64>().unwrap()))
+            }
+            Rule::float => {
+                Expression::Literal(Literal::Float(pair.as_str().parse::<f64>().unwrap()))
+            }
+            Rule::boolean => {
+                Expression::Literal(Literal::Bool(pair.as_str().parse::<bool>().unwrap()))
+            }
+            Rule::string_lit => Expression::Literal(Literal::String(inner.as_str().to_string())),
+            Rule::tuple => {
+                Expression::Literal(Literal::Tuple(inner.map(Expression::from).collect()))
+            }
             _ => unimplemented!("{rule:#?}"),
         }
     }