fix(php): keep PHP after comment-ended close tags, CR comments and bare short tags

Addresses CodeRabbit review on PR #34 (internal/cbm/php_inline_html.c and
two test findings).

Inline-HTML masker:
- Line comments now end at a lone CR as well as LF, so CR-only files do
  not scan into the next line and treat `?>` inside a string as a close
  tag.
- A `?>` that ends a `//` or `#` comment used to become `; ` with the
  comment still open, hiding PHP reopened on the same line. The comment
  bytes up to the close tag are now blanked to spaces. Byte offsets and
  rows are unchanged; only that comment's text is lost to the parser.
- With short tags, `<?` followed directly by an identifier (`<?work();`)
  now opens PHP. `<?xml` prologs stay markup.

Tests:
- test_daemon_application: two worker resource-failure tests reused
  th_mktempdir's static buffer for cache and root, so cleanup removed the
  root twice and leaked the cache directory. Both paths are now copied.
- test_pipeline: swift_init_observe leaves init_usages at -1 unless the
  USAGE query succeeds, so a failed query fails the test.
- test_extraction: php_inline_html_comment_close_tag_and_short_tag_masks
  checks exact mask output for these cases and that a function reopened
  after a comment-ended close tag is extracted.

Author: ngallodev

internal/cbm/php_inline_html.c

@@ -31,6 +31,7 @@ enum {
     PHP_TAG_OPEN_LEN = 5,  /* <?php */
     PHP_TAG_ECHO_LEN = 3,  /* <?= */
     PHP_TAG_SHORT_LEN = 2, /* <? */
+    PHP_XML_LEN = 3,       /* xml */
     PHP_HEREDOC_LEN = 3,   /* <<< */
     PHP_FIRST_NON_ASCII = 0x80,
     PHP_NOT_FOUND = -1,
@@ -80,9 +81,15 @@ static bool php_ieq(const char *s, int len, int i, const char *word) {
     return true;
 }
 
+/* True when the identifier at i is `xml` (an XML prolog target). */
+static bool php_xml_prolog(const char *s, int len, int i) {
+    return php_ieq(s, len, i, "xml") &&
+           !(i + PHP_XML_LEN < len && php_is_ident_char((unsigned char)s[i + PHP_XML_LEN]));
+}
+
 /* Length of the open tag at i, or 0. `<?php` needs whitespace or EOF after it
- * and `<?=` is always a tag. A bare `<?` counts only when whitespace follows,
- * so an `<?xml ...?>` prolog in markup stays markup. */
+ * and `<?=` is always a tag. A bare `<?` counts when whitespace or an
+ * identifier follows, except `<?xml`, so an XML prolog in markup stays markup. */
 static int php_open_tag_len(const char *s, int len, int i) {
     if (!php_at(s, len, i, "<?")) {
         return 0;
@@ -98,6 +105,11 @@ static int php_open_tag_len(const char *s, int len, int i) {
     if (after < len && php_is_space((unsigned char)s[after])) {
         return PHP_TAG_SHORT_LEN;
     }
+    /* `<?work();` is a short tag too, but `<?xml` stays an XML prolog. */
+    if (after < len && php_is_ident_start((unsigned char)s[after]) &&
+        !php_xml_prolog(s, len, after)) {
+        return PHP_TAG_SHORT_LEN;
+    }
     return 0;
 }
 
@@ -141,7 +153,7 @@ static int php_skip_block_comment(const char *s, int len, int i) {
 
 /* Index of the line break or `?>` that ends the one-line comment at i. */
 static int php_skip_line_comment(const char *s, int len, int i) {
-    while (i < len && s[i] != '\n' && !php_at(s, len, i, "?>")) {
+    while (i < len && s[i] != '\n' && s[i] != '\r' && !php_at(s, len, i, "?>")) {
         i++;
     }
     return i;
@@ -236,7 +248,8 @@ static int php_skip_ident(const char *s, int len, int i, bool *halt) {
 
 /* Scan PHP code from i to the next close tag. Returns the index of that `?>`,
  * len when the file ends in PHP mode, or PHP_NOT_FOUND at __halt_compiler. */
-static int php_scan_code(const char *s, int len, int i) {
+static int php_scan_code(const char *s, int len, int i, int *comment) {
+    *comment = PHP_NOT_FOUND;
     while (i < len) {
         unsigned char c = (unsigned char)s[i];
         if (php_at(s, len, i, "?>")) {
@@ -247,7 +260,11 @@ static int php_scan_code(const char *s, int len, int i) {
         } else if (php_at(s, len, i, "/*")) {
             i = php_skip_block_comment(s, len, i);
         } else if (php_at(s, len, i, "//") || (c == '#' && !php_at(s, len, i, "#["))) {
+            int start = i;
             i = php_skip_line_comment(s, len, i);
+            if (php_at(s, len, i, "?>")) {
+                *comment = start; /* the close tag ends this comment */
+            }
         } else if (php_at(s, len, i, "<<<")) {
             i = php_skip_heredoc(s, len, i);
         } else if (php_is_ident_start(c)) {
@@ -295,10 +312,15 @@ static void php_mask_blank(PHPMask *m, int from, int to) {
     }
 }
 
-/* Turn the `?>` at i into `; `. */
-static void php_mask_close_tag(PHPMask *m, int i) {
+/* Turn the `?>` at i into `; `. When the tag ends a line comment starting at
+ * `comment`, blank that comment first: `; ` cannot end it and a line break
+ * would shift rows, so the reopened PHP on the same line would be swallowed. */
+static void php_mask_close_tag(PHPMask *m, int i, int comment) {
     char *out = php_mask_writable(m);
     if (out) {
+        if (comment >= 0) {
+            php_blank(out, comment, i);
+        }
         out[i] = ';';
         out[i + SKIP_ONE] = ' ';
     }
@@ -336,11 +358,12 @@ const char *cbm_php_mask_inline_html(CBMArena *arena, const char *source, int so
         seen_open = true;
 
         /* PHP mode, up to the close tag. */
-        int close = php_scan_code(source, source_len, i + tag);
+        int comment = PHP_NOT_FOUND;
+        int close = php_scan_code(source, source_len, i + tag, &comment);
         if (close < 0 || close >= source_len) {
             break;
         }
-        php_mask_close_tag(&m, close);
+        php_mask_close_tag(&m, close, comment);
         i = close + PAIR_LEN;
     }
     /* On allocation failure parse the file as it is: the old behaviour. */

tests/test_daemon_application.c

@@ -2774,7 +2774,9 @@ TEST(daemon_application_programmatic_index_forwards_set_doc_candidates) {
 }
 
 TEST(daemon_application_worker_resource_failure_is_structured_and_not_retried) {
-    char *cache = th_mktempdir("cbm_app_worker_resource_cache");
+    /* th_mktempdir returns one static buffer: copy the cache path. */
+    char *cache_made = th_mktempdir("cbm_app_worker_resource_cache");
+    char *cache = cache_made ? strdup(cache_made) : NULL;
     cbm_config_t *stored_config = cache ? cbm_config_open(cache) : NULL;
     app_fake_worker_context_t fake;
     app_fake_worker_context_init(&fake);
@@ -2799,7 +2801,8 @@ TEST(daemon_application_worker_resource_failure_is_structured_and_not_retried) {
     cbm_daemon_runtime_application_callbacks_t callbacks =
         cbm_daemon_application_runtime_callbacks(application);
     cbm_daemon_runtime_application_session_t *session = app_test_open(&callbacks, 4188);
-    char *root = th_mktempdir("cbm_app_worker_resource");
+    char *root_made = th_mktempdir("cbm_app_worker_resource");
+    char *root = root_made ? strdup(root_made) : NULL;
     uint8_t *context = NULL;
     uint32_t context_length = 0;
     uint8_t *tool = NULL;
@@ -2847,6 +2850,8 @@ TEST(daemon_application_worker_resource_failure_is_structured_and_not_retried) {
     free(tool);
     th_cleanup(root);
     th_cleanup(cache);
+    free(root);
+    free(cache);
 
     ASSERT_TRUE(setup);
     ASSERT_EQ(status, CBM_DAEMON_RUNTIME_APPLICATION_OK);
@@ -2858,7 +2863,9 @@ TEST(daemon_application_worker_resource_failure_is_structured_and_not_retried) {
 }
 
 TEST(daemon_application_worker_resource_failure_after_crash_stops_recovery) {
-    char *cache = th_mktempdir("cbm_app_worker_resource_crash_cache");
+    /* th_mktempdir returns one static buffer: copy the cache path. */
+    char *cache_made = th_mktempdir("cbm_app_worker_resource_crash_cache");
+    char *cache = cache_made ? strdup(cache_made) : NULL;
     cbm_config_t *stored_config = cache ? cbm_config_open(cache) : NULL;
     app_fake_worker_context_t fake;
     app_fake_worker_context_init(&fake);
@@ -2887,7 +2894,8 @@ TEST(daemon_application_worker_resource_failure_after_crash_stops_recovery) {
     cbm_daemon_runtime_application_callbacks_t callbacks =
         cbm_daemon_application_runtime_callbacks(application);
     cbm_daemon_runtime_application_session_t *session = app_test_open(&callbacks, 4189);
-    char *root = th_mktempdir("cbm_app_worker_resource_crash");
+    char *root_made = th_mktempdir("cbm_app_worker_resource_crash");
+    char *root = root_made ? strdup(root_made) : NULL;
     uint8_t *context = NULL;
     uint32_t context_length = 0;
     uint8_t *tool = NULL;
@@ -2935,6 +2943,8 @@ TEST(daemon_application_worker_resource_failure_after_crash_stops_recovery) {
     free(tool);
     th_cleanup(root);
     th_cleanup(cache);
+    free(root);
+    free(cache);
 
     ASSERT_TRUE(setup);
     ASSERT_EQ(status, CBM_DAEMON_RUNTIME_APPLICATION_OK);

tests/test_extraction.c

@@ -1110,6 +1110,37 @@ TEST(php_inline_html_trailing_close_tag_crlf_issue2000) {
     PASS();
 }
 
+/* Standalone CR ends a line comment, so a `?>` inside the next CR-only line's
+ * string is not a close tag; a `?>` that ends a `//` or `#` comment blanks the
+ * comment so the PHP reopened on that line is not swallowed; `<?work();` is a
+ * short tag while `<?xml` stays markup. */
+TEST(php_inline_html_comment_close_tag_and_short_tag_masks) {
+    CBMArena arena;
+    cbm_arena_init(&arena);
+    const char *cr = "<?php\r// note\r$s = '?>';\rfunction a() {}\r";
+    ASSERT(cbm_php_mask_inline_html(&arena, cr, (int)strlen(cr)) == cr);
+
+    const char *cmt = "<?php\n// note ?><?php function b() {}\n";
+    const char *masked = cbm_php_mask_inline_html(&arena, cmt, (int)strlen(cmt));
+    ASSERT_STR_EQ(masked, "<?php\n        ;       function b() {}\n");
+
+    const char *hash = "<?php\n# n ?><?php function c() {}\n";
+    masked = cbm_php_mask_inline_html(&arena, hash, (int)strlen(hash));
+    ASSERT_STR_EQ(masked, "<?php\n    ;       function c() {}\n");
+
+    const char *shorttag = "<?work();\n?>\n<?xml version=\"1.0\"?>\n";
+    masked = cbm_php_mask_inline_html(&arena, shorttag, (int)strlen(shorttag));
+    ASSERT_STR_EQ(masked, "<?work();\n; \n                     \n");
+    cbm_arena_destroy(&arena);
+
+    CBMFileResult *r = extract("<?php\n// note ?><?php function later() { helper(); }\n",
+                               CBM_LANG_PHP, "t", "c.php");
+    ASSERT_NOT_NULL(r);
+    ASSERT(has_def(r, "Function", "later"));
+    cbm_free_result(r);
+    PASS();
+}
+
 /* --- Ruby --- */
 TEST(ruby_class) {
     CBMFileResult *r = extract("class Animal\n  def initialize(name)\n    @name = name\n  end\n  "
@@ -15448,6 +15479,7 @@ SUITE(extraction) {
     RUN_TEST(php_inline_html_markup_never_reaches_graph_issue2000);
     RUN_TEST(php_inline_html_mask_copies_only_on_write_issue2000);
     RUN_TEST(php_inline_html_trailing_close_tag_crlf_issue2000);
+    RUN_TEST(php_inline_html_comment_close_tag_and_short_tag_masks);
     RUN_TEST(ruby_class);
     RUN_TEST(ruby_module);
     RUN_TEST(ruby_constructor_callee_is_constant_path);

tests/test_pipeline.c

@@ -23126,8 +23126,9 @@ static void swift_init_observe(cbm_store_t *s, const char *project, SwiftInitObs
 
     edges = NULL;
     count = 0;
-    o->init_usages = 0;
+    o->init_usages = -1; /* error sentinel until the USAGE query succeeds */
     if (cbm_store_find_edges_by_type(s, project, "USAGE", &edges, &count) == CBM_STORE_OK) {
+        o->init_usages = 0;
         for (int i = 0; i < count; i++) {
             cbm_node_t tgt = {0};
             if (cbm_store_find_node_by_id(s, edges[i].target_id, &tgt) == CBM_STORE_OK &&
@@ -23148,6 +23149,7 @@ static void swift_init_case(bool parallel, int pad, SwiftInitObservation *o) {
     memset(o, 0, sizeof(*o));
     o->run_rc = -1;
     o->calls = -1;
+    o->init_usages = -1;
     char tmp[256];
     snprintf(tmp, sizeof(tmp), "/tmp/cbm_swift_init_XXXXXX");
     if (!cbm_mkdtemp(tmp)) {