Support constant string concatenation

compiler-core/schema.capnp

@@ -195,6 +195,11 @@ struct Constant {
       typ @12 :Type;
       constructor @13 :ValueConstructor;
     }
+
+    stringConcatenation :group {
+      left @14 :Constant;
+      right @15 :Constant;
+    }
   }
 }
 

compiler-core/src/ast/constant.rs

@@ -55,6 +55,12 @@ pub enum Constant<T, RecordTag> {
         typ: T,
     },
 
+    StringConcatenation {
+        location: SrcSpan,
+        left: Box<Self>,
+        right: Box<Self>,
+    },
+
     /// A placeholder constant used to allow module analysis to continue
     /// even when there are type errors. Should never end up in generated code.
     Invalid {
@@ -68,7 +74,7 @@ impl TypedConstant {
         match self {
             Constant::Int { .. } => type_::int(),
             Constant::Float { .. } => type_::float(),
-            Constant::String { .. } => type_::string(),
+            Constant::String { .. } | Constant::StringConcatenation { .. } => type_::string(),
             Constant::BitArray { .. } => type_::bits(),
             Constant::Tuple { elements, .. } => {
                 type_::tuple(elements.iter().map(|e| e.type_()).collect())
@@ -98,7 +104,8 @@ impl<A, B> Constant<A, B> {
             | Constant::Record { location, .. }
             | Constant::BitArray { location, .. }
             | Constant::Var { location, .. }
-            | Constant::Invalid { location, .. } => *location,
+            | Constant::Invalid { location, .. }
+            | Constant::StringConcatenation { location, .. } => *location,
         }
     }
 

compiler-core/src/ast_folder.rs

@@ -878,6 +878,12 @@ pub trait UntypedConstantFolder {
                 typ: (),
             } => self.fold_constant_var(location, module, name),
 
+            Constant::StringConcatenation {
+                location,
+                left,
+                right,
+            } => self.fold_constant_string_concatenation(location, left, right),
+
             Constant::Invalid { location, typ: () } => self.fold_constant_invalid(location),
         }
     }
@@ -955,6 +961,19 @@ pub trait UntypedConstantFolder {
         }
     }
 
+    fn fold_constant_string_concatenation(
+        &mut self,
+        location: SrcSpan,
+        left: Box<UntypedConstant>,
+        right: Box<UntypedConstant>,
+    ) -> UntypedConstant {
+        Constant::StringConcatenation {
+            location,
+            left,
+            right,
+        }
+    }
+
     fn fold_constant_invalid(&mut self, location: SrcSpan) -> UntypedConstant {
         Constant::Invalid { location, typ: () }
     }
@@ -1022,6 +1041,20 @@ pub trait UntypedConstantFolder {
                     .collect();
                 Constant::BitArray { location, segments }
             }
+
+            Constant::StringConcatenation {
+                location,
+                left,
+                right,
+            } => {
+                let left = Box::new(self.fold_constant(*left));
+                let right = Box::new(self.fold_constant(*right));
+                Constant::StringConcatenation {
+                    location,
+                    left,
+                    right,
+                }
+            }
         }
     }
 }

compiler-core/src/call_graph.rs

@@ -454,6 +454,11 @@ impl<'a> CallGraphBuilder<'a> {
                     self.constant(&segment.value);
                 }
             }
+
+            Constant::StringConcatenation { left, right, .. } => {
+                self.constant(left);
+                self.constant(right);
+            }
         }
     }
 }