Replace DUMMY_SPAN with Span::Panic and Span::Rust

src/ast/expr.rs

@@ -130,24 +130,30 @@ impl ResolvedExpr {
     }
 }
 
-impl Expr {
-    pub fn call_no_span(op: impl Into<Symbol>, children: impl IntoIterator<Item = Self>) -> Self {
-        Self::Call(
-            DUMMY_SPAN.clone(),
-            op.into(),
-            children.into_iter().collect(),
-        )
-    }
+#[macro_export]
+macro_rules! call {
+    ($func:expr, $args:expr) => {
+        $crate::ast::GenericExpr::Call($crate::span!(), $func.into(), $args.into_iter().collect())
+    };
+}
 
-    pub fn lit_no_span(lit: impl Into<Literal>) -> Self {
-        Self::Lit(DUMMY_SPAN.clone(), lit.into())
-    }
+#[macro_export]
+macro_rules! lit {
+    ($lit:expr) => {
+        $crate::ast::GenericExpr::Lit($crate::span!(), $lit.into())
+    };
+}
 
-    pub fn var_no_span(v: impl Into<Symbol>) -> Self {
-        Self::Var(DUMMY_SPAN.clone(), v.into())
-    }
+#[macro_export]
+macro_rules! var {
+    ($var:expr) => {
+        $crate::ast::GenericExpr::Var($crate::span!(), $var.into())
+    };
 }
 
+// Rust macro annoyance; see stackoverflow.com/questions/26731243/how-do-i-use-a-macro-across-module-files
+pub use {call, lit, var};
+
 impl<Head: Clone + Display, Leaf: Hash + Clone + Display + Eq> GenericExpr<Head, Leaf> {
     pub fn span(&self) -> Span {
         match self {

src/ast/parse.rs

@@ -46,20 +46,54 @@ pub fn parse_expr(
 
 /// A [`Span`] contains the file name and a pair of offsets representing the start and the end.
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct Span(Arc<SrcFile>, usize, usize);
+pub enum Span {
+    /// Panics if a span is needed. Prefer `Span::Rust` (see `span!`)
+    /// unless this behaviour is explicitly desired.
+    Panic,
+    /// A span from a `.egg` file.
+    /// Constructed by `parse_program` and `parse_expr`.
+    Egglog(Arc<EgglogSpan>),
+    /// A span from a `.rs` file. Constructed by the `span!` macro.
+    Rust(Arc<RustSpan>),
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct EgglogSpan {
+    file: Arc<SrcFile>,
+    i: usize,
+    j: usize,
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct RustSpan {
+    pub file: &'static str,
+    pub line: u32,
+    pub column: u32,
+}
 
-lazy_static::lazy_static! {
-    pub static ref DUMMY_SPAN: Span = Span(Arc::new(SrcFile {name: None, contents: String::new()}), 0, 0);
+#[macro_export]
+macro_rules! span {
+    () => {
+        $crate::ast::Span::Rust(std::sync::Arc::new($crate::ast::RustSpan {
+            file: file!(),
+            line: line!(),
+            column: column!(),
+        }))
+    };
 }
 
 impl Span {
     pub fn string(&self) -> &str {
-        &self.0.contents[self.1..self.2]
+        match self {
+            Span::Panic => panic!("Span::Panic in Span::String"),
+            Span::Rust(_) => todo!(),
+            Span::Egglog(span) => &span.file.contents[span.i..span.j],
+        }
     }
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
-struct SrcFile {
+pub struct SrcFile {
     name: Option<String>,
     contents: String,
 }
@@ -70,7 +104,7 @@ struct Location {
 }
 
 impl SrcFile {
-    pub fn get_location(&self, offset: usize) -> Location {
+    fn get_location(&self, offset: usize) -> Location {
         let mut line = 1;
         let mut col = 1;
         for (i, c) in self.contents.char_indices() {
@@ -98,26 +132,36 @@ impl Debug for Span {
 
 impl Display for Span {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let start = self.0.get_location(self.1);
-        let end = self.0.get_location((self.2.saturating_sub(1)).max(self.1));
-        let quote = self.string();
-        match (&self.0.name, start.line == end.line) {
-            (Some(filename), true) => write!(
-                f,
-                "In {}:{}-{} of {filename}: {quote}",
-                start.line, start.col, end.col
-            ),
-            (Some(filename), false) => write!(
-                f,
-                "In {}:{}-{}:{} of {filename}: {quote}",
-                start.line, start.col, end.line, end.col
-            ),
-            (None, false) => write!(
-                f,
-                "In {}:{}-{}:{}: {quote}",
-                start.line, start.col, end.line, end.col
-            ),
-            (None, true) => write!(f, "In {}:{}-{}: {quote}", start.line, start.col, end.col),
+        match self {
+            Span::Panic => panic!("Span::Panic in impl Display"),
+            Span::Rust(span) => write!(f, "At {}:{} of {}", span.line, span.column, span.file),
+            Span::Egglog(span) => {
+                let start = span.file.get_location(span.i);
+                let end = span
+                    .file
+                    .get_location((span.j.saturating_sub(1)).max(span.i));
+                let quote = self.string();
+                match (&span.file.name, start.line == end.line) {
+                    (Some(filename), true) => write!(
+                        f,
+                        "In {}:{}-{} of {filename}: {quote}",
+                        start.line, start.col, end.col
+                    ),
+                    (Some(filename), false) => write!(
+                        f,
+                        "In {}:{}-{}:{} of {filename}: {quote}",
+                        start.line, start.col, end.line, end.col
+                    ),
+                    (None, false) => write!(
+                        f,
+                        "In {}:{}-{}:{}: {quote}",
+                        start.line, start.col, end.line, end.col
+                    ),
+                    (None, true) => {
+                        write!(f, "In {}:{}-{}: {quote}", start.line, start.col, end.col)
+                    }
+                }
+            }
         }
     }
 }
@@ -837,12 +881,16 @@ impl Context {
         self.index == self.source.contents.len()
     }
 
-    fn next(&mut self) -> Result<(Token, Span), ParseError> {
+    fn next(&mut self) -> Result<(Token, EgglogSpan), ParseError> {
         self.advance_past_whitespace();
-        let mut span = Span(self.source.clone(), self.index, self.index);
+        let mut span = EgglogSpan {
+            file: self.source.clone(),
+            i: self.index,
+            j: self.index,
+        };
 
         let Some(c) = self.current_char() else {
-            return error!(span, "unexpected end of file");
+            return error!(s(span), "unexpected end of file");
         };
         self.advance_char();
 
@@ -854,9 +902,9 @@ impl Context {
                 let mut string = String::new();
 
                 loop {
-                    span.2 = self.index;
+                    span.j = self.index;
                     match self.current_char() {
-                        None => return error!(span, "string is missing end quote"),
+                        None => return error!(s(span), "string is missing end quote"),
                         Some('"') if !in_escape => break,
                         Some('\\') if !in_escape => in_escape = true,
                         Some(c) => {
@@ -866,7 +914,7 @@ impl Context {
                                 (true, 't') => '\t',
                                 (true, '\\') => '\\',
                                 (true, c) => {
-                                    return error!(span, "unrecognized escape character {c}")
+                                    return error!(s(span), "unrecognized escape character {c}")
                                 }
                             });
                             in_escape = false;
@@ -891,13 +939,17 @@ impl Context {
             }
         };
 
-        span.2 = self.index;
+        span.j = self.index;
         self.advance_past_whitespace();
 
         Ok((token, span))
     }
 }
 
+fn s(span: EgglogSpan) -> Span {
+    Span::Egglog(Arc::new(span))
+}
+
 enum Token {
     Open,
     Close,
@@ -906,7 +958,7 @@ enum Token {
 }
 
 fn sexp(ctx: &mut Context) -> Result<Sexp, ParseError> {
-    let mut stack: Vec<(Span, Vec<Sexp>)> = vec![];
+    let mut stack: Vec<(EgglogSpan, Vec<Sexp>)> = vec![];
 
     loop {
         let (token, span) = ctx.next()?;
@@ -918,14 +970,15 @@ fn sexp(ctx: &mut Context) -> Result<Sexp, ParseError> {
             }
             Token::Close => {
                 if stack.is_empty() {
-                    return error!(span, "unexpected `)`");
+                    return error!(s(span), "unexpected `)`");
                 }
                 let (mut list_span, list) = stack.pop().unwrap();
-                list_span.2 = span.2;
-                Sexp::List(list, list_span)
+                list_span.j = span.j;
+                Sexp::List(list, s(list_span))
             }
-            Token::String(s) => Sexp::Literal(Literal::String(s), span),
+            Token::String(sym) => Sexp::Literal(Literal::String(sym), s(span)),
             Token::Other => {
+                let span = s(span);
                 let s = span.string();
 
                 if s == "true" {
@@ -980,8 +1033,8 @@ mod tests {
     }
 
     #[test]
-    fn dummy_span_display() {
-        assert_eq!(format!("{}", *super::DUMMY_SPAN), "In 1:1-1: ");
+    fn rust_span_display() {
+        assert_eq!(format!("{}", span!()), "At 1037:34 of src/ast/parse.rs");
     }
 
     #[test]

src/constraint.rs

@@ -1,17 +1,7 @@
 use crate::{
-    ast::{
-        GenericAction, GenericActions, GenericExpr, GenericFact, MappedAction, ResolvedAction,
-        ResolvedActions, ResolvedExpr, ResolvedFact, ResolvedVar,
-    },
-    core::{
-        Atom, AtomTerm, CoreAction, CoreRule, GenericCoreActions, Query, ResolvedCall, SymbolOrEq,
-    },
-    sort::I64Sort,
-    typechecking::TypeError,
-    util::{FreshGen, HashSet, SymbolGen},
-    ArcSort, CorrespondingVar, Span, Symbol, TypeInfo, DUMMY_SPAN,
+    core::{Atom, CoreAction, CoreRule, GenericCoreActions, Query, SymbolOrEq},
+    *,
 };
-use core::{hash::Hash, panic};
 // Use immutable hashmap for performance
 // cloning assignments is common and O(1) with immutable hashmap
 use im_rc::HashMap;
@@ -243,7 +233,7 @@ impl Assignment<AtomTerm, ArcSort> {
                 let ty = global_ty
                     .clone()
                     // Span is ignored when looking up atom_terms
-                    .or_else(|| self.get(&AtomTerm::Var(DUMMY_SPAN.clone(), *var)).cloned())
+                    .or_else(|| self.get(&AtomTerm::Var(Span::Panic, *var)).cloned())
                     .expect("All variables should be assigned before annotation");
                 ResolvedExpr::Var(
                     span.clone(),
@@ -271,7 +261,7 @@ impl Assignment<AtomTerm, ArcSort> {
                     .iter()
                     .map(|arg| arg.output_type())
                     .chain(once(
-                        self.get(&AtomTerm::Var(DUMMY_SPAN.clone(), *corresponding_var))
+                        self.get(&AtomTerm::Var(span.clone(), *corresponding_var))
                             .unwrap()
                             .clone(),
                     ))

src/extract.rs

@@ -33,9 +33,7 @@ impl EGraph {
     ///     )
     ///     .unwrap();
     /// let mut termdag = TermDag::default();
-    /// let (sort, value) = egraph
-    ///     .eval_expr(&egglog::ast::Expr::var_no_span("expr"))
-    ///     .unwrap();
+    /// let (sort, value) = egraph.eval_expr(&egglog::var!("expr")).unwrap();
     /// let (_, extracted) = egraph.extract(value, &mut termdag, &sort);
     /// assert_eq!(termdag.to_string(&extracted), "(Add 1 1)");
     /// ```

src/lib.rs

@@ -296,12 +296,12 @@ impl Primitive {
     fn accept(&self, tys: &[Arc<dyn Sort>], typeinfo: &TypeInfo) -> bool {
         let mut constraints = vec![];
         let lits: Vec<_> = (0..tys.len())
-            .map(|i| AtomTerm::Literal(DUMMY_SPAN.clone(), Literal::Int(i as i64)))
+            .map(|i| AtomTerm::Literal(Span::Panic, Literal::Int(i as i64)))
             .collect();
         for (lit, ty) in lits.iter().zip(tys.iter()) {
             constraints.push(Constraint::Assign(lit.clone(), ty.clone()))
         }
-        constraints.extend(self.get_type_constraints(&DUMMY_SPAN).get(&lits, typeinfo));
+        constraints.extend(self.get_type_constraints(&Span::Panic).get(&lits, typeinfo));
         let problem = Problem {
             constraints,
             range: HashSet::default(),
@@ -535,7 +535,7 @@ impl EGraph {
                 self.msgs = messages;
                 Ok(())
             }
-            None => Err(Error::Pop(DUMMY_SPAN.clone())),
+            None => Err(Error::Pop(span!())),
         }
     }
 
@@ -710,7 +710,7 @@ impl EGraph {
         let f = self
             .functions
             .get(&sym)
-            .ok_or(TypeError::UnboundFunction(sym, DUMMY_SPAN.clone()))?;
+            .ok_or(TypeError::UnboundFunction(sym, span!()))?;
         let schema = f.schema.clone();
         let nodes = f
             .nodes
@@ -796,7 +796,7 @@ impl EGraph {
             let f = self
                 .functions
                 .get(&sym)
-                .ok_or(TypeError::UnboundFunction(sym, DUMMY_SPAN.clone()))?;
+                .ok_or(TypeError::UnboundFunction(sym, span!()))?;
             log::info!("Function {} has size {}", sym, f.nodes.len());
             self.print_msg(f.nodes.len().to_string());
             Ok(())
@@ -1122,7 +1122,7 @@ impl EGraph {
 
     pub fn eval_expr(&mut self, expr: &Expr) -> Result<(ArcSort, Value), Error> {
         let fresh_name = self.parser.symbol_gen.fresh(&"egraph_evalexpr".into());
-        let command = Command::Action(Action::Let(DUMMY_SPAN.clone(), fresh_name, expr.clone()));
+        let command = Command::Action(Action::Let(expr.span(), fresh_name, expr.clone()));
         self.run_program(vec![command])?;
         // find the table with the same name as the fresh name
         let func = self.functions.get(&fresh_name).unwrap();
@@ -1373,7 +1373,7 @@ impl EGraph {
         let mut contents = String::new();
         f.read_to_string(&mut contents).unwrap();
 
-        let span: Span = DUMMY_SPAN.clone();
+        let span: Span = span!();
         let mut actions: Vec<Action> = vec![];
         let mut str_buf: Vec<&str> = vec![];
         for line in contents.lines() {
@@ -1508,8 +1508,8 @@ impl EGraph {
     }
 
     /// Add a user-defined sort
-    pub fn add_arcsort(&mut self, arcsort: ArcSort) -> Result<(), TypeError> {
-        self.type_info.add_arcsort(arcsort, DUMMY_SPAN.clone())
+    pub fn add_arcsort(&mut self, arcsort: ArcSort, span: Span) -> Result<(), TypeError> {
+        self.type_info.add_arcsort(arcsort, span)
     }
 
     /// Add a user-defined primitive