Add complete support for constant dynamic collections

crates/rune/src/compile/const_value.rs

@@ -7,6 +7,12 @@ impl Compile<(&ConstValue, Span)> for Compiler<'_> {
             ConstValue::Unit => {
                 self.asm.push(Inst::unit(), span);
             }
+            ConstValue::Byte(b) => {
+                self.asm.push(Inst::byte(*b), span);
+            }
+            ConstValue::Char(c) => {
+                self.asm.push(Inst::char(*c), span);
+            }
             ConstValue::Integer(n) => {
                 self.asm.push(Inst::integer(*n), span);
             }
@@ -20,6 +26,10 @@ impl Compile<(&ConstValue, Span)> for Compiler<'_> {
                 let slot = self.unit.borrow_mut().new_static_string(&s)?;
                 self.asm.push(Inst::String { slot }, span);
             }
+            ConstValue::Bytes(b) => {
+                let slot = self.unit.borrow_mut().new_static_bytes(b)?;
+                self.asm.push(Inst::Bytes { slot }, span);
+            }
             ConstValue::Vec(vec) => {
                 for value in vec.iter() {
                     self.compile((value, span))?;
@@ -34,6 +44,18 @@ impl Compile<(&ConstValue, Span)> for Compiler<'_> {
 
                 self.asm.push(Inst::Tuple { count: tuple.len() }, span);
             }
+            ConstValue::Object(object) => {
+                let slot = self
+                    .unit
+                    .borrow_mut()
+                    .new_static_object_keys(&*object.keys)?;
+
+                for value in object.values.iter() {
+                    self.compile((value, span))?;
+                }
+
+                self.asm.push(Inst::Object { slot }, span);
+            }
         }
 
         Ok(())

crates/rune/src/eval/ir.rs

@@ -18,6 +18,7 @@ impl Eval<&Ir> for IrInterpreter<'_> {
             IrKind::Break(ir_break) => self.eval(ir_break, used),
             IrKind::Vec(ir_vec) => self.eval(ir_vec, used),
             IrKind::Tuple(ir_tuple) => self.eval(ir_tuple, used),
+            IrKind::Object(ir_object) => self.eval(ir_object, used),
         }
     }
 }

crates/rune/src/eval/ir_object.rs

@@ -0,0 +1,18 @@
+use crate::eval::prelude::*;
+
+impl Eval<&IrObject> for IrInterpreter<'_> {
+    fn eval(&mut self, ir_object: &IrObject, used: Used) -> Result<ConstValue, EvalOutcome> {
+        let mut keys = Vec::new();
+        let mut values = Vec::new();
+
+        for (key, value) in ir_object.assignments.iter() {
+            keys.push(key.clone());
+            values.push(self.eval(value, used)?);
+        }
+
+        Ok(ConstValue::Object(ConstObject {
+            keys: keys.into_boxed_slice(),
+            values: values.into_boxed_slice(),
+        }))
+    }
+}

crates/rune/src/eval/mod.rs

@@ -8,6 +8,7 @@ mod ir_branches;
 mod ir_break;
 mod ir_decl;
 mod ir_loop;
+mod ir_object;
 mod ir_scope;
 mod ir_set;
 mod ir_template;

crates/rune/src/eval/prelude.rs

@@ -5,5 +5,5 @@ pub(crate) use crate::ir::*;
 pub(crate) use crate::ir_interpreter::IrInterpreter;
 pub(crate) use crate::CompileError;
 pub(crate) use crate::Spanned;
-pub(crate) use runestick::{ConstValue, Span};
+pub(crate) use runestick::{ConstObject, ConstValue, Span};
 pub(crate) use std::convert::TryFrom;

crates/rune/src/ir.rs

@@ -39,12 +39,13 @@ pub struct Ir {
 
 impl Ir {
     /// Construct a new intermediate instruction.
-    pub fn new<K>(span: Span, kind: K) -> Self
+    pub fn new<S, K>(spanned: S, kind: K) -> Self
     where
+        S: Spanned,
         IrKind: From<K>,
     {
         Self {
-            span,
+            span: spanned.span(),
             kind: IrKind::from(kind),
         }
     }
@@ -79,6 +80,8 @@ decl_kind! {
         Vec(IrVec),
         /// Constructing a tuple.
         Tuple(IrTuple),
+        /// Constructing an object.
+        Object(IrObject),
     }
 }
 
@@ -205,6 +208,16 @@ pub struct IrTuple {
     pub items: Box<[Ir]>,
 }
 
+/// Object expression.
+#[derive(Debug, Clone, Spanned)]
+pub struct IrObject {
+    /// Span of the object.
+    #[rune(span)]
+    pub span: Span,
+    /// Field initializations.
+    pub assignments: Box<[(Box<str>, Ir)]>,
+}
+
 /// Vector expression.
 #[derive(Debug, Clone, Spanned)]
 pub struct IrVec {