From ca5c65d03207763bf043259bde3eb59d7cc1db03 Mon Sep 17 00:00:00 2001
From: Matt Pharr <matt.pharr@intel.com>
Date: Tue, 27 Mar 2012 09:33:43 -0700
Subject: [PATCH] Fix bugs where typecasting an expression to void would cause
 it to disappear.

This was obviously problematic in cases where the expression was a function
call or the like, with side effects.

Fixes issue #199.
---
 expr.cpp                           | 20 ++++++++++++++++----
 tests/typecast-void-funcall-1.ispc | 17 +++++++++++++++++
 tests/typecast-void-funcall.ispc   | 17 +++++++++++++++++
 3 files changed, 50 insertions(+), 4 deletions(-)
 create mode 100644 tests/typecast-void-funcall-1.ispc
 create mode 100644 tests/typecast-void-funcall.ispc

diff --git a/expr.cpp b/expr.cpp
index 4f516382..c1e6092f 100644
--- a/expr.cpp
+++ b/expr.cpp
@@ -6284,10 +6284,17 @@ TypeCastExpr::GetValue(FunctionEmitContext *ctx) const {
 
     ctx->SetDebugPos(pos);
     const Type *toType = GetType(), *fromType = expr->GetType();
-    if (!toType || !fromType || Type::Equal(toType, AtomicType::Void) || 
-        Type::Equal(fromType, AtomicType::Void))
-        // an error should have been issued elsewhere in this case
+    if (toType == NULL || fromType == NULL) {
+        Assert(m->errorCount > 0);
         return NULL;
+    }
+
+    if (Type::Equal(toType, AtomicType::Void)) {
+        // emit the code for the expression in case it has side-effects but
+        // then we're done.
+        (void)expr->GetValue(ctx);
+        return NULL;
+    }
 
     const PointerType *fromPointerType = dynamic_cast<const PointerType *>(fromType);
     const PointerType *toPointerType = dynamic_cast<const PointerType *>(toType);
@@ -6590,7 +6597,12 @@ TypeCastExpr::TypeCheck() {
     fromType = lDeconstifyType(fromType);
     toType = lDeconstifyType(toType);
 
-    if (fromType->IsVaryingType() && toType->IsUniformType()) {
+    // Anything can be cast to void...
+    if (Type::Equal(toType, AtomicType::Void))
+        return this;
+
+    if (Type::Equal(fromType, AtomicType::Void) ||
+        fromType->IsVaryingType() && toType->IsUniformType()) {
         Error(pos, "Can't type cast from type \"%s\" to type \"%s\"",
               fromType->GetString().c_str(), toType->GetString().c_str());
         return NULL;
diff --git a/tests/typecast-void-funcall-1.ispc b/tests/typecast-void-funcall-1.ispc
new file mode 100644
index 00000000..c9aa0ed7
--- /dev/null
+++ b/tests/typecast-void-funcall-1.ispc
@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+float add(float a, float b, uniform float * uniform result) {
+    result[programIndex] = a+b;
+    return a+b;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex]; 
+    float b = 0.; b = a; 
+    (void)add(a, b, RET);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2 + 2*programIndex;
+}
diff --git a/tests/typecast-void-funcall.ispc b/tests/typecast-void-funcall.ispc
new file mode 100644
index 00000000..f2431ef9
--- /dev/null
+++ b/tests/typecast-void-funcall.ispc
@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+uniform float add(float a, float b, uniform float * uniform result) {
+    result[programIndex] = a+b;
+    return 1;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex]; 
+    float b = 0.; b = a; 
+    (void)add(a, b, RET);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2 + 2*programIndex;
+}