Use variant

Author: vouillon

src/wasm-ir-builder.h

@@ -238,13 +238,17 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   Module& wasm;
   Function* func;
   Builder builder;
-  // We distinguish three cases:
-  // - no debug location has been specified for the next instruction;
-  //   then this instruction may inherit a debug location from its
-  //   parent or a previous sibling;
-  // - we explicitly specified that this instruction has no debug location;
-  // - we provided a debug location for this instruction.
-  std::optional<std::optional<Function::DebugLocation>> debugLoc;
+
+  // The location lacks debug info as it was marked as not having it.
+  struct NoDebug : public std::monostate {};
+  // The location lacks debug info, but was not marked as not having
+  // it, and it can receive it from the parent or its previous sibling
+  // (if it has one).
+  struct CanReceiveDebug : public std::monostate {};
+  using DebugVariant =
+    std::variant<NoDebug, CanReceiveDebug, Function::DebugLocation>;
+
+  DebugVariant debugLoc;
 
   struct ChildPopper;
 

src/wasm/wasm-ir-builder.cpp

@@ -176,23 +176,29 @@ void IRBuilder::setDebugLocation(
   } else {
     DBG(std::cerr << "setting debugloc to none\n";);
   }
-  debugLoc = loc;
+  if (loc) {
+    debugLoc = *loc;
+  } else {
+    debugLoc = NoDebug();
+  }
 }
 
 void IRBuilder::applyDebugLoc(Expression* expr) {
-  if (debugLoc) {
+  if (!std::get_if<CanReceiveDebug>(&debugLoc)) {
     if (func) {
-      if (*debugLoc) {
-        DBG(std::cerr << "applying debugloc " << *debugLoc->fileIndex << ":"
-                      << *debugLoc->lineNumber << ":" << *debugLoc->columnNumber
+      if (auto* loc = std::get_if<Function::DebugLocation>(&debugLoc)) {
+        DBG(std::cerr << "applying debugloc " << loc->fileIndex << ":"
+                      << loc->lineNumber << ":" << loc->columnNumber
                       << " to expression " << ShallowExpression{expr} << "\n");
+        func->debugLocations[expr] = *loc;
       } else {
+        assert(std::get_if<NoDebug>(&debugLoc));
         DBG(std::cerr << "applying debugloc to expression "
-                      << ShallowExpression{expr} << "\n");
+                  << ShallowExpression{expr} << "\n");
+        func->debugLocations[expr] = std::nullopt;
       }
-      func->debugLocations[expr] = *debugLoc;
     }
-    debugLoc.reset();
+    debugLoc = CanReceiveDebug();
   }
 }
 
@@ -687,10 +693,10 @@ Result<> IRBuilder::visitFunctionStart(Function* func) {
   if (!scopeStack.empty()) {
     return Err{"unexpected start of function"};
   }
-  if (debugLoc && *debugLoc) {
-    func->prologLocation.insert(**debugLoc);
+  if (auto* loc = std::get_if<Function::DebugLocation>(&debugLoc)) {
+    func->prologLocation.insert(*loc);
   }
-  debugLoc.reset();
+  debugLoc = CanReceiveDebug();
   scopeStack.push_back(ScopeCtx::makeFunc(func));
   this->func = func;
   return Ok{};
@@ -728,12 +734,13 @@ Result<> IRBuilder::visitTryTableStart(TryTable* trytable, Name label) {
 }
 
 Result<Expression*> IRBuilder::finishScope(Block* block) {
-  if (debugLoc && *debugLoc) {
-    DBG(std::cerr << "discarding debugloc " << *debugLoc->fileIndex << ":"
-                  << *debugLoc->lineNumber << ":" << *debugLoc->columnNumber
-                  << "\n");
+#if IR_BUILDER_DEBUG
+  if (auto* loc = std::get_if<Function::DebugLocation>(&debugLoc)) {
+    std::cerr << "discarding debugloc " << loc->fileIndex << ":"
+              << loc->lineNumber << ":" << loc->columnNumber << "\n";
   }
-  debugLoc.reset();
+#endif
+  debugLoc = CanReceiveDebug();
 
   if (scopeStack.empty() || scopeStack.back().isNone()) {
     return Err{"unexpected end of scope"};
@@ -918,10 +925,12 @@ Result<> IRBuilder::visitEnd() {
   if (scope.isNone()) {
     return Err{"unexpected end"};
   }
-  if (auto* func = scope.getFunction(); func && debugLoc && *debugLoc) {
-    func->epilogLocation.insert(**debugLoc);
+  if (auto* func = scope.getFunction(); func) {
+    if (auto* loc = std::get_if<Function::DebugLocation>(&debugLoc)) {
+      func->epilogLocation.insert(*loc);
+    }
   }
-  debugLoc.reset();
+  debugLoc = CanReceiveDebug();
   auto expr = finishScope(scope.getBlock());
   CHECK_ERR(expr);