Merge pull request #10 from Jules-Bertholet/clone-war

Some more refactorings
COMBINE-lab · Jan 15, 2024 · a937a74 · a937a74
2 parents 9be5d80 + 243daff
commit a937a74
Show file tree

Hide file tree

Showing 17 changed files with 846 additions and 1,038 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,3 +24,9 @@ clap = { version = "4.4.8", features = ["derive"] }
 assert_cmd = "2.0.12"
 similar-asserts = "1.5.0"
 tempdir = "0.3.7"
+
+[lints.rust]
+rust_2018_idioms = "warn"
+
+[lints.clippy]
+semicolon_if_nothing_returned = "warn"
diff --git a/src/bin/bin.rs b/src/bin/bin.rs
@@ -40,7 +40,7 @@ pub struct Args {
     additional: Vec<String>,
 }
 
-pub fn interpret(args: Args, compiled_data: CompiledData) {
+pub fn interpret(args: Args, compiled_data: &CompiledData) {
     let Args {
         geom: _,
         file1,
@@ -57,7 +57,7 @@ pub fn interpret(args: Args, compiled_data: CompiledData) {
 
     let read = compiled_data.interpret(read, &out1, &out2, &additional);
 
-    read.run_with_threads(threads)
+    read.run_with_threads(threads);
 }
 
 fn main() {
@@ -67,19 +67,19 @@ fn main() {
 
     let (tokens, mut errs) = lexer::lexer().parse_recovery(&*geom);
 
-    let parse_errs = if let Some(tokens) = &tokens {
+    let parse_errs = if let Some(tokens) = tokens {
         let (ast, parse_errs) = parser().parse_recovery(Stream::from_iter(
             tokens.len()..tokens.len() + 1,
-            tokens.clone().into_iter(),
+            tokens.into_iter(),
         ));
 
-        if let Some((ast, _)) = &ast {
-            let res = compile(ast.clone());
+        if let Some(ast) = ast {
+            let res = compile(ast);
 
             if let Err(e) = res {
                 errs.push(Simple::custom(e.span, e.msg));
             } else {
-                interpret(args, res.ok().unwrap());
+                interpret(args, &res.ok().unwrap());
             }
         };
 
@@ -157,5 +157,5 @@ fn main() {
             };
 
             report.finish().print(Source::from(&geom)).unwrap();
-        })
+        });
 }
diff --git a/src/geometry/compile/definitions.rs b/src/geometry/compile/definitions.rs
@@ -1,22 +1,23 @@
-use super::{
-    functions::{compile_fn, CompiledFunction},
-    utils::*,
-};
-
-use std::{collections::HashMap, ops::Deref};
+use std::collections::HashMap;
 
-use crate::parser::{Expr, Spanned};
+use crate::{
+    compile::{
+        functions::{compile_fn, CompiledFunction},
+        utils::*,
+    },
+    parser::{Definition, Expr},
+    S,
+};
 
-// validate definitions there should be no labels, just labeled geom peices and functions
-fn validate_definition(expr: Spanned<Expr>, label: &str) -> Result<GeometryMeta, Error> {
-    let mut stack: Vec<Spanned<CompiledFunction>> = vec![];
-    let mut expr = expr;
+/// validate definitions there should be no labels, just labeled geom peices and functions
+fn validate_definition(mut expr: S<Expr>, label: &str) -> Result<GeometryMeta, Error> {
+    let mut stack: Vec<S<CompiledFunction>> = vec![];
 
     loop {
         match expr.0 {
             Expr::Function(fn_, gp) => {
                 // parse the function and validate it
-                expr = gp.deref().clone();
+                expr = gp.unboxed();
                 stack.push(compile_fn(fn_, expr.clone())?); // here is where we can compile the functions
             }
             Expr::Label(_) => {
@@ -29,8 +30,8 @@ fn validate_definition(expr: Spanned<Expr>, label: &str) -> Result<GeometryMeta,
         }
     }
 
-    let gp = if let (Expr::GeomPiece(type_, size), span) = expr {
-        (
+    let gp = if let S(Expr::GeomPiece(type_, size), span) = expr {
+        S(
             GeometryPiece {
                 type_,
                 size,
@@ -44,56 +45,41 @@ fn validate_definition(expr: Spanned<Expr>, label: &str) -> Result<GeometryMeta,
 
     let gp = GeometryMeta { expr: gp, stack };
 
-    validate_expr(gp)
+    gp.validate_expr().map(|()| gp)
 }
 
-pub fn compile_definitions(expr: Spanned<Expr>) -> Result<HashMap<String, GeometryMeta>, Error> {
-    let (expr, expr_span) = expr;
+pub fn compile_definitions(
+    S(defs, _): S<Vec<S<Definition>>>,
+) -> Result<HashMap<String, GeometryMeta>, Error> {
+    let mut map = HashMap::new();
 
-    if let Expr::Definitions(defs) = expr {
-        let mut map = HashMap::new();
+    let mut err: Option<Error> = None;
 
-        let mut err: Option<Error> = None;
-
-        for (def, def_span) in defs {
-            if let Expr::LabeledGeomPiece(label, expr) = def.clone() {
-                let expr = expr.deref().clone();
-                let label = label.deref().clone();
-
-                if let Expr::Label((l, span)) = label {
-                    let res = validate_definition(expr.clone(), &l);
-                    if let Err(e) = res {
-                        err = Some(e);
-                        break;
-                    } else if map.insert(l.clone(), res.ok().unwrap()).is_some() {
-                        err = Some(Error {
-                            // span labels
-                            span,
-                            msg: format!(
-                                "Repeated label in definition block: \"{}\" already defined",
-                                l
-                            ),
-                        });
-                        break;
-                    }
-                } else {
-                    err = Some(Error {
-                        span: def_span,
-                        msg: format!("Expected a Labeled Geometry piece, found: {}", def),
-                    })
-                }
-            }
-        }
-
-        if let Some(e) = err {
-            return Err(e);
+    for S(
+        Definition {
+            label: S(label_str, label_span),
+            expr,
+        },
+        _,
+    ) in defs
+    {
+        let res = validate_definition(expr, &label_str);
+        if let Err(e) = res {
+            err = Some(e);
+            break;
+        } else if map.insert(label_str.clone(), res.ok().unwrap()).is_some() {
+            err = Some(Error {
+                // span labels
+                span: label_span,
+                msg: format!("Repeated label in definition block: \"{label_str}\" already defined"),
+            });
+            break;
         }
+    }
 
-        Ok(map)
-    } else {
-        Err(Error {
-            span: expr_span,
-            msg: format!("Expected a definition block, found: {}", expr),
-        })
+    if let Some(e) = err {
+        return Err(e);
     }
+
+    Ok(map)
 }
diff --git a/src/geometry/compile/functions.rs b/src/geometry/compile/functions.rs
@@ -4,15 +4,12 @@
 //! expressions with label references a seperate
 //! place for this to happen will be useful
 
-use std::ops::Deref;
-
 use crate::{
-    parser::{Expr, Function, Spanned},
-    Nucleotide,
+    compile::utils::{Error, GeometryMeta, GeometryPiece},
+    parser::{Expr, Function},
+    Nucleotide, S,
 };
 
-use super::utils::{validate_expr, Error, GeometryMeta, GeometryPiece};
-
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum CompiledFunction {
     Reverse,
@@ -27,18 +24,16 @@ pub enum CompiledFunction {
     PadTo(usize, Nucleotide),
     PadToLeft(usize, Nucleotide),
     Normalize,
-    Map(String, Vec<Spanned<CompiledFunction>>),
-    MapWithMismatch(String, Vec<Spanned<CompiledFunction>>, usize),
+    Map(String, Vec<S<CompiledFunction>>),
+    MapWithMismatch(String, Vec<S<CompiledFunction>>, usize),
     FilterWithinDist(String, usize),
     Hamming(usize),
 }
 
 pub fn compile_fn(
-    fn_: Spanned<Function>,
-    parent_expr: Spanned<Expr>,
-) -> Result<Spanned<CompiledFunction>, Error> {
-    let (fn_, span) = fn_;
-    let (parent_expr, expr_span) = parent_expr;
+    S(fn_, span): S<Function>,
+    S(parent_expr, expr_span): S<Expr>,
+) -> Result<S<CompiledFunction>, Error> {
     let comp_fn = match fn_ {
         Function::Reverse => CompiledFunction::Reverse,
         Function::ReverseComp => CompiledFunction::ReverseComp,
@@ -54,35 +49,35 @@ pub fn compile_fn(
         Function::Normalize => CompiledFunction::Normalize,
         Function::MapWithMismatch(path, expr, mismatch) => CompiledFunction::MapWithMismatch(
             path,
-            compile_inner_expr(expr.deref().clone(), (parent_expr, expr_span))?,
+            compile_inner_expr(expr.unboxed(), S(parent_expr, expr_span))?,
             mismatch,
         ),
         Function::Map(path, expr) => CompiledFunction::Map(
             path,
-            compile_inner_expr(expr.deref().clone(), (parent_expr, expr_span))?,
+            compile_inner_expr(expr.unboxed(), S(parent_expr, expr_span))?,
         ),
         Function::FilterWithinDist(path, mismatch) => {
             CompiledFunction::FilterWithinDist(path, mismatch)
         }
         Function::Hamming(n) => CompiledFunction::Hamming(n),
     };
 
-    Ok((comp_fn, span))
+    Ok(S(comp_fn, span))
 }
 
 fn compile_inner_expr(
-    mut expr: Spanned<Expr>,
-    parent_expr: Spanned<Expr>,
-) -> Result<Vec<Spanned<CompiledFunction>>, Error> {
+    mut expr: S<Expr>,
+    parent_expr: S<Expr>,
+) -> Result<Vec<S<CompiledFunction>>, Error> {
     // if we are here in a map then the expr passed into the expr should be a geom_piece or labeled geom_piece
     // either way we can extract the size and type of it
-    let mut stack: Vec<Spanned<CompiledFunction>> = Vec::new();
+    let mut stack: Vec<S<CompiledFunction>> = Vec::new();
 
     loop {
         match expr.0 {
             Expr::Self_ => break,
             Expr::Function(inner_fn, inner_expr) => {
-                expr = inner_expr.deref().clone();
+                expr = inner_expr.unboxed();
                 let inner_fn = compile_fn(inner_fn.clone(), expr.clone());
                 if inner_fn.is_ok() {
                     stack.push(inner_fn.ok().unwrap());
@@ -103,11 +98,11 @@ fn compile_inner_expr(
     }
 
     let geom_piece = {
-        let (mut expr, span) = parent_expr;
+        let S(mut expr, span) = parent_expr;
         loop {
             match expr {
                 Expr::LabeledGeomPiece(_, b) => {
-                    let (gp, _) = b.deref();
+                    let S(gp, _) = b.unboxed();
                     expr = gp.clone();
                 }
                 Expr::GeomPiece(_, _) => break,
@@ -125,16 +120,18 @@ fn compile_inner_expr(
         } else {
             return Err(Error {
                 span,
-                msg: format!("Expected geometry peice found: {}", expr),
+                msg: format!("Expected geometry peice found: {expr}"),
             });
         }
     };
 
-    // check this and return esult from this function
-    validate_expr(GeometryMeta {
-        expr: (geom_piece, expr.1),
-        stack: stack.clone(),
-    })?;
+    // check this and return result from this function
+    let gm = GeometryMeta {
+        expr: S(geom_piece, expr.1),
+        stack,
+    };
+
+    gm.validate_expr()?;
 
-    Ok(stack)
+    Ok(gm.stack)
 }