Merge pull request #497 from Alex-Fischman/sexp-parser

Make parser extensible

Author: Alex-Fischman

Cargo.lock

@@ -53,8 +53,6 @@ lazy_static = "1.4"
 num = "0.4.3"
 smallvec = "1.11"
 
-generic_symbolic_expressions = "5.0.4"
-
 egraph-serialize = { version = "0.2.0", default-features = false }
 
 # binary dependencies

Cargo.toml

@@ -6,12 +6,12 @@ use crate::*;
 /// makes rules into a SSA-like format (see [`NormFact`]).
 pub(crate) fn desugar_program(
     program: Vec<Command>,
-    symbol_gen: &mut SymbolGen,
+    parser: &mut Parser,
     seminaive_transform: bool,
 ) -> Result<Vec<NCommand>, Error> {
     let mut res = vec![];
     for command in program {
-        let desugared = desugar_command(command, symbol_gen, seminaive_transform)?;
+        let desugared = desugar_command(command, parser, seminaive_transform)?;
         res.extend(desugared);
     }
     Ok(res)
@@ -22,7 +22,7 @@ pub(crate) fn desugar_program(
 /// makes rules into a SSA-like format (see [`NormFact`]).
 pub(crate) fn desugar_command(
     command: Command,
-    symbol_gen: &mut SymbolGen,
+    parser: &mut Parser,
     seminaive_transform: bool,
 ) -> Result<Vec<NCommand>, Error> {
     let res = match command {
@@ -102,28 +102,28 @@ pub(crate) fn desugar_command(
 
             res
         }
-        Command::Rewrite(ruleset, rewrite, subsume) => {
-            desugar_rewrite(ruleset, rewrite_name(&rewrite).into(), &rewrite, subsume)
+        Command::Rewrite(ruleset, ref rewrite, subsume) => {
+            desugar_rewrite(ruleset, rule_name(&command), rewrite, subsume)
         }
-        Command::BiRewrite(ruleset, rewrite) => {
-            desugar_birewrite(ruleset, rewrite_name(&rewrite).into(), &rewrite)
+        Command::BiRewrite(ruleset, ref rewrite) => {
+            desugar_birewrite(ruleset, rule_name(&command), rewrite)
         }
         Command::Include(span, file) => {
             let s = std::fs::read_to_string(&file)
                 .unwrap_or_else(|_| panic!("{span} Failed to read file {file}"));
             return desugar_program(
-                parse_program(Some(file), &s)?,
-                symbol_gen,
+                parse_program(Some(file), &s, parser)?,
+                parser,
                 seminaive_transform,
             );
         }
         Command::Rule {
             ruleset,
             mut name,
-            rule,
+            ref rule,
         } => {
             if name == "".into() {
-                name = rule.to_string().replace('\"', "'").into();
+                name = rule_name(&command);
             }
 
             let result = vec![NCommand::NormRule {
@@ -144,7 +144,7 @@ pub(crate) fn desugar_command(
             span,
             expr,
             schedule,
-        } => desugar_simplify(&expr, &schedule, span, symbol_gen),
+        } => desugar_simplify(&expr, &schedule, span, parser),
         Command::RunSchedule(sched) => {
             vec![NCommand::RunSchedule(sched.clone())]
         }
@@ -171,9 +171,9 @@ pub(crate) fn desugar_command(
                 //       ((extract {fresh} {variants}))
                 //       :ruleset {fresh_ruleset})
                 // (run {fresh_ruleset} 1)
-                let fresh = symbol_gen.fresh(&"desugar_qextract_var".into());
-                let fresh_ruleset = symbol_gen.fresh(&"desugar_qextract_ruleset".into());
-                let fresh_rulename = symbol_gen.fresh(&"desugar_qextract_rulename".into());
+                let fresh = parser.symbol_gen.fresh(&"desugar_qextract_var".into());
+                let fresh_ruleset = parser.symbol_gen.fresh(&"desugar_qextract_ruleset".into());
+                let fresh_rulename = parser.symbol_gen.fresh(&"desugar_qextract_rulename".into());
                 let rule = Rule {
                     span: span.clone(),
                     body: vec![Fact::Eq(
@@ -218,7 +218,7 @@ pub(crate) fn desugar_command(
             vec![NCommand::Pop(span, num)]
         }
         Command::Fail(span, cmd) => {
-            let mut desugared = desugar_command(*cmd, symbol_gen, seminaive_transform)?;
+            let mut desugared = desugar_command(*cmd, parser, seminaive_transform)?;
 
             let last = desugared.pop().unwrap();
             desugared.push(NCommand::Fail(span, Box::new(last)));
@@ -322,10 +322,10 @@ fn desugar_simplify(
     expr: &Expr,
     schedule: &Schedule,
     span: Span,
-    symbol_gen: &mut SymbolGen,
+    parser: &mut Parser,
 ) -> Vec<NCommand> {
     let mut res = vec![NCommand::Push(1)];
-    let lhs = symbol_gen.fresh(&"desugar_simplify".into());
+    let lhs = parser.symbol_gen.fresh(&"desugar_simplify".into());
     res.push(NCommand::CoreAction(Action::Let(
         span.clone(),
         lhs,
@@ -339,7 +339,7 @@ fn desugar_simplify(
                 variants: 0,
                 expr: Expr::Var(span.clone(), lhs),
             },
-            symbol_gen,
+            parser,
             false,
         )
         .unwrap(),
@@ -349,6 +349,10 @@ fn desugar_simplify(
     res
 }
 
-pub(crate) fn rewrite_name(rewrite: &Rewrite) -> String {
-    rewrite.to_string().replace('\"', "'")
+pub fn rule_name<Head, Leaf>(command: &GenericCommand<Head, Leaf>) -> Symbol
+where
+    Head: Clone + Display,
+    Leaf: Clone + PartialEq + Eq + Hash + Display,
+{
+    command.to_string().replace('\"', "'").into()
 }

src/ast/desugar.rs

@@ -1,4 +1,3 @@
-use super::ToSexp;
 use crate::{core::ResolvedCall, *};
 use ordered_float::OrderedFloat;
 use std::{fmt::Display, hash::Hasher};
@@ -97,12 +96,6 @@ impl Display for ResolvedVar {
     }
 }
 
-impl ToSexp for ResolvedVar {
-    fn to_sexp(&self) -> Sexp {
-        Sexp::Symbol(self.name.to_string())
-    }
-}
-
 pub type Expr = GenericExpr<Symbol, Symbol>;
 /// A generated expression is an expression that is generated by the system
 /// and does not have annotations.
@@ -250,31 +243,18 @@ impl<Head: Clone + Display, Leaf: Hash + Clone + Display + Eq> GenericExpr<Head,
     }
 }
 
-impl<Head: Display, Leaf: Display> GenericExpr<Head, Leaf> {
-    /// Converts this expression into a
-    /// s-expression (symbolic expression).
-    /// Example: `(Add (Add 2 3) 4)`
-    pub fn to_sexp(&self) -> Sexp {
-        let res = match self {
-            GenericExpr::Lit(_ann, lit) => Sexp::Symbol(lit.to_string()),
-            GenericExpr::Var(_ann, v) => Sexp::Symbol(v.to_string()),
-            GenericExpr::Call(_ann, op, children) => Sexp::List(
-                vec![Sexp::Symbol(op.to_string())]
-                    .into_iter()
-                    .chain(children.iter().map(|c| c.to_sexp()))
-                    .collect(),
-            ),
-        };
-        res
-    }
-}
-
 impl<Head, Leaf> Display for GenericExpr<Head, Leaf>
 where
     Head: Display,
     Leaf: Display,
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.to_sexp())
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            GenericExpr::Lit(_ann, lit) => write!(f, "{lit}"),
+            GenericExpr::Var(_ann, var) => write!(f, "{var}"),
+            GenericExpr::Call(_ann, op, children) => {
+                write!(f, "({} {})", op, ListDisplay(children, " "))
+            }
+        }
     }
 }