From db68bae222b835f8190013dca45854c7cc07dadf Mon Sep 17 00:00:00 2001
From: Ashley Nelson <nashley@google.com>
Date: Wed, 4 Oct 2023 11:25:56 -0700
Subject: [Outlining] Adds separator context (#5977)

Adds a std::variant to represent the context of why a unique symbol was inserted in the stringified module. This allows us to pass necessary contextual data to subclasses of StringifyWalker in a structured manner.
---
 src/passes/stringify-walker.h | 101 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 99 insertions(+), 2 deletions(-)

(limited to 'src/passes/stringify-walker.h')

diff --git a/src/passes/stringify-walker.h b/src/passes/stringify-walker.h
index c20d250ec..129021bc4 100644
--- a/src/passes/stringify-walker.h
+++ b/src/passes/stringify-walker.h
@@ -66,6 +66,103 @@ struct StringifyWalker
 
   using Super = PostWalker<SubType, UnifiedExpressionVisitor<SubType>>;
 
+  struct SeparatorReason {
+    struct FuncStart {
+      Function* func;
+    };
+
+    struct BlockStart {
+      Block* curr;
+    };
+
+    struct IfStart {
+      If* iff;
+    };
+
+    struct ElseStart {
+      If* iff;
+    };
+
+    struct LoopStart {
+      Loop* loop;
+    };
+
+    struct TryBodyStart {};
+
+    struct TryCatchStart {};
+
+    struct End {
+      Expression* curr;
+    };
+    using Separator = std::variant<FuncStart,
+                                   BlockStart,
+                                   IfStart,
+                                   ElseStart,
+                                   LoopStart,
+                                   TryBodyStart,
+                                   TryCatchStart,
+                                   End>;
+
+    Separator reason;
+
+    SeparatorReason(Separator reason) : reason(reason) {}
+
+    static SeparatorReason makeFuncStart(Function* func) {
+      return SeparatorReason(FuncStart{func});
+    }
+    static SeparatorReason makeBlockStart(Block* block) {
+      return SeparatorReason(BlockStart{block});
+    }
+    static SeparatorReason makeIfStart(If* iff) {
+      return SeparatorReason(IfStart{iff});
+    }
+    static SeparatorReason makeElseStart(If* iff) {
+      return SeparatorReason(ElseStart{iff});
+    }
+    static SeparatorReason makeLoopStart(Loop* loop) {
+      return SeparatorReason(LoopStart{loop});
+    }
+    static SeparatorReason makeTryCatchStart() {
+      return SeparatorReason(TryCatchStart{});
+    }
+    static SeparatorReason makeTryBodyStart() {
+      return SeparatorReason(TryBodyStart{});
+    }
+    static SeparatorReason makeEnd() { return SeparatorReason(End{}); }
+    bool isFuncStart() { return std::get_if<FuncStart>(&reason); }
+    bool isBlockStart() { return std::get_if<BlockStart>(&reason); }
+    bool isIfStart() { return std::get_if<IfStart>(&reason); }
+    bool isElseStart() { return std::get_if<ElseStart>(&reason); }
+    bool isLoopStart() { return std::get_if<LoopStart>(&reason); }
+    bool isTryBodyStart() { return std::get_if<TryBodyStart>(&reason); }
+    bool isTryCatchStart() { return std::get_if<TryCatchStart>(&reason); }
+    bool isEnd() { return std::get_if<End>(&reason); }
+  };
+
+  friend std::ostream&
+  operator<<(std::ostream& o,
+             typename StringifyWalker::SeparatorReason reason) {
+    if (reason.isFuncStart()) {
+      return o << "Func Start";
+    } else if (reason.isBlockStart()) {
+      return o << "Block Start";
+    } else if (reason.isIfStart()) {
+      return o << "If Start";
+    } else if (reason.isElseStart()) {
+      return o << "Else Start";
+    } else if (reason.isLoopStart()) {
+      return o << "Loop Start";
+    } else if (reason.isTryBodyStart()) {
+      return o << "Try Body Start";
+    } else if (reason.isTryCatchStart()) {
+      return o << "Try Catch Start";
+    } else if (reason.isEnd()) {
+      return o << "End";
+    }
+
+    return o << "~~~Undefined in operator<< overload~~~";
+  }
+
   std::queue<Expression**> controlFlowQueue;
 
   /*
@@ -77,7 +174,7 @@ struct StringifyWalker
    * appropriate points during the walk and should be implemented by subclasses.
    */
   void visitExpression(Expression* curr);
-  void addUniqueSymbol();
+  void addUniqueSymbol(SeparatorReason reason);
 
   void doWalkModule(Module* module);
   void doWalkFunction(Function* func);
@@ -130,7 +227,7 @@ struct HashStringifyWalker : public StringifyWalker<HashStringifyWalker> {
   std::unordered_map<Expression*, uint32_t, StringifyHasher, StringifyEquator>
     exprToCounter;
 
-  void addUniqueSymbol();
+  void addUniqueSymbol(SeparatorReason reason);
   void visitExpression(Expression* curr);
 };
 
-- 
cgit v1.2.3