From 5318984a1dbcb643e5514c23984041c767f05f55 Mon Sep 17 00:00:00 2001
From: Atell Krasnopolski <delta_atell@protonmail.com>
Date: Thu, 18 Jul 2024 13:29:45 +0200
Subject: [PATCH] Prevent Clad from trying to create a void zero literal

Previously, clad used to try to synthesise a void zero literal
when differentiating a call to a void function with
literal arguments in the forward mode. This caused it to crash.

Fixes: #988
---
 lib/Differentiator/BaseForwardModeVisitor.cpp | 13 ++++++++++---
 test/FirstDerivative/FunctionCalls.C          | 16 ++++++++++++++++
 2 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/lib/Differentiator/BaseForwardModeVisitor.cpp b/lib/Differentiator/BaseForwardModeVisitor.cpp
index 7853205a7..a551d1249 100644
--- a/lib/Differentiator/BaseForwardModeVisitor.cpp
+++ b/lib/Differentiator/BaseForwardModeVisitor.cpp
@@ -1219,9 +1219,16 @@ StmtDiff BaseForwardModeVisitor::VisitCallExpr(const CallExpr* CE) {
                                validLoc, llvm::MutableArrayRef<Expr*>(CallArgs),
                                validLoc)
                 .get();
-        auto* zero = ConstantFolder::synthesizeLiteral(CE->getType(), m_Context,
-                                                       /*val=*/0);
-        return StmtDiff(call, zero);
+        if (!CE->getType().getTypePtr()->isVoidType()) {
+          auto* zero =
+              ConstantFolder::synthesizeLiteral(CE->getType(), m_Context,
+                                                /*val=*/0);
+          return StmtDiff(call, zero);
+        } else {
+          // No differentiation or zero generation for void functions with
+          // literal arguments.
+          return StmtDiff(call, nullptr);
+        }
       }
     }
   }
diff --git a/test/FirstDerivative/FunctionCalls.C b/test/FirstDerivative/FunctionCalls.C
index 33e15c2c6..35dedd308 100644
--- a/test/FirstDerivative/FunctionCalls.C
+++ b/test/FirstDerivative/FunctionCalls.C
@@ -183,6 +183,21 @@ double test_9(double x) {
 // CHECK-NEXT: return _t0.pushforward;
 // CHECK-NEXT: }
 
+void some_important_void_func(double y) {
+    assert(y < 0);
+}
+
+double test_10(double x) {
+  some_important_void_func(0);
+  return x;
+}
+
+// CHECK:      double test_10_darg0(double x) {
+// CHECK-NEXT:     double _d_x = 1;
+// CHECK-NEXT:     some_important_void_func(0);
+// CHECK-NEXT:     return _d_x;
+// CHECK-NEXT: }
+
 int main () {
   clad::differentiate(test_1, 0);
   clad::differentiate(test_2, 0);
@@ -196,6 +211,7 @@ int main () {
   clad::differentiate<clad::opts::enable_tbr, clad::opts::disable_tbr>(test_8); // expected-error {{Both enable and disable TBR options are specified.}}
   clad::differentiate<clad::opts::diagonal_only>(test_8); // expected-error {{Diagonal only option is only valid for Hessian mode.}}
   clad::differentiate(test_9);
+  clad::differentiate(test_10);
   return 0;
 
 // CHECK: void increment_pushforward(int &i, int &_d_i) {