fix: allow nested fmtstr

compiler/noirc_frontend/src/hir_def/types.rs

@@ -2746,7 +2746,13 @@ impl From<&Type> for PrintableType {
                     .expect("Cannot print variable sized strings");
                 PrintableType::String { length: size }
             }
-            Type::FmtString(_, _) => unreachable!("format strings cannot be printed"),
+            Type::FmtString(size, typ) => {
+                let dummy_location = Location::dummy();
+                let size = size
+                    .evaluate_to_u32(dummy_location)
+                    .expect("Cannot print variable sized strings");
+                PrintableType::FmtString { length: size, typ: Box::new(typ.as_ref().into()) }
+            }
             Type::Error => unreachable!(),
             Type::Unit => PrintableType::Unit,
             Type::Constant(_, _) => unreachable!(),

compiler/noirc_printable_type/src/lib.rs

@@ -42,6 +42,10 @@ pub enum PrintableType {
     String {
         length: u32,
     },
+    FmtString {
+        length: u32,
+        typ: Box<PrintableType>,
+    },
     Function {
         arguments: Vec<PrintableType>,
         return_type: Box<PrintableType>,
@@ -62,6 +66,7 @@ pub enum PrintableType {
 pub enum PrintableValue<F> {
     Field(F),
     String(String),
+    FmtString(String, Vec<PrintableValue<F>>),
     Vec { array_elements: Vec<PrintableValue<F>>, is_slice: bool },
     Struct(BTreeMap<String, PrintableValue<F>>),
     Other,
@@ -159,6 +164,15 @@ fn to_string<F: AcirField>(value: &PrintableValue<F>, typ: &PrintableType) -> Op
             output.push_str(s);
         }
 
+        (PrintableValue::FmtString(template, values), PrintableType::FmtString { typ, .. }) => {
+            let PrintableType::Tuple { types } = typ.as_ref() else {
+                panic!("Expected type to be a Tuple for FmtString");
+            };
+            let template = template.to_string();
+            let args = values.iter().cloned().zip(types.iter().cloned()).collect::<Vec<_>>();
+            output.push_str(&PrintableValueDisplay::FmtString(template, args).to_string());
+        }
+
         (PrintableValue::Struct(map), PrintableType::Struct { name, fields, .. }) => {
             output.push_str(&format!("{name} {{ "));
 
@@ -319,8 +333,29 @@ pub fn decode_printable_value<F: AcirField>(
         },
         PrintableType::String { length } => {
             let field_elements: Vec<F> = field_iterator.take(*length as usize).collect();
+            let string = decode_string_value(&field_elements);
+            PrintableValue::String(string)
+        }
+        PrintableType::FmtString { length, typ } => {
+            // First comes the template string, for which we know its length
+            let field_elements: Vec<F> = field_iterator.take(*length as usize).collect();
+            let string = decode_string_value(&field_elements);
+
+            // Next comes the number of interpolated values
+            let tuple_length =
+                field_iterator.next().expect("Expected tuple length").to_u128() as usize;
+            let PrintableType::Tuple { types } = typ.as_ref() else {
+                panic!("Expected type to be a Tuple for FmtString");
+            };
+            assert_eq!(tuple_length, types.len());
+
+            // Next come the interpolated values
+            let values = types
+                .iter()
+                .map(|typ| decode_printable_value(field_iterator, typ))
+                .collect::<Vec<_>>();
 
-            PrintableValue::String(decode_string_value(&field_elements))
+            PrintableValue::FmtString(string, values)
         }
         PrintableType::Struct { fields, .. } => {
             let mut struct_map = BTreeMap::new();

test_programs/execution_success/nested_fmtstr/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "nested_fmtstr"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/execution_success/nested_fmtstr/src/main.nr

@@ -0,0 +1,13 @@
+fn main() {
+    let array = [1, 2, 3];
+    let one = f"pre array ({array}) post array";
+    println(one);
+
+    let two = f"pre one ({one}) post one";
+    println(two);
+    let three = f"pre two ({two}) ({two}) post two";
+
+    println(three);
+
+    println(f"pre three ({three} {three} {three}) post three");
+}