tc2halide: put throwWarnings in CompilerOptions and use the latter

Most functions in the tc2halide namespace take a boolean argument that
controls whether the conversion warnings should be treated as
exceptions.  Move this flag to CompilerOptions and pass these options
instead.  Propagate the options to Scop::makeScop calls used only in
tests.

Author: ftynse

tc/aten/aten_compiler.h

@@ -22,6 +22,7 @@
 #include "tc/aten/aten.h"
 #include "tc/core/tensor.h"
 #include "tc/core/utils/time.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc {
 namespace aten {

tc/core/compiler-inl.h

@@ -55,8 +55,8 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
 
   auto inputsInfo = makeTensorInfoVector(inputs);
   auto outputsInfo = detail::inferOutputTensorInfo(tcDefinition, inputs);
-  auto halideComponents =
-      tc2halide::translate(isl::with_exceptions::globalIslCtx(), tcDefinition);
+  auto halideComponents = tc2halide::translate(
+      isl::with_exceptions::globalIslCtx(), tcDefinition, CompilerOptions());
   detail::checkInputsCompliant(halideComponents, inputs);
 
   auto tcName = lang::Def(tcDefinition).name().name();

tc/core/compiler.cc

@@ -103,7 +103,10 @@ std::vector<TensorInfo> inferOutputTensorInfo(
     lang::TreeRef tcDefinition,
     const std::vector<const DLConstTensor*> inputs) {
   return tc::inferOutputTensorInfo(
-      tc2halide::translate(isl::with_exceptions::globalIslCtx(), tcDefinition),
+      tc2halide::translate(
+          isl::with_exceptions::globalIslCtx(),
+          tcDefinition,
+          CompilerOptions()),
       inputs);
 }
 

tc/core/polyhedral/scop.cc

@@ -34,6 +34,7 @@
 #include "tc/core/polyhedral/schedule_utils.h"
 #include "tc/core/scope_guard.h"
 #include "tc/core/tc2halide.h"
+#include "tc/utils/compiler_options.h"
 
 using namespace std;
 
@@ -69,12 +70,18 @@ ScopUPtr Scop::makeScop(
   return scop;
 }
 
-ScopUPtr Scop::makeScop(isl::ctx ctx, const string& tc) {
-  return makeScop(ctx, tc2halide::translate(ctx, tc));
+ScopUPtr Scop::makeScop(
+    isl::ctx ctx,
+    const string& tc,
+    const CompilerOptions& compilerOptions) {
+  return makeScop(ctx, tc2halide::translate(ctx, tc, compilerOptions));
 }
 
-ScopUPtr Scop::makeScop(isl::ctx ctx, const lang::TreeRef& treeRef) {
-  return makeScop(ctx, tc2halide::translate(ctx, treeRef));
+ScopUPtr Scop::makeScop(
+    isl::ctx ctx,
+    const lang::TreeRef& treeRef,
+    const CompilerOptions& compilerOptions) {
+  return makeScop(ctx, tc2halide::translate(ctx, treeRef, compilerOptions));
 }
 
 isl::union_set& Scop::domainRef() {

tc/core/polyhedral/scop.h

@@ -32,6 +32,7 @@
 #include "tc/core/tc2halide.h"
 #include "tc/core/tensor.h"
 #include "tc/external/isl.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc {
 namespace polyhedral {
@@ -56,11 +57,15 @@ struct Scop {
   // Halide IR is constructed and made a member by setting halideComponents.
   // These operations are grouped and scheduled in a halide::Stmt which becomes
   // the unit from which the scop is constructed.
-  static std::unique_ptr<Scop> makeScop(isl::ctx ctx, const std::string& tc);
+  static std::unique_ptr<Scop> makeScop(
+      isl::ctx ctx,
+      const std::string& tc,
+      const CompilerOptions& compilerOptions = CompilerOptions());
 
   static std::unique_ptr<Scop> makeScop(
       isl::ctx ctx,
-      const lang::TreeRef& treeRef);
+      const lang::TreeRef& treeRef,
+      const CompilerOptions& compilerOptions = CompilerOptions());
 
   // Clone a Scop
   static std::unique_ptr<Scop> makeScop(const Scop& scop) {

tc/core/tc2halide.cc

@@ -20,6 +20,7 @@
 #include "tc/core/tc2halide.h"
 #include "tc/lang/parser.h"
 #include "tc/lang/sema.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc2halide {
 
@@ -270,7 +271,7 @@ void forwardBoundsInference(
     const std::vector<Expr>& exprs,
     const FunctionBounds& bounds,
     const lang::TreeRef& comprehension,
-    bool throwWarnings,
+    const tc::CompilerOptions& compilerOptions,
     Scope<Interval>* solution) {
   class CreateConstraints : public IRVisitor {
     using IRVisitor::visit;
@@ -488,10 +489,10 @@ void forwardBoundsInference(
     lang::ErrorReport err(comprehension);
     err << "Required precondition will not be checked at runtime: "
         << remaining;
-    if (throwWarnings) {
+    if (compilerOptions.throwWarnings) {
       throw err;
     } else {
-      warn(err);
+      warn(err, compilerOptions);
     }
   }
 }
@@ -509,7 +510,7 @@ Expr reductionUpdate(Expr e) {
 void translateComprehension(
     const lang::Comprehension& comprehension,
     const map<string, Parameter>& params,
-    bool throwWarnings,
+    const tc::CompilerOptions& compilerOptions,
     map<string, Function>* funcs,
     FunctionBounds* bounds) {
   Function f;
@@ -670,7 +671,7 @@ void translateComprehension(
   // Infer the rest
   all_exprs.push_back(rhs);
   forwardBoundsInference(
-      all_exprs, *bounds, comprehension, throwWarnings, &solution);
+      all_exprs, *bounds, comprehension, compilerOptions, &solution);
 
   // TODO: What if subsequent updates have incompatible bounds
   // (e.g. an in-place stencil)?. The .bound directive will use the
@@ -754,7 +755,9 @@ void translateComprehension(
 }
 
 // Translate a semantically checked TC def to HalideComponents struct.
-HalideComponents translateDef(const lang::Def& def, bool throwWarnings) {
+HalideComponents translateDef(
+    const lang::Def& def,
+    const tc::CompilerOptions& compilerOptions) {
   map<string, Function> funcs;
   HalideComponents components;
   components.def = def;
@@ -765,7 +768,7 @@ HalideComponents translateDef(const lang::Def& def, bool throwWarnings) {
   }
   for (auto c : def.statements()) {
     translateComprehension(
-        c, components.params, throwWarnings, &funcs, &bounds);
+        c, components.params, compilerOptions, &funcs, &bounds);
   }
   vector<Function> outputs;
   for (auto p : def.returns()) {
@@ -906,19 +909,23 @@ HalideComponents translateDef(const lang::Def& def, bool throwWarnings) {
 }
 } // namespace
 
-HalideComponents
-translate(isl::ctx ctx, const lang::TreeRef& treeRef, bool throwWarnings) {
+HalideComponents translate(
+    isl::ctx ctx,
+    const lang::TreeRef& treeRef,
+    const tc::CompilerOptions& compilerOptions = tc::CompilerOptions()) {
   LOG_IF(INFO, tc::FLAGS_debug_halide) << treeRef;
   return translateDef(
-      lang::Def(lang::Sema().checkFunction(treeRef)), throwWarnings);
+      lang::Def(lang::Sema().checkFunction(treeRef)), compilerOptions);
 }
 
 // NOTE: there is no guarantee here that the tc string has only one def. It
 // could have many defs. Only first def will be converted in that case.
-HalideComponents
-translate(isl::ctx ctx, const std::string& tc, bool throwWarnings) {
+HalideComponents translate(
+    isl::ctx ctx,
+    const std::string& tc,
+    const tc::CompilerOptions& compilerOptions = tc::CompilerOptions()) {
   LOG_IF(INFO, tc::FLAGS_debug_halide) << tc;
-  return translate(ctx, lang::Parser(tc).parseFunction(), throwWarnings);
+  return translate(ctx, lang::Parser(tc).parseFunction(), compilerOptions);
 }
 
 } // namespace tc2halide

tc/core/tc2halide.h

@@ -20,6 +20,7 @@
 #include "tc/external/isl.h"
 #include "tc/lang/tree.h"
 #include "tc/lang/tree_views.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc2halide {
 
@@ -44,15 +45,19 @@ struct HalideComponents {
 Halide::Internal::Call::ConstString kReductionUpdate = "ReductionUpdate";
 
 // Translate a TC parse tree into equivalent Halide imperative IR with
-// a naive schedule.
+// a naive schedule.  Additional options, such as how to treat warnings, are
+// passed in as "compilerOptions".
 HalideComponents translate(
     isl::ctx ctx,
     const lang::TreeRef& treeRef,
-    bool throwWarnings = false);
+    const tc::CompilerOptions& compilerOptions);
 
 // Translate TC source into equivalent Halide imperative IR with a
-// naive schedule.
-HalideComponents
-translate(isl::ctx ctx, const std::string& tc, bool throwWarnings = false);
+// naive schedule.  Additional options, such as how to treat warnings, are
+// passed in as "compilerOptions".
+HalideComponents translate(
+    isl::ctx ctx,
+    const std::string& tc,
+    const tc::CompilerOptions& compilerOptions);
 
 } // namespace tc2halide

tc/utils/compiler_options.h

@@ -32,6 +32,8 @@ class CompilerOptions {
 
   /// Print syntactic warnings.
   bool emitWarnings = true;
+  /// Treat warnings in TC to Halide conversion as exceptions.
+  bool throwWarnings = false;
 };
 
 } // namespace tc

test/test_core.cc

@@ -32,6 +32,7 @@
 #include "tc/lang/error_report.h"
 #include "tc/library/copy.h"
 #include "tc/library/matmul.h"
+#include "tc/utils/compiler_options.h"
 
 using namespace std;
 
@@ -60,8 +61,8 @@ dtype {
 struct GenericHalideCoreTest : public ::testing::Test {
   void CheckC(const std::string& tc, const std::vector<std::string>& expected) {
     auto curPos = std::string::npos;
-    auto halide =
-        tc2halide::translate(isl::with_exceptions::globalIslCtx(), tc);
+    auto halide = tc2halide::translate(
+        isl::with_exceptions::globalIslCtx(), tc, CompilerOptions());
     auto res = tc::halideCodegenC(halide.stmt);
     for (const auto& e : expected) {
       auto newPos = res.find(e);
@@ -243,8 +244,8 @@ struct TC2Isl : public ::testing::Test {
     DLConstTensorUPtr in = makeDLConstTensor(ti);
 
     // Must reuse the same ctx or memleaks ensue!
-    tc2halide::HalideComponents comps =
-        tc2halide::translate(isl::with_exceptions::globalIslCtx(), tc);
+    tc2halide::HalideComponents comps = tc2halide::translate(
+        isl::with_exceptions::globalIslCtx(), tc, CompilerOptions());
     auto scop =
         polyhedral::Scop::makeScop(isl::with_exceptions::globalIslCtx(), comps);
     polyhedral::detail::validateSchedule(scop->scheduleRoot());

test/test_cuda_mapper.cc

@@ -50,7 +50,7 @@ struct PolyhedralMapperTest : public ::testing::Test {
   std::unique_ptr<Scop> Prepare(std::string tc) {
     auto ctx = isl::with_exceptions::globalIslCtx();
     // Build the SCoP corresponding to the Tc
-    return Scop::makeScop(ctx, tc);
+    return Scop::makeScop(ctx, tc, CompilerOptions());
   }
 
   std::unique_ptr<Scop> PrepareAndJoinBands(std::string tc) {