decomp: enforce identifier naming convention and address review comments

Author: kumarak

include/patchestry/AST/CfgBuilder.hpp

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <cstdint>
+#include <limits>
 #include <string>
 #include <vector>
 
@@ -29,13 +30,16 @@ namespace patchestry::ast {
 
     // A basic block in the CFG
     struct CfgBlock {
+        static constexpr size_t kNoSucc = std::numeric_limits< size_t >::max();
+
         std::string label;                  // empty if unlabeled entry block
         std::vector< clang::Stmt * > stmts; // statements in the block
         std::vector< size_t > succs;        // successor block indices
         bool is_conditional = false;        // true if block ends with if(cond) goto
         clang::Expr *branch_cond = nullptr; // condition expr if conditional
-        size_t taken_succ = 0;              // index of "then" successor
-        size_t fallthrough_succ = 0;        // index of "else" / fallthrough successor
+        size_t taken_succ        = kNoSucc; // index of "then" successor, or NO_SUCC
+        size_t fallthrough_succ =
+            kNoSucc; // index of "else" / fallthrough successor, or NO_SUCC
         std::vector< SwitchCaseEntry > switch_cases;  // non-empty iff this is a switch block
     };
 

include/patchestry/AST/CfgFoldStructure.hpp

@@ -32,7 +32,7 @@ namespace patchestry::ast {
         /// As rules fire, nodes get absorbed into StructuredNode wrappers and
         /// removed from the active set.
         struct CNode {
-            static constexpr size_t NONE = std::numeric_limits<size_t>::max();
+            static constexpr size_t kNone = std::numeric_limits<size_t>::max();
 
             size_t id;                          // original CfgBlock index
             std::vector<size_t> succs;          // outgoing edges (by CNode id)
@@ -55,47 +55,47 @@ namespace patchestry::ast {
 
             // Set when absorbed into a parent structured node
             bool collapsed = false;
-            size_t collapsed_into = NONE;  // representative node after collapse
+            size_t collapsed_into = kNone;  // representative node after collapse
 
             // Flags for the collapse algorithm
             bool mark = false;
             int visit_count = 0;
 
             enum EdgeFlag : uint32_t {
-                F_GOTO     = 1u << 0,
-                F_BACK     = 1u << 1,
-                F_LOOP_EXIT = 1u << 2,
+                kGoto     = 1u << 0,
+                kBack     = 1u << 1,
+                kLoopExit = 1u << 2,
             };
 
-            bool isGotoOut(size_t i) const {
-                return i < edge_flags.size() && (edge_flags[i] & F_GOTO);
+            bool IsGotoOut(size_t i) const {
+                return i < edge_flags.size() && (edge_flags[i] & kGoto);
             }
-            bool isBackEdge(size_t i) const {
-                return i < edge_flags.size() && (edge_flags[i] & F_BACK);
+            bool IsBackEdge(size_t i) const {
+                return i < edge_flags.size() && (edge_flags[i] & kBack);
             }
-            bool isLoopExit(size_t i) const {
-                return i < edge_flags.size() && (edge_flags[i] & F_LOOP_EXIT);
+            bool IsLoopExit(size_t i) const {
+                return i < edge_flags.size() && (edge_flags[i] & kLoopExit);
             }
-            bool isDecisionOut(size_t i) const {
-                return !isGotoOut(i) && !isBackEdge(i);
+            bool IsDecisionOut(size_t i) const {
+                return !IsGotoOut(i) && !IsBackEdge(i);
             }
             /// Edges to trace in TraceDAG: not back-edges, not loop-exit edges.
-            bool isLoopDAGOut(size_t i) const {
-                return !isBackEdge(i) && !isLoopExit(i);
+            bool IsLoopDagOut(size_t i) const {
+                return !IsBackEdge(i) && !IsLoopExit(i);
             }
-            bool isSwitchOut() const { return succs.size() > 2; }
+            bool IsSwitchOut() const { return succs.size() > 2; }
 
-            size_t sizeIn() const { return preds.size(); }
-            size_t sizeOut() const { return succs.size(); }
+            size_t SizeIn() const { return preds.size(); }
+            size_t SizeOut() const { return succs.size(); }
 
-            void setGoto(size_t i) {
-                if (i < edge_flags.size()) edge_flags[i] |= F_GOTO;
+            void SetGoto(size_t i) {
+                if (i < edge_flags.size()) edge_flags[i] |= kGoto;
             }
-            void setLoopExit(size_t i) {
-                if (i < edge_flags.size()) edge_flags[i] |= F_LOOP_EXIT;
+            void SetLoopExit(size_t i) {
+                if (i < edge_flags.size()) edge_flags[i] |= kLoopExit;
             }
-            void clearLoopExit(size_t i) {
-                if (i < edge_flags.size()) edge_flags[i] &= ~static_cast<uint32_t>(F_LOOP_EXIT);
+            void ClearLoopExit(size_t i) {
+                if (i < edge_flags.size()) edge_flags[i] &= ~static_cast<uint32_t>(kLoopExit);
             }
         };
 
@@ -106,27 +106,27 @@ namespace patchestry::ast {
             size_t entry = 0;
 
             /// Active (uncollapsed) node ids
-            std::vector<size_t> activeIds() const {
+            std::vector<size_t> ActiveIds() const {
                 std::vector<size_t> result;
                 for (auto &n : nodes) {
                     if (!n.collapsed) result.push_back(n.id);
                 }
                 return result;
             }
 
-            size_t activeCount() const {
+            size_t ActiveCount() const {
                 size_t c = 0;
                 for (auto &n : nodes) {
                     if (!n.collapsed) ++c;
                 }
                 return c;
             }
 
-            CNode &node(size_t id) { return nodes[id]; }
-            const CNode &node(size_t id) const { return nodes[id]; }
+            CNode &Node(size_t id) { return nodes[id]; }
+            const CNode &Node(size_t id) const { return nodes[id]; }
 
             /// Remove an edge from the active graph
-            void removeEdge(size_t from, size_t to) {
+            void RemoveEdge(size_t from, size_t to) {
                 auto &s = nodes[from].succs;
                 auto &f = nodes[from].edge_flags;
                 for (size_t i = 0; i < s.size(); ++i) {
@@ -142,58 +142,57 @@ namespace patchestry::ast {
 
             /// Replace a set of nodes with a single new structured node.
             /// Returns the representative node id.
-            size_t collapseNodes(const std::vector<size_t> &ids, SNode *snode);
+            size_t CollapseNodes(const std::vector<size_t> &ids, SNode *snode);
         };
 
         /// Build the collapse graph from a Cfg.
-        CGraph buildCGraph(const Cfg &cfg);
+        CGraph BuildCGraph(const Cfg &cfg);
 
         /// Detect back-edges using DFS and mark them in the graph.
-        void markBackEdges(CGraph &g);
+        void MarkBackEdges(CGraph &g);
 
         /// A detected natural loop: header, back-edge tails, nesting info.
         struct LoopBody {
             size_t head;                          // loop header CNode id
             std::vector<size_t> tails;            // CNode ids with back-edges to head
             int depth = 0;                        // nesting depth (deeper = higher number)
             int unique_count = 0;                 // count of head+tail nodes before reachability
-            size_t exit_block = NONE;             // official exit CNode id, or NONE
+            size_t exit_block = kNone;            // official exit CNode id, or kNone
             LoopBody *immed_container = nullptr;  // immediately containing loop
 
-            static constexpr size_t NONE = std::numeric_limits<size_t>::max();
+            static constexpr size_t kNone = std::numeric_limits<size_t>::max();
 
             explicit LoopBody(size_t h) : head(h) {}
 
-            void addTail(size_t t) { tails.push_back(t); }
+            void AddTail(size_t t) { tails.push_back(t); }
 
             /// Core body computation: backward reachability from tails to head.
             /// Populates `body` with all CNode ids in the loop. Sets CNode::mark.
-            /// Caller MUST call clearMarks() after using the body.
-            void findBase(CGraph &g, std::vector<size_t> &body) const;
+            /// Caller MUST call ClearMarks() after using the body.
+            void FindBase(CGraph &g, std::vector<size_t> &body) const;
 
             /// Set immed_container based on containment within other loops.
-            void labelContainments(const CGraph &g, const std::vector<size_t> &body,
+            void LabelContainments(const CGraph &g, const std::vector<size_t> &body,
                                    const std::vector<LoopBody *> &looporder);
 
             /// Exit detection, tail ordering, body extension, exit edge labeling.
-            /// (Declared here, implemented in Plan 02)
-            void findExit(const CGraph &g, const std::vector<size_t> &body);
-            void orderTails(const CGraph &g);
-            void extend(CGraph &g, std::vector<size_t> &body) const;
-            void labelExitEdges(CGraph &g, const std::vector<size_t> &body) const;
+            void FindExit(const CGraph &g, const std::vector<size_t> &body);
+            void OrderTails(const CGraph &g);
+            void Extend(CGraph &g, std::vector<size_t> &body) const;
+            void LabelExitEdges(CGraph &g, const std::vector<size_t> &body) const;
 
             /// Merge LoopBody records that share the same head.
-            static void mergeIdenticalHeads(std::vector<LoopBody *> &looporder,
+            static void MergeIdenticalHeads(std::vector<LoopBody *> &looporder,
                                             std::list<LoopBody> &storage);
 
-            /// Mark edges leaving the loop body as F_LOOP_EXIT.
-            void setExitMarks(CGraph &g, const std::vector<size_t> &body) const;
+            /// Mark edges leaving the loop body as kLoopExit.
+            void SetExitMarks(CGraph &g, const std::vector<size_t> &body) const;
 
-            /// Clear F_LOOP_EXIT marks set by setExitMarks.
-            void clearExitMarks(CGraph &g, const std::vector<size_t> &body) const;
+            /// Clear kLoopExit marks set by SetExitMarks.
+            void ClearExitMarks(CGraph &g, const std::vector<size_t> &body) const;
 
             /// Check if this loop's head is still active (not collapsed).
-            bool update(const CGraph &g) const;
+            bool Update(const CGraph &g) const;
 
             /// Sort innermost-first (higher depth = processed first).
             bool operator<(const LoopBody &other) const {
@@ -209,8 +208,8 @@ namespace patchestry::ast {
             FloatingEdge(size_t t, size_t b) : top_id(t), bottom_id(b) {}
 
             /// Resolve to current edge in graph. Returns {source_id, edge_index},
-            /// or {CNode::NONE, 0} if the edge no longer exists.
-            std::pair<size_t, size_t> getCurrentEdge(const CGraph &g) const;
+            /// or {CNode::kNone, 0} if the edge no longer exists.
+            std::pair<size_t, size_t> GetCurrentEdge(const CGraph &g) const;
         };
 
         /// TraceDAG: traces DAG paths through the CGraph to identify
@@ -226,23 +225,23 @@ namespace patchestry::ast {
                 int depth = 0;
                 bool ismark = false;
 
-                void markPath();
-                int distance(BranchPoint *op2);
+                void MarkPath();
+                int Distance(BranchPoint *op2);
             };
 
             struct BlockTrace {
-                enum : uint32_t { f_active = 1, f_terminal = 2 };
+                enum : uint32_t { kActive = 1, kTerminal = 2 };
                 uint32_t flags = 0;
                 BranchPoint *top;
                 int pathout;
-                size_t bottom_id;      // CNode id (or NONE for root traces)
+                size_t bottom_id;      // CNode id (or kNone for root traces)
                 size_t dest_id;        // destination CNode id
                 int edgelump = 1;
                 std::list<BlockTrace *>::iterator activeiter;
                 BranchPoint *derivedbp = nullptr;
 
-                bool isActive() const { return flags & f_active; }
-                bool isTerminal() const { return flags & f_terminal; }
+                bool IsActive() const { return flags & kActive; }
+                bool IsTerminal() const { return flags & kTerminal; }
             };
 
             struct BadEdgeScore {
@@ -252,52 +251,52 @@ namespace patchestry::ast {
                 int terminal = 0;
                 int siblingedge = 0;
 
-                bool compareFinal(const BadEdgeScore &op2) const;
+                bool CompareFinal(const BadEdgeScore &op2) const;
                 bool operator<(const BadEdgeScore &op2) const;
             };
 
-            std::list<FloatingEdge> &likelygoto;
-            std::vector<size_t> rootlist;
-            std::vector<BranchPoint *> branchlist;
-            int activecount = 0;
-            std::list<BlockTrace *> activetrace;
-            std::list<BlockTrace *>::iterator current_activeiter;
-            size_t finishblock_id = CNode::NONE;
+            std::list<FloatingEdge> &likelygoto_;
+            std::vector<size_t> rootlist_;
+            std::vector<BranchPoint *> branchlist_;
+            int activecount_ = 0;
+            std::list<BlockTrace *> activetrace_;
+            std::list<BlockTrace *>::iterator current_activeiter_;
+            size_t finishblock_id_ = CNode::kNone;
 
-            void removeTrace(BlockTrace *trace);
-            void processExitConflict(std::list<BadEdgeScore>::iterator start,
+            void RemoveTrace(BlockTrace *trace);
+            void ProcessExitConflict(std::list<BadEdgeScore>::iterator start,
                                      std::list<BadEdgeScore>::iterator end);
-            BlockTrace *selectBadEdge();
-            void insertActive(BlockTrace *trace);
-            void removeActive(BlockTrace *trace);
-            bool checkOpen(const CGraph &g, BlockTrace *trace);
-            std::list<BlockTrace *>::iterator openBranch(CGraph &g,
+            BlockTrace *SelectBadEdge();
+            void InsertActive(BlockTrace *trace);
+            void RemoveActive(BlockTrace *trace);
+            bool CheckOpen(const CGraph &g, BlockTrace *trace);
+            std::list<BlockTrace *>::iterator OpenBranch(CGraph &g,
                                                          BlockTrace *parent);
-            bool checkRetirement(BlockTrace *trace, size_t &exitblock_id);
-            std::list<BlockTrace *>::iterator retireBranch(BranchPoint *bp,
+            bool CheckRetirement(BlockTrace *trace, size_t &exitblock_id);
+            std::list<BlockTrace *>::iterator RetireBranch(BranchPoint *bp,
                                                            size_t exitblock_id);
-            void clearVisitCount(CGraph &g);
+            void ClearVisitCount(CGraph &g);
 
         public:
-            TraceDAG(std::list<FloatingEdge> &lg) : likelygoto(lg) {}
+            TraceDAG(std::list<FloatingEdge> &lg) : likelygoto_(lg) {}
             ~TraceDAG();
 
-            void addRoot(size_t root_id) { rootlist.push_back(root_id); }
-            void setFinishBlock(size_t id) { finishblock_id = id; }
-            void initialize();
-            void pushBranches(CGraph &g);
+            void AddRoot(size_t root_id) { rootlist_.push_back(root_id); }
+            void SetFinishBlock(size_t id) { finishblock_id_ = id; }
+            void Initialize();
+            void PushBranches(CGraph &g);
         };
 
         /// Clear CNode::mark for all nodes in body vector.
-        void clearMarks(CGraph &g, const std::vector<size_t> &body);
+        void ClearMarks(CGraph &g, const std::vector<size_t> &body);
 
         /// Scan back-edges and create LoopBody records.
-        void labelLoops(CGraph &g, std::list<LoopBody> &loopbody,
+        void LabelLoops(CGraph &g, std::list<LoopBody> &loopbody,
                         std::vector<LoopBody *> &looporder);
 
         /// Discover all loops, compute bodies/nesting/exits, and order innermost-first.
-        /// Called once from CfgFoldStructure() after markBackEdges().
-        void orderLoopBodies(CGraph &g, std::list<LoopBody> &loopbody);
+        /// Called once from CfgFoldStructure() after MarkBackEdges().
+        void OrderLoopBodies(CGraph &g, std::list<LoopBody> &loopbody);
 
     } // namespace detail
 

include/patchestry/AST/ClangEmitter.hpp

@@ -16,12 +16,12 @@ namespace patchestry::ast {
 
     // Convert an SNode tree back to a Clang CompoundStmt and set it as the
     // function body.
-    void emitClangAST(SNode *root, clang::FunctionDecl *fn,
+    void EmitClangAST(SNode *root, clang::FunctionDecl *fn,
                       clang::ASTContext &ctx);
 
     // Post-emission cleanup for prettier C output.
     // Flattens nested CompoundStmts and pushes LabelStmts inside
     // CompoundStmt bodies. Only call for patchir-decomp path.
-    void cleanupPrettyPrint(clang::FunctionDecl *fn, clang::ASTContext &ctx);
+    void CleanupPrettyPrint(clang::FunctionDecl *fn, clang::ASTContext &ctx);
 
 } // namespace patchestry::ast