Implement Core JetHinter

codegen/src/main.rs

@@ -35,7 +35,7 @@ fn write_jet<W: io::Write>(jet: Elements, w: &mut W) -> io::Result<()> {
     writeln!(w, "///")?;
     writeln!(w, "/// {} mWU _(milli weight units)_", jet.cost())?;
     write!(w, "pub fn {jet}(")?;
-    let parameters = simplicityhl::jet::source_type(jet);
+    let parameters = simplicityhl::jet::elements::source_type(jet);
     for (i, ty) in parameters.iter().enumerate() {
         let identifier = (b'a' + i as u8) as char;
         if i == parameters.len() - 1 {
@@ -44,10 +44,14 @@ fn write_jet<W: io::Write>(jet: Elements, w: &mut W) -> io::Result<()> {
             write!(w, "{identifier}: {ty}, ")?;
         }
     }
-    let target = simplicityhl::jet::target_type(jet);
+    let target = simplicityhl::jet::elements::target_type(jet);
     match target.is_unit() {
         true => writeln!(w, ") {{")?,
-        false => writeln!(w, ") -> {} {{", simplicityhl::jet::target_type(jet))?,
+        false => writeln!(
+            w,
+            ") -> {} {{",
+            simplicityhl::jet::elements::target_type(jet)
+        )?,
     }
 
     writeln!(w, "    todo!()")?;
@@ -104,12 +108,12 @@ fn generate_docs(output_path: PathBuf) -> Result<(), Box<dyn std::error::Error>>
                     haskell_name: format!("{:?}", jet),
                     simplicityhl_name: jet.to_string(),
                     section: section_name.clone(),
-                    input_type: simplicityhl::jet::source_type(jet)
+                    input_type: simplicityhl::jet::elements::source_type(jet)
                         .iter()
                         .map(|ty| ty.to_string())
                         .collect::<Vec<_>>()
                         .join(", "),
-                    output_type: simplicityhl::jet::target_type(jet).to_string(),
+                    output_type: simplicityhl::jet::elements::target_type(jet).to_string(),
                     description: jet.documentation().to_string(),
                     deprecated: jet.is_deprecated(),
                 })

src/ast.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use either::Either;
 use miniscript::iter::{Tree, TreeLike};
-use simplicity::jet::{Elements, Jet};
+use simplicity::jet::{Core, Elements, Jet};
 
 use crate::debug::{CallTracker, DebugSymbols, TrackedCallName};
 use crate::driver::{FileScoped, SymbolTable, MAIN_MODULE, MAIN_STR};
@@ -557,31 +557,38 @@ pub trait JetHinter: std::fmt::Debug + Send + Sync {
     fn clone_box(&self) -> Box<dyn JetHinter>;
 }
 
-#[derive(Clone, Debug, Default)]
-pub struct ElementsJetHinter;
+macro_rules! impl_jet_hinter {
+    ($struct_name:ident, $jet_type:ident) => {
+        #[derive(Clone, Debug, Default)]
+        pub struct $struct_name;
 
-impl ElementsJetHinter {
-    pub fn new() -> Self {
-        Self
-    }
-}
+        impl $struct_name {
+            pub fn new() -> Self {
+                Self
+            }
+        }
 
-impl JetHinter for ElementsJetHinter {
-    fn parse_jet(&self, name: &str) -> Option<Box<dyn JetHL>> {
-        Elements::parse(name)
-            .ok()
-            .map(|jet| -> Box<dyn JetHL> { Box::new(jet) })
-    }
+        impl JetHinter for $struct_name {
+            fn parse_jet(&self, name: &str) -> Option<Box<dyn JetHL>> {
+                $jet_type::parse(name)
+                    .ok()
+                    .map(|jet| -> Box<dyn JetHL> { Box::new(jet) })
+            }
 
-    fn construct_verify(&self) -> Box<dyn JetHL> {
-        Box::new(Elements::Verify)
-    }
+            fn construct_verify(&self) -> Box<dyn JetHL> {
+                Box::new($jet_type::Verify)
+            }
 
-    fn clone_box(&self) -> Box<dyn JetHinter> {
-        Box::new(Self)
-    }
+            fn clone_box(&self) -> Box<dyn JetHinter> {
+                Box::new(Self)
+            }
+        }
+    };
 }
 
+impl_jet_hinter!(ElementsJetHinter, Elements);
+impl_jet_hinter!(CoreJetHinter, Core);
+
 /// Scope for generating the abstract syntax tree.
 ///
 /// The scope is used for: