feat: decompose Instruction::Cast to have an explicit truncation instruction

compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs

@@ -469,9 +469,9 @@ impl Context {
                     self.acir_context.assert_eq_var(lhs, rhs, assert_message.clone())?;
                 }
             }
-            Instruction::Cast(value_id, typ) => {
-                let result_acir_var = self.convert_ssa_cast(value_id, typ, dfg)?;
-                self.define_result_var(dfg, instruction_id, result_acir_var);
+            Instruction::Cast(value_id, _) => {
+                let acir_var = self.convert_numeric_value(*value_id, dfg)?;
+                self.define_result_var(dfg, instruction_id, acir_var);
             }
             Instruction::Call { func, arguments } => {
                 let result_ids = dfg.instruction_results(instruction_id);
@@ -1633,41 +1633,6 @@ impl Context {
         }
     }
 
-    /// Returns an `AcirVar` that is constrained to fit in the target type by truncating the input.
-    /// If the target cast is to a `NativeField`, no truncation is required so the cast becomes a
-    /// no-op.
-    fn convert_ssa_cast(
-        &mut self,
-        value_id: &ValueId,
-        typ: &Type,
-        dfg: &DataFlowGraph,
-    ) -> Result<AcirVar, RuntimeError> {
-        let (variable, incoming_type) = match self.convert_value(*value_id, dfg) {
-            AcirValue::Var(variable, typ) => (variable, typ),
-            AcirValue::DynamicArray(_) | AcirValue::Array(_) => {
-                unreachable!("Cast is only applied to numerics")
-            }
-        };
-        let target_numeric = match typ {
-            Type::Numeric(numeric) => numeric,
-            _ => unreachable!("Can only cast to a numeric"),
-        };
-        match target_numeric {
-            NumericType::NativeField => {
-                // Casting into a Field as a no-op
-                Ok(variable)
-            }
-            NumericType::Unsigned { bit_size } | NumericType::Signed { bit_size } => {
-                let max_bit_size = incoming_type.bit_size();
-                if max_bit_size <= *bit_size {
-                    // Incoming variable already fits into target bit size -  this is a no-op
-                    return Ok(variable);
-                }
-                self.acir_context.truncate_var(variable, *bit_size, max_bit_size)
-            }
-        }
-    }
-
     /// Returns an `AcirVar`that is constrained to be result of the truncation.
     fn convert_ssa_truncate(
         &mut self,

compiler/noirc_evaluator/src/ssa/function_builder/mod.rs

@@ -230,6 +230,25 @@ impl FunctionBuilder {
     /// Insert a cast instruction at the end of the current block.
     /// Returns the result of the cast instruction.
     pub(crate) fn insert_cast(&mut self, value: ValueId, typ: Type) -> ValueId {
+        fn get_type_size(typ: &Type) -> u32 {
+            match typ {
+                Type::Numeric(NumericType::NativeField) => FieldElement::max_num_bits(),
+                Type::Numeric(
+                    NumericType::Unsigned { bit_size } | NumericType::Signed { bit_size },
+                ) => *bit_size,
+                _ => unreachable!("Should only be called with primitive types"),
+            }
+        }
+
+        let incoming_type = self.type_of_value(value);
+        let incoming_type_size = get_type_size(&incoming_type);
+        let target_type_size = get_type_size(&typ);
+        let value = if target_type_size < incoming_type_size {
+            self.insert_truncate(value, target_type_size, incoming_type_size)
+        } else {
+            value
+        };
+
         self.insert_instruction(Instruction::Cast(value, typ), None).first()
     }