Misc. improvements

• Emit non-zero array constants properly
• Emit only actually used array constants per runtime wrapper
• Juno CLI
• Use repr(C) structs for product types
• Minimal implementation of SROA
• TODO: inlining, codegen cast, intrinsics, dynamic constant math

hercules_ir/src/ir.rs

@@ -708,6 +708,40 @@ impl Constant {
         }
     }
 
+    // A zero constant may need to return constants that don't exist yet, so we
+    // need mutable access to the constants array.
+    pub fn try_product_fields(
+        &self,
+        types: &[Type],
+        constants: &mut Vec<Constant>,
+    ) -> Option<Vec<ConstantID>> {
+        match self {
+            Constant::Product(_, fields) => Some(fields.iter().map(|x| *x).collect()),
+            Constant::Zero(ty) => match types[ty.idx()] {
+                Type::Product(ref fields) => Some(
+                    fields
+                        .iter()
+                        .map(|field_ty| {
+                            let field_constant = Constant::Zero(*field_ty);
+                            if let Some(idx) = constants
+                                .iter()
+                                .position(|constant| *constant == field_constant)
+                            {
+                                ConstantID::new(idx)
+                            } else {
+                                let id = ConstantID::new(constants.len());
+                                constants.push(field_constant);
+                                id
+                            }
+                        })
+                        .collect(),
+                ),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
     pub fn try_array_type(&self, types: &[Type]) -> Option<TypeID> {
         // Need types, since zero initializer may be for a collection type, ro
         // not.