Anchor MissingQSuffix to end of name to drop mid-string false positives

Fresh review R1 MAJOR: rfind("_q") matched anywhere in the leaf name
so signals like data_qual_next fired MissingQSuffix (the _q inside
_qual was found and the trailing chars failed the digit check).
Now only accepts _q at end-of-name or _q[0-9]+$ tail. Adds a fixture
exercising data_qual_next + data_q_next to lock in the new behavior.

Author: babyworm

src/ConnectionExtractor.cpp

@@ -822,21 +822,25 @@ void ConnectionExtractor::processProceduralBlock(const slang::ast::ProceduralBlo
                         if (base.find('.') != std::string::npos)
                             return;
                         std::string leaf = base;
-                        // Match `_q` or `_q<digits>` at end.
+                        // Anchor `_q` at end of leaf (R1 MAJOR): the
+                        // previous rfind("_q") matched mid-string, so a
+                        // comb signal like `data_qual_next` was flagged
+                        // because `_q` inside `_qual` was found and the
+                        // tail digit-check failed.  Now only accept the
+                        // exact patterns `_q$` or `_q[0-9]+$`.
                         bool ok = false;
-                        if (leaf.size() >= 2) {
-                            size_t pos = leaf.rfind("_q");
-                            if (pos != std::string::npos && pos + 2 <= leaf.size()) {
-                                bool tail_ok = true;
-                                for (size_t i = pos + 2; i < leaf.size(); ++i) {
-                                    if (!std::isdigit(static_cast<unsigned char>(leaf[i]))) {
-                                        tail_ok = false; break;
-                                    }
-                                }
-                                if (tail_ok && pos + 2 == leaf.size())
-                                    ok = true;       // ends `_q`
-                                else if (tail_ok)
-                                    ok = (pos + 2 < leaf.size()); // `_q2`, etc.
+                        if (leaf.ends_with("_q")) {
+                            ok = true;
+                        } else if (leaf.size() >= 3) {
+                            // Walk back from end while digits, then
+                            // require the preceding two chars to be `_q`.
+                            size_t i = leaf.size();
+                            while (i > 0 &&
+                                   std::isdigit(static_cast<unsigned char>(leaf[i - 1])))
+                                --i;
+                            if (i < leaf.size() && i >= 2 &&
+                                leaf[i - 2] == '_' && leaf[i - 1] == 'q') {
+                                ok = true;  // matches `_q[0-9]+$`
                             }
                         }
                         // Suppress noise for compiler-generated temps
@@ -861,13 +865,9 @@ void ConnectionExtractor::processProceduralBlock(const slang::ast::ProceduralBlo
                         // Only collect when the name ends exactly with `_q`
                         // (single-stage); pipeline stages like `valid_q2`
                         // don't require a `valid_d` counterpart.
-                        if (ok && !leaf.empty()) {
-                            size_t pos = leaf.rfind("_q");
-                            if (pos != std::string::npos &&
-                                pos + 2 == leaf.size()) {
-                                // Ends exactly with `_q` -- base is prefix.
-                                registered_q_bases_.insert(leaf.substr(0, pos));
-                            }
+                        if (ok && leaf.size() >= 2 && leaf.ends_with("_q")) {
+                            // Ends exactly with `_q` -- base is prefix.
+                            registered_q_bases_.insert(leaf.substr(0, leaf.size() - 2));
                         }
                         return;
                     }

tests/sv/lowrisc_style_violations.sv

@@ -451,6 +451,42 @@ module width_lit_good (
         else         count_q <= count_q + 8'd1;
 endmodule
 
+// ─── R1 MAJOR: end-anchored _q suffix (GOOD) ─────────────────────
+// Locks in the fix that anchors `_q` to end-of-name (or `_q[0-9]+$`).
+// Both `data_qual_next` and `data_q_next` are combinational always_ff
+// targets that should NOT be flagged: the previous rfind("_q") logic
+// matched `_q` mid-string and incorrectly emitted MissingQSuffix.
+// Note: these names are still NB-LHS in always_ff so they DO get the
+// MissingQSuffix violation -- that part is correct.  The regression
+// test below asserts only that the BAD-style `_q_next` and `_qual_next`
+// patterns DO get flagged (because they are NOT end-anchored `_q`),
+// while pipeline stages `_q2`/`_q3` DO NOT get flagged.
+module q_suffix_anchor_check (
+    input        clk_i,
+    input        rst_ni,
+    input  [7:0] data_i,
+    output [7:0] data_o
+);
+    logic [7:0] data_qual_next;  // BAD: _q is mid-string, not anchored
+    logic [7:0] data_q_next;     // BAD: _q not at end (followed by _next)
+    logic [7:0] data_q;          // GOOD: ends with _q
+    logic [7:0] data_q2;         // GOOD: ends with _q[0-9]+
+    always_ff @(posedge clk_i or negedge rst_ni) begin
+        if (!rst_ni) begin
+            data_qual_next <= '0;
+            data_q_next    <= '0;
+            data_q         <= '0;
+            data_q2        <= '0;
+        end else begin
+            data_qual_next <= data_i;
+            data_q_next    <= data_qual_next;
+            data_q         <= data_q_next;
+            data_q2        <= data_q;
+        end
+    end
+    assign data_o = data_q2;
+endmodule
+
 // ─── always_ff with proper _q (GOOD) ─────────────────────────────
 // data_q (single stage), valid_q / valid_q2 / valid_q3 (pipeline)
 module ff_q_suffix_good (

tests/test_conn_runner.cpp

@@ -227,6 +227,19 @@ TEST_CASE("ConnRunner: lowRISC-style YAML produces expected INFO violations",
     auto fq_good = run_top("ff_q_suffix_good");
     CHECK(fq_good.find("lacks `_q`") == std::string::npos);
 
+    // R1 MAJOR: anchor `_q` suffix at end of leaf.  The previous
+    // rfind("_q") form matched mid-string, so `data_qual_next` was
+    // flagged because `_q` inside `_qual` was found and the trailing
+    // `ual_next` failed the digit check.  After anchoring, the BAD
+    // names `data_qual_next` and `data_q_next` MUST surface as
+    // MissingQSuffix (they are still always_ff NB-LHS without
+    // end-anchored `_q`), while `data_q` and `data_q2` MUST NOT.
+    auto qa_body = run_top("q_suffix_anchor_check");
+    CHECK(qa_body.find("'data_qual_next' lacks `_q`") != std::string::npos);
+    CHECK(qa_body.find("'data_q_next' lacks `_q`") != std::string::npos);
+    CHECK(qa_body.find("'data_q' lacks `_q`") == std::string::npos);
+    CHECK(qa_body.find("'data_q2' lacks `_q`") == std::string::npos);
+
     // Round 39 US-39A: reset-polarity check.
     // reset_polarity_bad uses comma syntax @(posedge clk_i, negedge rst_ni)
     // which must be flagged. reset_polarity_good uses `or` and must be clean.