Juno Frontend

• The initial implementation of the Juno Frontend
• A substantial portion of the Juno language is implemented, most outstanding features are related to match statements, modules, and type inference
• A handful of examples are present in juno_frontend/examples, including a version of CAVA though it does not compile as it depends on a number of features that are yet to be implemented.

hercules_ir/src/ir.rs

@@ -1169,13 +1169,15 @@ define_id_type!(TypeID);
 define_id_type!(ConstantID);
 define_id_type!(DynamicConstantID);
 
-// Debug printing for modules
-
+/*
+ * Sometimes, it's useful to debug print out a module. This code prints out a
+ * module in (approximately) the same textual format as is parsed in parse.rs.
+ */
 use std::fmt::Display;
 use std::fmt::Formatter;
 
 impl Display for Module {
-    fn fmt(&self, f : &mut Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         for func in self.functions.iter() {
             func.ir_fmt(f, self)?;
             write!(f, "\n")?;
@@ -1184,18 +1186,25 @@ impl Display for Module {
     }
 }
 
+/*
+ * When printing out objects in a module, we may need to refer back (upwards) to
+ * other objects in the module. Display doesn't let us do that, so we make our
+ * own trait.
+ */
 trait IRDisplay {
-    fn ir_fmt(&self, f : &mut Formatter<'_>, module : &Module) -> std::fmt::Result;
+    fn ir_fmt(&self, f: &mut Formatter<'_>, module: &Module) -> std::fmt::Result;
 }
 
 impl IRDisplay for Function {
-    fn ir_fmt(&self, f : &mut Formatter<'_>, module : &Module) -> std::fmt::Result {
+    fn ir_fmt(&self, f: &mut Formatter<'_>, module: &Module) -> std::fmt::Result {
         write!(f, "fn {}<{}>(", self.name, self.num_dynamic_constants)?;
-        
+
         for (idx, typ) in self.param_types.iter().enumerate() {
             write!(f, "arg_{} : ", idx)?;
             module.write_type(*typ, f)?;
-            if idx + 1 < self.param_types.len() { write!(f, ", ")?; }
+            if idx + 1 < self.param_types.len() {
+                write!(f, ", ")?;
+            }
         }
 
         write!(f, ") -> ")?;
@@ -1214,9 +1223,11 @@ impl IRDisplay for Function {
 }
 
 impl IRDisplay for Node {
-    fn ir_fmt(&self, f : &mut Formatter<'_>, module : &Module) -> std::fmt::Result {
+    fn ir_fmt(&self, f: &mut Formatter<'_>, module: &Module) -> std::fmt::Result {
         match self {
-            Node::Start => { write!(f, "start") },
+            Node::Start => {
+                write!(f, "start")
+            }
             Node::Region { preds } => {
                 write!(f, "region(")?;
                 for (idx, pred) in preds.iter().enumerate() {
@@ -1226,57 +1237,75 @@ impl IRDisplay for Node {
                     }
                 }
                 write!(f, ")")
-            },
+            }
             Node::If { control, cond } => {
                 write!(f, "if(var_{}, var_{})", control.0, cond.0)
-            },
+            }
             Node::Match { control, sum } => {
                 write!(f, "match(var_{}, var_{})", control.0, sum.0)
-            },
+            }
             Node::Fork { control, factor } => {
                 write!(f, "fork(var_{}, ", control.0)?;
                 module.write_dynamic_constant(*factor, f)?;
                 write!(f, ")")
-            },
+            }
             Node::Join { control } => {
                 write!(f, "join(var_{})", control.0)
-            },
+            }
             Node::Phi { control, data } => {
                 write!(f, "phi(var_{}", control.0)?;
                 for val in data.iter() {
                     write!(f, ", var_{}", val.0)?;
                 }
                 write!(f, ")")
-            },
+            }
             Node::ThreadID { control } => {
                 write!(f, "thread_id(var_{})", control.0)
-            },
-            Node::Reduce { control, init, reduct } => {
-                write!(f, "reduce(var_{}, var_{}, var_{})", control.0, init.0, reduct.0)
-            },
+            }
+            Node::Reduce {
+                control,
+                init,
+                reduct,
+            } => {
+                write!(
+                    f,
+                    "reduce(var_{}, var_{}, var_{})",
+                    control.0, init.0, reduct.0
+                )
+            }
             Node::Return { control, data } => {
                 write!(f, "return(var_{}, var_{})", control.0, data.0)
-            },
+            }
             Node::Parameter { index } => {
                 write!(f, "arg_{}", index)
-            },
+            }
             Node::Constant { id } => {
                 write!(f, "constant(")?;
                 module.constants[id.idx()].ir_fmt(f, module)?;
                 write!(f, ")")
-            },
+            }
             Node::DynamicConstant { id } => {
                 write!(f, "dynamic_constant(")?;
                 module.write_dynamic_constant(*id, f)?;
                 write!(f, ")")
-            },
+            }
             Node::Unary { input, op } => {
                 write!(f, "{}(var_{})", op.lower_case_name(), input.0)
-            },
+            }
             Node::Binary { left, right, op } => {
-                write!(f, "{}(var_{}, var_{})", op.lower_case_name(), left.0, right.0)
-            },
-            Node::Call { function, dynamic_constants, args } => {
+                write!(
+                    f,
+                    "{}(var_{}, var_{})",
+                    op.lower_case_name(),
+                    left.0,
+                    right.0
+                )
+            }
+            Node::Call {
+                function,
+                dynamic_constants,
+                args,
+            } => {
                 write!(f, "call<")?;
                 for (idx, dyn_const) in dynamic_constants.iter().enumerate() {
                     module.write_dynamic_constant(*dyn_const, f)?;
@@ -1289,7 +1318,7 @@ impl IRDisplay for Node {
                     write!(f, ", var_{}", arg.0)?;
                 }
                 write!(f, ")")
-            },
+            }
             Node::Read { collect, indices } => {
                 write!(f, "read(var_{}", collect.0)?;
                 for idx in indices.iter() {
@@ -1297,22 +1326,26 @@ impl IRDisplay for Node {
                     idx.ir_fmt(f, module)?;
                 }
                 write!(f, ")")
-            },
-            Node::Write { collect, data, indices } => {
+            }
+            Node::Write {
+                collect,
+                data,
+                indices,
+            } => {
                 write!(f, "write(var_{}, var_{}", collect.0, data.0)?;
                 for idx in indices.iter() {
                     write!(f, ", ")?;
                     idx.ir_fmt(f, module)?;
                 }
                 write!(f, ")")
-            },
+            }
             Node::Ternary { .. } => todo!(),
         }
     }
 }
 
 impl IRDisplay for Index {
-    fn ir_fmt(&self, f : &mut Formatter<'_>, _module : &Module) -> std::fmt::Result {
+    fn ir_fmt(&self, f: &mut Formatter<'_>, _module: &Module) -> std::fmt::Result {
         match self {
             Index::Field(idx) => write!(f, "field({})", idx),
             Index::Variant(idx) => write!(f, "variant({})", idx),
@@ -1321,16 +1354,18 @@ impl IRDisplay for Index {
                 write!(f, "position(")?;
                 for (i, idx) in indices.iter().enumerate() {
                     write!(f, "var_{}", idx.0)?;
-                    if i + 1 < indices.len() { write!(f, ", ")?; }
+                    if i + 1 < indices.len() {
+                        write!(f, ", ")?;
+                    }
                 }
                 write!(f, ")")
-            },
+            }
         }
     }
 }
 
 impl IRDisplay for Constant {
-    fn ir_fmt(&self, f : &mut Formatter<'_>, module : &Module) -> std::fmt::Result {
+    fn ir_fmt(&self, f: &mut Formatter<'_>, module: &Module) -> std::fmt::Result {
         match self {
             Constant::Boolean(v) => write!(f, "{} : bool", v),
             Constant::Integer8(v) => write!(f, "{} : i8", v),
@@ -1351,13 +1386,13 @@ impl IRDisplay for Constant {
                 }
                 write!(f, ") :")?;
                 module.write_type(*t, f)
-            },
+            }
             Constant::Summation(t, tag, cnst) => {
                 write!(f, "{}(", tag)?;
                 module.constants[cnst.idx()].ir_fmt(f, module)?;
                 write!(f, ") : ")?;
                 module.write_type(*t, f)
-            },
+            }
             Constant::Array(t, cnsts) => {
                 write!(f, "{{")?;
                 for i in 0..cnsts.len() {
@@ -1366,11 +1401,11 @@ impl IRDisplay for Constant {
                 }
                 write!(f, "}} : ")?;
                 module.write_type(*t, f)
-            },
+            }
             Constant::Zero(t) => {
                 write!(f, "zero : ")?;
                 module.write_type(*t, f)
-            },
+            }
         }
     }
 }