Merge branch 'match_expr' into target_test

powdr-labs · Sep 25, 2024 · fcb7c89 · fcb7c89
2 parents 1008a55 + 4a23a7a
commit fcb7c89
Show file tree

Hide file tree

Showing 4 changed files with 65 additions and 8 deletions.
diff --git a/jit-compiler/src/codegen.rs b/jit-compiler/src/codegen.rs
@@ -7,7 +7,8 @@ use powdr_ast::{
         display::quote,
         types::{ArrayType, FunctionType, Type, TypeScheme},
         ArrayLiteral, BinaryOperation, BinaryOperator, BlockExpression, FunctionCall, IfExpression,
-        IndexAccess, LambdaExpression, Number, StatementInsideBlock, UnaryOperation,
+        IndexAccess, LambdaExpression, MatchArm, MatchExpression, Number, Pattern,
+        StatementInsideBlock, UnaryOperation,
     },
 };
 use powdr_number::FieldElement;
@@ -281,6 +282,22 @@ impl<'a, T: FieldElement> CodeGenerator<'a, T> {
                         .unwrap_or_default()
                 )
             }
+            Expression::MatchExpression(_, MatchExpression { scrutinee, arms }) => {
+                format!(
+                    "match {} {{\n{}\n}}",
+                    self.format_expr(scrutinee)?,
+                    arms.iter()
+                        .map(|MatchArm { pattern, value }| {
+                            Ok(format!(
+                                "{} => {},",
+                                format_pattern(pattern),
+                                self.format_expr(value)?,
+                            ))
+                        })
+                        .collect::<Result<Vec<_>, String>>()?
+                        .join("\n")
+                )
+            }
             _ => return Err(format!("Implement {e}")),
         })
     }
@@ -303,6 +320,31 @@ impl<'a, T: FieldElement> CodeGenerator<'a, T> {
     }
 }
 
+fn format_pattern(pattern: &Pattern) -> String {
+    match pattern {
+        Pattern::CatchAll(_) => "_".to_string(),
+        Pattern::Ellipsis(_) => "..".to_string(),
+        Pattern::Number(_, n) => {
+            // TODO this should probably fail if the number is too large.
+            n.to_string()
+        }
+        Pattern::String(_, s) => quote(s),
+        Pattern::Tuple(_, items) => {
+            format!("({})", items.iter().map(format_pattern).join(", "))
+        }
+        Pattern::Array(_, items) => {
+            format!("[{}]", items.iter().map(format_pattern).join(", "))
+        }
+        Pattern::Variable(_, var) => var.clone(),
+        Pattern::Enum(_, name, None) => escape_symbol(&name.to_string()),
+        Pattern::Enum(_, name, Some(fields)) => format!(
+            "{}({})",
+            escape_symbol(&name.to_string()),
+            fields.iter().map(format_pattern).join(", ")
+        ),
+    }
+}
+
 pub fn escape_symbol(s: &str) -> String {
     // TODO better escaping
     s.replace('.', "_").replace("::", "_")
@@ -324,10 +366,12 @@ fn map_type(ty: &Type) -> String {
         ),
         Type::TypeVar(tv) => tv.to_string(),
         Type::NamedType(path, type_args) => {
-            if type_args.is_some() {
-                unimplemented!()
+            let name = escape_symbol(&path.to_string());
+            if let Some(type_args) = type_args {
+                format!("{name}::<{}>", type_args.iter().map(map_type).join(", "))
+            } else {
+                name
             }
-            escape_symbol(&path.to_string())
         }
         Type::Col | Type::Inter => unreachable!(),
     }

diff --git a/jit-compiler/src/compiler.rs b/jit-compiler/src/compiler.rs
@@ -39,7 +39,7 @@ pub fn generate_glue_code<T: FieldElement>(
         let ty = analyzed.type_of_symbol(sym);
         if ty != int_int_fun && ty.ty != Type::Col {
             return Err(format!(
-                "Only (int -> int) functions and columns are supported, but requested {}",
+                "Only (int -> int) functions and columns are supported, but requested{}",
                 format_type_scheme_around_name(sym, &Some(ty)),
             ));
         }
@@ -84,7 +84,7 @@ version = "0.1.0"
 edition = "2021"
 
 [lib]
-crate-type = ["dylib"]
+crate-type = ["cdylib"]
 
 [dependencies]
 ibig = { version = "0.3.6", features = [], default-features = false }
@@ -110,10 +110,17 @@ pub fn call_cargo(code: &str) -> Result<(Temp, String), String> {
         let stderr = from_utf8(&out.stderr).unwrap_or("UTF-8 error in error message.");
         return Err(format!("Failed to compile: {stderr}."));
     }
+    let extension = if cfg!(target_os = "windows") {
+        "dll"
+    } else if cfg!(target_os = "macos") {
+        "dylib"
+    } else {
+        "so"
+    };
     let lib_path = dir
         .join("target")
         .join("release")
-        .join("libpowdr_jit_compiled.so");
+        .join(format!("libpowdr_jit_compiled.{extension}"));
     Ok((dir, lib_path.to_str().unwrap().to_string()))
 }
 

diff --git a/jit-compiler/src/lib.rs b/jit-compiler/src/lib.rs
@@ -42,7 +42,7 @@ pub fn compile<T: FieldElement>(
     let metadata = fs::metadata(&lib_path).unwrap();
 
     log::info!(
-        "Loading library with size {} MB...",
+        "Loading library of size {} MB...",
         metadata.len() as f64 / 1000000.0
     );
 

diff --git a/jit-compiler/tests/execution.rs b/jit-compiler/tests/execution.rs
@@ -44,6 +44,12 @@ fn sqrt() {
     assert_eq!(f(0), 0);
 }
 
+#[test]
+#[should_panic = "Only (int -> int) functions and columns are supported, but requested c: int -> bool"]
+fn invalid_function() {
+    let _ = compile("let c: int -> bool = |i| true;", "c");
+}
+
 #[test]
 fn assigned_functions() {
     let input = r#"