Optimize array of literals

Author: swernli

compiler/qsc_eval/src/lib.rs

@@ -617,6 +617,7 @@ impl State {
 
         match &expr.kind {
             ExprKind::Array(arr) => self.eval_arr(arr.len()),
+            ExprKind::ArrayLit(arr) => self.eval_arr_lit(arr, globals),
             ExprKind::ArrayRepeat(..) => self.eval_arr_repeat(expr.span)?,
             ExprKind::Assign(lhs, _) => self.eval_assign(env, globals, *lhs)?,
             ExprKind::AssignOp(op, lhs, rhs) => {
@@ -736,6 +737,19 @@ impl State {
         self.set_curr_val(Value::Array(arr.into()));
     }
 
+    fn eval_arr_lit(&mut self, arr: &Vec<ExprId>, globals: &impl PackageStoreLookup) {
+        let mut new_arr: Rc<Vec<Value>> = Rc::new(Vec::with_capacity(arr.len()));
+        for id in arr {
+            let ExprKind::Lit(lit) = &globals.get_expr((self.package, *id).into()).kind else {
+                panic!("expr kind should be lit")
+            };
+            Rc::get_mut(&mut new_arr)
+                .expect("array should be uniquely referenced")
+                .push(lit_to_val(lit));
+        }
+        self.curr_val = Some(Value::Array(new_arr));
+    }
+
     fn eval_array_append_in_place(
         &mut self,
         env: &mut Env,

compiler/qsc_eval/src/lower.rs

@@ -303,16 +303,34 @@ impl Lowerer {
         let ty = self.lower_ty(&expr.ty);
 
         let kind = match &expr.kind {
-            hir::ExprKind::Array(items) => fir::ExprKind::Array(
-                items
+            hir::ExprKind::Array(items) => {
+                if items
                     .iter()
-                    .map(|i| {
-                        let i = self.lower_expr(i);
-                        self.cfg.push(CfgNode::Store);
-                        i
-                    })
-                    .collect(),
-            ),
+                    .all(|i| matches!(i.kind, hir::ExprKind::Lit(..)))
+                {
+                    fir::ExprKind::ArrayLit(
+                        items
+                            .iter()
+                            .map(|i| {
+                                let i = self.lower_expr(i);
+                                self.cfg.pop();
+                                i
+                            })
+                            .collect(),
+                    )
+                } else {
+                    fir::ExprKind::Array(
+                        items
+                            .iter()
+                            .map(|i| {
+                                let i = self.lower_expr(i);
+                                self.cfg.push(CfgNode::Store);
+                                i
+                            })
+                            .collect(),
+                    )
+                }
+            }
             hir::ExprKind::ArrayRepeat(value, size) => {
                 let value = self.lower_expr(value);
                 self.cfg.push(CfgNode::Store);

compiler/qsc_fir/src/fir.rs

@@ -1015,6 +1015,8 @@ impl Display for Expr {
 pub enum ExprKind {
     /// An array: `[a, b, c]`.
     Array(Vec<ExprId>),
+    /// An array of literal values, ie: `[1, 2, 3]`.
+    ArrayLit(Vec<ExprId>),
     /// An array constructed by repeating a value: `[a, size = b]`.
     ArrayRepeat(ExprId, ExprId),
     /// An assignment: `set a = b`.
@@ -1074,6 +1076,7 @@ impl Display for ExprKind {
         let mut indent = set_indentation(indented(f), 0);
         match self {
             ExprKind::Array(exprs) => display_array(indent, exprs)?,
+            ExprKind::ArrayLit(exprs) => display_array(indent, exprs)?,
             ExprKind::ArrayRepeat(val, size) => display_array_repeat(indent, *val, *size)?,
             ExprKind::Assign(lhs, rhs) => display_assign(indent, *lhs, *rhs)?,
             ExprKind::AssignOp(op, lhs, rhs) => display_assign_op(indent, *op, *lhs, *rhs)?,

compiler/qsc_fir/src/mut_visit.rs

@@ -123,7 +123,9 @@ pub fn walk_stmt<'a>(vis: &mut impl MutVisitor<'a>, id: StmtId) {
 pub fn walk_expr<'a>(vis: &mut impl MutVisitor<'a>, expr: ExprId) {
     let expr = vis.get_expr(expr);
     match &expr.kind {
-        ExprKind::Array(exprs) => exprs.iter().for_each(|e| vis.visit_expr(*e)),
+        ExprKind::Array(exprs) | ExprKind::ArrayLit(exprs) => {
+            exprs.iter().for_each(|e| vis.visit_expr(*e));
+        }
         ExprKind::ArrayRepeat(item, size) => {
             vis.visit_expr(*item);
             vis.visit_expr(*size);

compiler/qsc_fir/src/visit.rs

@@ -123,7 +123,9 @@ pub fn walk_stmt<'a>(vis: &mut impl Visitor<'a>, id: StmtId) {
 pub fn walk_expr<'a>(vis: &mut impl Visitor<'a>, expr: ExprId) {
     let expr = vis.get_expr(expr);
     match &expr.kind {
-        ExprKind::Array(exprs) => exprs.iter().for_each(|e| vis.visit_expr(*e)),
+        ExprKind::Array(exprs) | ExprKind::ArrayLit(exprs) => {
+            exprs.iter().for_each(|e| vis.visit_expr(*e));
+        }
         ExprKind::ArrayRepeat(item, size) => {
             vis.visit_expr(*item);
             vis.visit_expr(*size);