Warning for uninitialized reductions.

Author: dingobye

tc/lang/sema.h

@@ -490,6 +490,21 @@ struct Sema {
       }
     }
 
+    // After checking rhs and before creating lhs, we check if it is a reduction
+    // without initialization (i.e., reduction operator without "!" suffix, and
+    // lhs not defined previously).
+    if (isUninitializedReductionOperation(stmt.assignment()) &&
+        nullptr == lookup(stmt.ident(), false)) {
+      ErrorReport err(stmt);
+      std::string tk = kindToToken(stmt.assignment()->kind());
+      err << "Reduction without initialization. "
+          << "It reads from the uninitialized " << stmt.ident().name()
+          << " before writing to it.\n"
+          << "Consider using the !-suffixed reduction operator " << tk
+          << "! instead of " << tk;
+      warn(err);
+    }
+
     auto type = TensorType::create(
         stmt.range(),
         scalar_type,
@@ -544,6 +559,17 @@ struct Sema {
 
     return result;
   }
+  static bool isUninitializedReductionOperation(TreeRef assignment) {
+    switch (assignment->kind()) {
+      case TK_PLUS_EQ:
+      case TK_TIMES_EQ:
+      case TK_MIN_EQ:
+      case TK_MAX_EQ:
+        return true;
+      default:
+        return false;
+    }
+  }
   bool isNotInplace(TreeRef assignment) {
     switch (assignment->kind()) {
       case TK_PLUS_EQ_B:

test/test_lang.cc

@@ -143,6 +143,23 @@ void assertSemaThrows(const std::string& errcontents, const std::string& text) {
   }
   ASSERT(threw);
 }
+void assertSemaWarns(const std::string& warncontents, const std::string& text) {
+  Parser parser(text);
+  auto p = parser.parseFunction();
+  Sema sem;
+  // Redirect std::cerr to buffer in order to capture warning message.
+  std::stringstream buffer;
+  std::streambuf* old = std::cerr.rdbuf(buffer.rdbuf());
+  sem.checkFunction(p);
+  std::cerr.rdbuf(old);
+  // Match the captured warning message with the expected one.
+  // Empty warncontents denotes no warning should be raised.
+  if (warncontents.empty()) {
+    ASSERT(buffer.str().find("WARNING:") == std::string::npos);
+  } else {
+    ASSERT(buffer.str().find(warncontents) != std::string::npos);
+  }
+}
 TreeRef loadText(const std::string& text) {
   return Sema().checkFunction(Parser(text).parseFunction());
 }
@@ -315,6 +332,57 @@ int main(int argc, char** argv) {
       O(i) = A(i,j)
     }
   )");
+  assertSemaWarns(
+      "", // Legal reduction with initialization.
+      R"(
+    def fun(float(M,N) A) -> (O) {
+      O(i) +=! A(i,j)
+    }
+  )");
+  assertSemaWarns(
+      "", // Legal reduction that writes to an already initialized output.
+      R"(
+    def fun(float(M,N) A, float(M) B) -> (O) {
+      O(i) = B(i)
+      O(i) *= A(i,j)
+    }
+  )");
+  assertSemaWarns(
+      "", // Legal reduction that writes to an already initialized output.
+      R"(
+    def fun(float(M,N) A, float(M,N) B) -> (O) {
+      O(i) max=! A(i,j)
+      O(i) min= B(i,j)
+    }
+  )");
+  assertSemaWarns(
+      "+=! instead of +=",
+      R"(
+    def fun(float(M,N) A) -> (O) {
+      O(i) += A(i,j)
+    }
+  )");
+  assertSemaWarns(
+      "*=! instead of *=",
+      R"(
+    def fun(float(M,N) A) -> (O) {
+      O(i) *= A(i,j)
+    }
+  )");
+  assertSemaWarns(
+      "max=! instead of max=",
+      R"(
+    def fun(float(M,N) A) -> (O) {
+      O(i) max= A(i,j)
+    }
+  )");
+  assertSemaWarns(
+      "min=! instead of min=",
+      R"(
+    def fun(float(M,N) A) -> (O) {
+      O(i) min= A(i,j)
+    }
+  )");
 
   auto option_one = R"(
     def fun(float(B, N, M) X, float(B, M, K) Y) -> (Z)