rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/spinel_parse.c

@@ -20,31 +20,64 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
+#include <limits.h>
 #include <prism.h>
 
 /* ---- Output buffer ---- */
 static char **lines;
-static int line_count;
-static int line_cap;
+static size_t line_count;
+static size_t line_cap;
 static int node_counter;
 
 static void out_add(const char *fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
-  char buf[4096];
-  vsnprintf(buf, sizeof(buf), fmt, ap);
+  va_list ap2;
+  va_copy(ap2, ap);
+  int needed = vsnprintf(NULL, 0, fmt, ap);
   va_end(ap);
+  if (needed < 0) {
+    va_end(ap2);
+    fprintf(stderr, "spinel_parse: vsnprintf failed\n");
+    exit(1);
+  }
+  char *buf = malloc((size_t)needed + 1);
+  if (!buf) {
+    va_end(ap2);
+    fprintf(stderr, "spinel_parse: out of memory\n");
+    exit(1);
+  }
+  vsnprintf(buf, (size_t)needed + 1, fmt, ap2);
+  va_end(ap2);
   if (line_count >= line_cap) {
-    line_cap = line_cap * 2 + 256;
-    lines = realloc(lines, sizeof(char *) * line_cap);
+    if (line_cap > (((size_t)-1) - 256) / 2) {
+      fprintf(stderr, "spinel_parse: out of memory\n");
+      exit(1);
+    }
+    size_t new_cap = line_cap * 2 + 256;
+    char **new_lines = realloc(lines, sizeof(char *) * new_cap);
+    if (!new_lines) { fprintf(stderr, "spinel_parse: out of memory\n"); exit(1); }
+    lines = new_lines;
+    line_cap = new_cap;
   }
-  lines[line_count++] = strdup(buf);
+  lines[line_count++] = buf;
 }
 
 /* ---- Name from constant pool ---- */
 static const pm_parser_t *g_parser;
 static const char *g_source_file = "";
 static char *g_source_file_escaped = NULL;  /* escape_str(g_source_file), set once at init */
+/* Debug builds: when SPINEL_DEBUG=1, flatten() emits a per-node
+   `node_line` field so codegen can place C `#line` directives. Off by
+   default so the AST text format (and golden tests) are unchanged. */
+static int g_emit_line = 0;
+/* Debug multi-file source map, populated by sp_build_line_map() before
+   flatten() runs and read in flatten() to attribute each node to its
+   original file/line. Declared here because flatten() precedes the
+   require-resolution machinery that defines the builder. */
+static int *sp_line_file = NULL;  /* buffer line (1-based) -> file id */
+static int *sp_line_orig = NULL;  /* buffer line (1-based) -> original line */
+static int sp_line_map_n = 0;
 
 static char *cstr(pm_constant_id_t id) {
   if (id == 0) return strdup("");
@@ -67,6 +100,11 @@ static char *escape_str(const uint8_t *src, size_t len) {
     else if (c == '\r') { out[j++]='%'; out[j++]='0'; out[j++]='D'; }
     else if (c == '\t') { out[j++]='%'; out[j++]='0'; out[j++]='9'; }
     else if (c == ' ')  { out[j++]='%'; out[j++]='2'; out[j++]='0'; }
+    /* Issue #722: NUL byte inside a string literal would truncate
+       the field at the AST text-serialization layer (lines split
+       on '\n' and the loader uses strlen on fields). Encode as %00
+       so the byte survives the round-trip. */
+    else if (c == 0)    { out[j++]='%'; out[j++]='0'; out[j++]='0'; }
     else out[j++] = c;
   }
   out[j] = '\0';
@@ -107,11 +145,21 @@ static void emit_int(int id, const char *field, long long val) {
 }
 
 static void emit_float(int id, const char *field, double val) {
+  /* Issue #766: 64-byte buf; "%.17g" produces at most 24 chars, plus
+     ".0" trailer = 26. Safe by margin.
+     Issue #767: snprintf is locale-sensitive (de_DE produces "3,14"
+     for 3.14, which then fails to parse as a C float literal).
+     Format into a fresh sprintf via the C locale by using a manual
+     dot conversion: produce in current locale then replace ',' -> '.'.
+     The lib-side replacement is safe because Ruby float literals never
+     contain a comma. */
   char buf[64];
   snprintf(buf, sizeof(buf), "%.17g", val);
-  /* Ensure there's a decimal point (Ruby outputs 0.0, not 0) */
-  if (!strchr(buf, '.') && !strchr(buf, 'e') && !strchr(buf, 'E'))
-    strcat(buf, ".0");
+  for (char *p = buf; *p; p++) if (*p == ',') *p = '.';
+  if (!strchr(buf, '.') && !strchr(buf, 'e') && !strchr(buf, 'E')) {
+    size_t l = strlen(buf);
+    if (l + 3 < sizeof(buf)) strcat(buf, ".0");
+  }
   out_add("F %d %s %s", id, field, buf);
 }
 
@@ -128,30 +176,60 @@ static void emit_node_array(int id, const char *field, pm_node_list_t *list) {
   int *ids = malloc(sizeof(int) * list->size);
   for (size_t i = 0; i < list->size; i++)
     ids[i] = flatten(list->nodes[i]);
-  /* Build comma-separated string */
-  char buf[65536];
-  int pos = 0;
+  /* Issue #744: build comma-separated string into a growable buffer.
+     Previously a fixed 65536-byte stack buffer overflowed on
+     20k+-element arrays -- snprintf returns the bytes it WOULD have
+     written, advancing pos past the end and corrupting the stack. */
+  size_t cap = 1024;
+  char *buf = malloc(cap);
+  size_t pos = 0;
   for (size_t i = 0; i < list->size; i++) {
+    /* worst case per iter: ", -2147483648\0" -> 14 bytes; reserve 16 to be safe */
+    if (pos + 16 >= cap) {
+      size_t new_cap = cap * 2 + 16;
+      char *nb = realloc(buf, new_cap);
+      if (!nb) { fprintf(stderr, "spinel_parse: out of memory\n"); exit(1); }
+      buf = nb;
+      cap = new_cap;
+    }
     if (i > 0) buf[pos++] = ',';
-    pos += snprintf(buf + pos, sizeof(buf) - pos, "%d", ids[i]);
+    int n = snprintf(buf + pos, cap - pos, "%d", ids[i]);
+    if (n > 0) pos += (size_t)n;
   }
   buf[pos] = '\0';
   out_add("A %d %s %s", id, field, buf);
+  free(buf);
   free(ids);
 }
 
 /* ---- Integer value extraction ---- */
 static long long pm_int_value(pm_integer_t *integer) {
-  long long val = 0;
-  if (integer->length == 0) {
-    val = (long long)integer->value;
+  uint64_t val = 0;
+  uint64_t max_positive = (uint64_t)LLONG_MAX;
+  uint64_t max_negative = max_positive + 1ULL;
+  const size_t limb_bits = 32;
+  const size_t value_bits = sizeof(val) * CHAR_BIT;
+  int overflow = 0;
+
+  if (integer->values == NULL) {
+    val = (uint64_t)integer->value;
   } else {
-    /* Large integer - approximate with first word */
-    val = (long long)integer->value;
-    /* TODO: proper bignum support */
+    for (size_t i = 0; i < integer->length; i++) {
+      if (i >= value_bits / limb_bits) {
+        if (integer->values[i] != 0) overflow = 1;
+        continue;
+      }
+      size_t shift = i * limb_bits;
+      val |= ((uint64_t)integer->values[i]) << shift;
+    }
+  }
+
+  if (integer->negative) {
+    if (overflow || val >= max_negative) return LLONG_MIN;
+    return -(long long)val;
   }
-  if (integer->negative) val = -val;
-  return val;
+  if (overflow || val > max_positive) return LLONG_MAX;
+  return (long long)val;
 }
 
 /* ---- Main flattening ---- */
@@ -161,6 +239,30 @@ static int flatten(pm_node_t *node) {
   int id = node_counter++;
   pm_node_type_t t = PM_NODE_TYPE(node);
 
+  /* Debug builds only: stamp every node with its source line — and, when a
+     multi-file map was built, its original file — so codegen can emit
+     `#line N "file"` directives. Written to dedicated `node_line` /
+     `node_file` fields (NOT the overloaded `value`/`start_line` slot). The
+     raw value is the line in the concatenated buffer; the map translates it
+     back to the original file and line. */
+  if (g_emit_line) {
+    pm_line_column_t lc = pm_newline_list_line_column(&g_parser->newline_list,
+                                                      node->location.start,
+                                                      g_parser->start_line);
+    int32_t bl = lc.line;
+    int orig = bl;
+    int fid = 0;
+    if (sp_line_map_n > 0 && bl >= 1 && bl <= sp_line_map_n) {
+      orig = sp_line_orig[bl];
+      fid = sp_line_file[bl];
+    }
+    emit_int(id, "node_line", (long long)orig);
+    emit_int(id, "node_file", (long long)fid);
+    /* Column is concatenation-stable (require splicing is line-based), so the
+       buffer column equals the original-file column. 0-based, as Prism gives. */
+    emit_int(id, "node_col", (long long)lc.column);
+  }
+
 #define N(type_name) out_add("N %d " type_name, id)
 #define S(field, val) do { char *_e = (val); emit_str(id, field, _e); free(_e); } while(0)
 #define I(field, val) emit_int(id, field, val)
@@ -227,8 +329,12 @@ static int flatten(pm_node_t *node) {
     R("receiver", n->receiver);
     R("arguments", n->arguments);
     R("block", n->block);
+    /* Issue #793: emit explicit call_operator for non-safe-nav calls
+       too, so codegen reads "." instead of an unset field. */
     if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
       S("call_operator", escape_str((const uint8_t *)"&.", 2));
+    } else {
+      S("call_operator", escape_str((const uint8_t *)".", 1));
     }
     break;
   }
@@ -246,6 +352,50 @@ static int flatten(pm_node_t *node) {
     R("target", n->target);
     break;
   }
+  case PM_CONSTANT_OPERATOR_WRITE_NODE: {
+    pm_constant_operator_write_node_t *n = (pm_constant_operator_write_node_t *)node;
+    N("ConstantOperatorWriteNode");
+    NAME("name", n->name);
+    NAME("binary_operator", n->binary_operator);
+    R("value", n->value);
+    break;
+  }
+  case PM_CONSTANT_OR_WRITE_NODE: {
+    pm_constant_or_write_node_t *n = (pm_constant_or_write_node_t *)node;
+    N("ConstantOrWriteNode");
+    NAME("name", n->name);
+    R("value", n->value);
+    break;
+  }
+  case PM_CONSTANT_AND_WRITE_NODE: {
+    pm_constant_and_write_node_t *n = (pm_constant_and_write_node_t *)node;
+    N("ConstantAndWriteNode");
+    NAME("name", n->name);
+    R("value", n->value);
+    break;
+  }
+  case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
+    pm_constant_path_operator_write_node_t *n = (pm_constant_path_operator_write_node_t *)node;
+    N("ConstantPathOperatorWriteNode");
+    NAME("binary_operator", n->binary_operator);
+    R("value", n->value);
+    R("target", (pm_node_t *)n->target);
+    break;
+  }
+  case PM_CONSTANT_PATH_OR_WRITE_NODE: {
+    pm_constant_path_or_write_node_t *n = (pm_constant_path_or_write_node_t *)node;
+    N("ConstantPathOrWriteNode");
+    R("value", n->value);
+    R("target", (pm_node_t *)n->target);
+    break;
+  }
+  case PM_CONSTANT_PATH_AND_WRITE_NODE: {
+    pm_constant_path_and_write_node_t *n = (pm_constant_path_and_write_node_t *)node;
+    N("ConstantPathAndWriteNode");
+    R("value", n->value);
+    R("target", (pm_node_t *)n->target);
+    break;
+  }
   case PM_CONSTANT_READ_NODE: {
     pm_constant_read_node_t *n = (pm_constant_read_node_t *)node;
     N("ConstantReadNode");
@@ -332,6 +482,19 @@ static int flatten(pm_node_t *node) {
     NAME("name", n->name);
     break;
   }
+  case PM_CLASS_VARIABLE_TARGET_NODE: {
+    pm_class_variable_target_node_t *n = (pm_class_variable_target_node_t *)node;
+    N("ClassVariableTargetNode");
+    NAME("name", n->name);
+    break;
+  }
+  case PM_CONSTANT_PATH_TARGET_NODE: {
+    pm_constant_path_target_node_t *n = (pm_constant_path_target_node_t *)node;
+    N("ConstantPathTargetNode");
+    R("parent", n->parent);
+    NAME("name", n->name);
+    break;
+  }
   case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
     pm_instance_variable_and_write_node_t *n = (pm_instance_variable_and_write_node_t *)node;
     N("InstanceVariableAndWriteNode");
@@ -367,6 +530,28 @@ static int flatten(pm_node_t *node) {
     NAME("name", n->name);
     break;
   }
+  case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
+    pm_class_variable_operator_write_node_t *n = (pm_class_variable_operator_write_node_t *)node;
+    N("ClassVariableOperatorWriteNode");
+    NAME("name", n->name);
+    NAME("binary_operator", n->binary_operator);
+    R("value", n->value);
+    break;
+  }
+  case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
+    pm_class_variable_or_write_node_t *n = (pm_class_variable_or_write_node_t *)node;
+    N("ClassVariableOrWriteNode");
+    NAME("name", n->name);
+    R("value", n->value);
+    break;
+  }
+  case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
+    pm_class_variable_and_write_node_t *n = (pm_class_variable_and_write_node_t *)node;
+    N("ClassVariableAndWriteNode");
+    NAME("name", n->name);
+    R("value", n->value);
+    break;
+  }
   case PM_INDEX_OPERATOR_WRITE_NODE: {
     pm_index_operator_write_node_t *n = (pm_index_operator_write_node_t *)node;
     N("IndexOperatorWriteNode");
@@ -496,6 +681,29 @@ static int flatten(pm_node_t *node) {
     F("value", n->value);
     break;
   }
+  case PM_IMAGINARY_NODE: {
+    /* `2i` -- imaginary numeric. Issue #840. Wraps an inner
+       IntegerNode or FloatNode in `numeric`. Codegen surfaces this
+       as a sp_Complex literal {re=0, im=numeric}. */
+    pm_imaginary_node_t *n = (pm_imaginary_node_t *)node;
+    N("ImaginaryNode");
+    R("numeric", n->numeric);
+    break;
+  }
+  case PM_RATIONAL_NODE: {
+    /* `1/2r` or `1.5r` -- rational literal. Issue #841. Emits
+       numerator + denominator as decimal-text fields (loader pins
+       them in @nd_rat_num / @nd_rat_den). Prism stores both as
+       reduced pm_integer_t. */
+    pm_rational_node_t *n = (pm_rational_node_t *)node;
+    N("RationalNode");
+    char nbuf[32];
+    snprintf(nbuf, sizeof(nbuf), "%lld", (long long)pm_int_value(&n->numerator));
+    emit_str(id, "rat_num", nbuf);
+    snprintf(nbuf, sizeof(nbuf), "%lld", (long long)pm_int_value(&n->denominator));
+    emit_str(id, "rat_den", nbuf);
+    break;
+  }
   case PM_STRING_NODE: {
     pm_string_node_t *n = (pm_string_node_t *)node;
     N("StringNode");
@@ -687,12 +895,18 @@ static int flatten(pm_node_t *node) {
     R("arguments", n->arguments);
     break;
   }
-  case PM_BREAK_NODE:
+  case PM_BREAK_NODE: {
+    pm_break_node_t *n = (pm_break_node_t *)node;
     N("BreakNode");
+    R("arguments", n->arguments);
     break;
-  case PM_NEXT_NODE:
+  }
+  case PM_NEXT_NODE: {
+    pm_next_node_t *n = (pm_next_node_t *)node;
     N("NextNode");
+    R("arguments", n->arguments);
     break;
+  }
   case PM_RETRY_NODE:
     N("RetryNode");
     break;
@@ -847,9 +1061,8 @@ static int flatten(pm_node_t *node) {
     break;
   }
   case PM_SOURCE_ENCODING_NODE: {
-    /* `__ENCODING__`. CRuby returns an Encoding object; Spinel has
-       no Encoding runtime, so we return the canonical name as a
-       frozen string. All Spinel sources are UTF-8. */
+    /* `__ENCODING__`. Spinel sources are UTF-8; codegen returns a
+       small Encoding value for Ruby-compatible `.class` / `.name`. */
     N("SourceEncodingNode");
     break;
   }
@@ -892,15 +1105,28 @@ static int flatten(pm_node_t *node) {
     R("expression", n->expression);
     break;
   }
+  case PM_ASSOC_SPLAT_NODE: {
+    /* `**h` in argument position — splice a hash's entries as
+       keyword args. Wraps the inner hash expression; codegen
+       handles the expansion at call sites. Issue #917. */
+    pm_assoc_splat_node_t *n = (pm_assoc_splat_node_t *)node;
+    N("AssocSplatNode");
+    R("value", n->value);
+    break;
+  }
   case PM_SUPER_NODE: {
     pm_super_node_t *n = (pm_super_node_t *)node;
     N("SuperNode");
     R("arguments", n->arguments);
+    R("block", n->block);
     break;
   }
-  case PM_FORWARDING_SUPER_NODE:
+  case PM_FORWARDING_SUPER_NODE: {
+    pm_forwarding_super_node_t *n = (pm_forwarding_super_node_t *)node;
     N("ForwardingSuperNode");
+    R("block", (pm_node_t *)n->block);
     break;
+  }
   case PM_MULTI_WRITE_NODE: {
     pm_multi_write_node_t *n = (pm_multi_write_node_t *)node;
     N("MultiWriteNode");
@@ -1001,6 +1227,79 @@ static int flatten(pm_node_t *node) {
     R("right", n->right);
     break;
   }
+  case PM_ARRAY_PATTERN_NODE: {
+    /* `case x in [a, b, c]`. requireds is the list of fixed-position
+       sub-patterns. rest / posts cover `[a, *, c]`. constant covers
+       `Foo[a, b]` (Foo() destructuring). Minimal initial support:
+       emit requireds as a node-id array; rest / posts / constant
+       handled later when the codegen path catches up. Issue #669. */
+    pm_array_pattern_node_t *n = (pm_array_pattern_node_t *)node;
+    N("ArrayPatternNode");
+    R("constant", n->constant);
+    A("requireds", &n->requireds);
+    R("rest", n->rest);
+    A("posts", &n->posts);
+    break;
+  }
+  case PM_HASH_PATTERN_NODE: {
+    /* `case x in {a:, b: 2}`. elements is a list of AssocNodes
+       (key + sub-pattern); a `:b:` shorthand binds the key's symbol
+       as a same-named LV. Constant covers `Foo[a:]` destructuring
+       (not yet handled by codegen). Rest covers `**rest` (also not
+       yet handled). Issue #805. */
+    pm_hash_pattern_node_t *n = (pm_hash_pattern_node_t *)node;
+    N("HashPatternNode");
+    R("constant", n->constant);
+    A("elements", &n->elements);
+    R("rest", n->rest);
+    break;
+  }
+  case PM_FIND_PATTERN_NODE: {
+    /* `case x in [*a, b, *c]` -- find-anywhere pattern with leading
+       and trailing wildcards plus required middle elements.
+       Currently surfaces all three slots so the codegen can match
+       on length + extract requireds; the find-anywhere semantics
+       (variable-position match) are not yet implemented but the
+       shape no longer drops to UnsupportedNode. Issue #805. */
+    pm_find_pattern_node_t *n = (pm_find_pattern_node_t *)node;
+    N("FindPatternNode");
+    R("constant", n->constant);
+    R("left", (pm_node_t *)n->left);
+    A("requireds", &n->requireds);
+    R("right", n->right);
+    break;
+  }
+  case PM_CAPTURE_PATTERN_NODE: {
+    /* `case x in pat => var` -- match `pat`, bind matched value to
+       `var` (LocalVariableTargetNode). Issue #884. */
+    pm_capture_pattern_node_t *n = (pm_capture_pattern_node_t *)node;
+    N("CapturePatternNode");
+    R("value", (pm_node_t *)n->value);
+    R("target", (pm_node_t *)n->target);
+    break;
+  }
+  case PM_PINNED_EXPRESSION_NODE: {
+    /* `case x in ^(expr)`. The pinned expression is evaluated at
+       match time and compared by `==` against the scrutinee. */
+    pm_pinned_expression_node_t *n = (pm_pinned_expression_node_t *)node;
+    N("PinnedExpressionNode");
+    R("expression", n->expression);
+    break;
+  }
+  case PM_PINNED_VARIABLE_NODE: {
+    /* `case x in ^var`. The wrapped variable can be any read-shape
+       node prism emits for `^var` -- LocalVariableReadNode,
+       InstanceVariableReadNode, ClassVariableReadNode,
+       GlobalVariableReadNode, ConstantReadNode,
+       NumberedReferenceReadNode, BackReferenceReadNode. Routed to
+       the same `@nd_expression` slot as PinnedExpressionNode so the
+       codegen treats them uniformly -- both are "match the scrutinee
+       by `==` against this expression". */
+    pm_pinned_variable_node_t *n = (pm_pinned_variable_node_t *)node;
+    N("PinnedVariableNode");
+    R("expression", n->variable);
+    break;
+  }
   case PM_NUMBERED_PARAMETERS_NODE: {
     pm_numbered_parameters_node_t *n = (pm_numbered_parameters_node_t *)node;
     N("NumberedParametersNode");
@@ -1185,11 +1484,19 @@ static int flatten(pm_node_t *node) {
 static char *read_file(const char *path) {
   FILE *f = fopen(path, "rb");
   if (!f) return NULL;
-  fseek(f, 0, SEEK_END);
+  if (fseek(f, 0, SEEK_END) != 0) { fclose(f); return NULL; }
   long len = ftell(f);
-  fseek(f, 0, SEEK_SET);
-  char *buf = malloc(len + 1);
-  size_t nread = fread(buf, 1, len, f);
+  /* Issue #768: ftell returning -1 (stream error) used to wrap len + 1
+     to 0, malloc(0) returns NULL, then fread(NULL, 1, SIZE_MAX, f)
+     tried to read 16 exabytes. Bail cleanly. */
+  if (len < 0) { fclose(f); return NULL; }
+  if (fseek(f, 0, SEEK_SET) != 0) { fclose(f); return NULL; }
+  char *buf = malloc((size_t)len + 1);
+  if (!buf) { fclose(f); return NULL; }
+  size_t nread = fread(buf, 1, (size_t)len, f);
+  /* Issue #763: detect short read and bail rather than processing
+     a truncated source file silently. */
+  if (nread != (size_t)len) { free(buf); fclose(f); return NULL; }
   buf[nread] = '\0';
   fclose(f);
   return buf;
@@ -1204,27 +1511,44 @@ static int sp_included_cap = 0;
 
 /* Resolve a path to its canonical form for dedup. realpath() returns NULL
    on missing files; in that case fall back to the literal path. */
+/* Issue #749: realpath/_fullpath + strdup can both fail under OOM,
+   leaving callers with a NULL pointer that goes to strcmp(NULL, ...)
+   and segfaults. Fall back to a static empty string so downstream
+   `strcmp(canonical, ...) == 0` consistently misses (the caller then
+   treats this as "not already included" and proceeds with the file
+   read, which fails through the normal LoadError path). */
 static char *sp_canonical_path(const char *path) {
+  if (!path) { char *e = strdup(""); return e ? e : NULL; }
 #ifdef _WIN32
   char *real = _fullpath(NULL, path, 0);
 #else
   char *real = realpath(path, NULL);
 #endif
-  return real ? real : strdup(path);
+  if (real) return real;
+  char *d = strdup(path);
+  if (d) return d;
+  /* Last resort: return a static empty string to avoid NULL. The
+     buffer is read-only by callers (passed to strcmp, then freed by
+     the caller's free() -- so allocate a fresh empty string instead
+     of returning a string literal). */
+  return strdup("");
 }
 
 static int sp_path_already_included(const char *canonical) {
+  if (!canonical) return 0;
   for (int i = 0; i < sp_included_count; i++) {
-    if (strcmp(sp_included_paths[i], canonical) == 0) return 1;
+    if (sp_included_paths[i] && strcmp(sp_included_paths[i], canonical) == 0) return 1;
   }
   return 0;
 }
 
 static void sp_mark_path_included(const char *canonical) {
   if (sp_included_count >= sp_included_cap) {
-    sp_included_cap = sp_included_cap == 0 ? 16 : sp_included_cap * 2;
-    sp_included_paths = (char **)realloc(sp_included_paths,
-                                         sizeof(char *) * sp_included_cap);
+    int new_cap = sp_included_cap == 0 ? 16 : sp_included_cap * 2;
+    char **np = (char **)realloc(sp_included_paths, sizeof(char *) * new_cap);
+    if (!np) { fprintf(stderr, "spinel_parse: out of memory\n"); exit(1); }
+    sp_included_paths = np;
+    sp_included_cap = new_cap;
   }
   sp_included_paths[sp_included_count++] = strdup(canonical);
 }
@@ -1242,6 +1566,108 @@ static void sp_includes_free(void) {
   sp_included_cap = 0;
 }
 
+/* ---- Debug multi-file source map (g_emit_line only) -------------------
+   require/require_relative are resolved by *textual* splicing into one
+   buffer, so a node's Prism line is a line in that concatenated buffer and
+   the original file boundaries are lost. For --debug we recover them: each
+   spliced file's content is wrapped in PUSH/POP marker *comments* (Prism
+   ignores comments, so the AST is unchanged), and a single pass over the
+   final buffer reconstructs, per buffer line, which file and original line
+   it came from. The stack accounting needs no original-line bookkeeping at
+   splice time: a PUSH consumes the parent's (replaced) require line, then
+   content lines count within the child's own coordinates until POP. */
+#define SP_PUSH_PREFIX "#<SPINEL_PUSH>"
+#define SP_POP_PREFIX "#<SPINEL_POP>"
+
+static char **sp_file_table = NULL;  /* id -> path */
+static int sp_file_count = 0, sp_file_cap = 0;
+
+static int sp_intern_file(const char *path) {
+  for (int i = 0; i < sp_file_count; i++)
+    if (strcmp(sp_file_table[i], path) == 0) return i;
+  if (sp_file_count >= sp_file_cap) {
+    int nc = sp_file_cap == 0 ? 8 : sp_file_cap * 2;
+    char **np = (char **)realloc(sp_file_table, sizeof(char *) * nc);
+    if (!np) { fprintf(stderr, "spinel_parse: out of memory\n"); exit(1); }
+    sp_file_table = np; sp_file_cap = nc;
+  }
+  char *dup_path = strdup(path);
+  if (!dup_path) { fprintf(stderr, "spinel_parse: out of memory\n"); exit(1); }
+  sp_file_table[sp_file_count] = dup_path;
+  return sp_file_count++;
+}
+
+/* In debug mode, wrap an included file's (already-resolved) content with
+   PUSH <path> / POP marker lines. Takes ownership of `content`; returns it
+   unchanged when not in debug mode. */
+static char *sp_wrap_included(char *content, const char *path) {
+  if (!g_emit_line) return content;
+  size_t clen = strlen(content);
+  int need_nl = (clen > 0 && content[clen - 1] != '\n') ? 1 : 0;
+  size_t total = strlen(SP_PUSH_PREFIX) + strlen(path) + 1 + clen + need_nl
+               + strlen(SP_POP_PREFIX) + 1 + 1;
+  char *w = malloc(total + 8);
+  if (!w) { fprintf(stderr, "spinel_parse: out of memory\n"); exit(1); }
+  size_t o = (size_t)sprintf(w, SP_PUSH_PREFIX "%s\n", path);
+  memcpy(w + o, content, clen); o += clen;
+  if (need_nl) w[o++] = '\n';
+  o += (size_t)sprintf(w + o, SP_POP_PREFIX "\n");
+  w[o] = '\0';
+  free(content);
+  return w;
+}
+
+/* Reconstruct the line map from the final spliced buffer. toplevel is the
+   path of the outermost file (interned as the initial frame). */
+static void sp_build_line_map(const char *src, const char *toplevel) {
+  size_t nlines = 1;
+  for (const char *p = src; *p; p++) if (*p == '\n') nlines++;
+  sp_line_map_n = (int)nlines;
+  sp_line_file = (int *)calloc(nlines + 2, sizeof(int));
+  sp_line_orig = (int *)calloc(nlines + 2, sizeof(int));
+
+  int *stk_file = (int *)malloc(sizeof(int) * (nlines + 2));
+  int *stk_next = (int *)malloc(sizeof(int) * (nlines + 2));
+  if (!sp_line_file || !sp_line_orig || !stk_file || !stk_next) {
+    fprintf(stderr, "spinel_parse: out of memory\n"); exit(1);
+  }
+  int sp = 0;
+  stk_file[sp] = sp_intern_file(toplevel);
+  stk_next[sp] = 1;
+
+  int bl = 1;
+  const char *line = src;
+  while (1) {
+    const char *eol = strchr(line, '\n');
+    size_t len = eol ? (size_t)(eol - line) : strlen(line);
+    if (strncmp(line, SP_PUSH_PREFIX, strlen(SP_PUSH_PREFIX)) == 0) {
+      /* The replaced require occupied one parent line: consume it. */
+      if (sp >= 0) stk_next[sp] += 1;
+      char pathbuf[1024];
+      size_t plen = len - strlen(SP_PUSH_PREFIX);
+      if (plen >= sizeof(pathbuf)) plen = sizeof(pathbuf) - 1;
+      memcpy(pathbuf, line + strlen(SP_PUSH_PREFIX), plen);
+      pathbuf[plen] = '\0';
+      sp++;
+      stk_file[sp] = sp_intern_file(pathbuf);
+      stk_next[sp] = 1;
+      /* marker line maps to nothing meaningful */
+    } else if (strncmp(line, SP_POP_PREFIX, strlen(SP_POP_PREFIX)) == 0) {
+      if (sp > 0) sp--;
+    } else {
+      sp_line_file[bl] = stk_file[sp];
+      sp_line_orig[bl] = stk_next[sp];
+      stk_next[sp] += 1;
+    }
+    bl++;
+    if (!eol) break;
+    line = eol + 1;
+    if (*line == '\0') break;
+  }
+  free(stk_file);
+  free(stk_next);
+}
+
 /* Simple require_relative resolver: replace lines matching
    require_relative "path" with the file content. Files that have
    already been included once are silently skipped on subsequent
@@ -1289,12 +1715,16 @@ static char *resolve_requires(const char *source, const char *source_path) {
     if (!end || end > line_end) { scan_from = pos + 1; continue; }
 
     size_t path_len = end - start;
+    /* Issue #765: bail rather than silently truncating overlong paths
+       into the fixed-size buffers. */
+    if (path_len >= sizeof(((struct {char x[512];}*)0)->x)) { scan_from = pos + 1; continue; }
     char rel_path[512];
     snprintf(rel_path, sizeof(rel_path), "%.*s", (int)path_len, start);
 
     /* Build full path */
     char full_path[1024];
-    snprintf(full_path, sizeof(full_path), "%s/%s", dir, rel_path);
+    int fp_n = snprintf(full_path, sizeof(full_path), "%s/%s", dir, rel_path);
+    if (fp_n < 0 || (size_t)fp_n >= sizeof(full_path)) { scan_from = pos + 1; continue; }
     {
       size_t fl = strlen(full_path);
       if (fl < sizeof(full_path) - 4 && (fl < 3 || strcmp(full_path + fl - 3, ".rb") != 0))
@@ -1311,6 +1741,9 @@ static char *resolve_requires(const char *source, const char *source_path) {
       sp_mark_path_included(canonical);
       content = read_file(full_path);
       if (!content) {
+        fprintf(stderr,
+                "warning: require_relative \"%s\" from %s could not be resolved (no such file: %s); the call is ignored\n",
+                rel_path, source_path, full_path);
         content = strdup("# require_relative not found");
       } else {
         /* Recursively resolve */
@@ -1321,6 +1754,10 @@ static char *resolve_requires(const char *source, const char *source_path) {
       free(canonical);
     }
 
+    /* Debug: wrap with PUSH/POP markers so the line map can attribute this
+       file's nodes to the right source. No-op outside --debug. */
+    content = sp_wrap_included(content, full_path);
+
     /* Replace the line */
     size_t line_len = (line_end - pos) + ((*line_end == '\n') ? 1 : 0);
     size_t content_len = strlen(content);
@@ -1344,6 +1781,20 @@ static char *resolve_requires(const char *source, const char *source_path) {
   return result;
 }
 
+/* A `require "X"` whose X has no bundled lib/X.rb may still be provided
+   natively by the Spinel runtime/codegen (e.g. the JSON module). Such a
+   require is a harmless no-op and must not warn. Bundled .rb libs (set,
+   stringio, strscan, erb, ...) are resolved by file existence and never
+   reach the not-found branch, so they don't belong here -- only the
+   C-native modules that map to a stdlib require name do. */
+static int sp_lib_is_native(const char *name) {
+  static const char *const natives[] = { "json", NULL };
+  for (int i = 0; natives[i]; i++) {
+    if (strcmp(name, natives[i]) == 0) return 1;
+  }
+  return 0;
+}
+
 /* ---- Plain require resolution ---- */
 static char *resolve_plain_requires(char *source, const char *exe_path) {
   /* Find lib/ directory relative to this executable */
@@ -1356,10 +1807,20 @@ static char *resolve_plain_requires(char *source, const char *exe_path) {
 
   char *result = source;
   char *pos;
-  while ((pos = strstr(result, "\nrequire ")) != NULL ||
-         (pos == NULL && result == source && strncmp(result, "require ", 8) == 0 && (pos = result))) {
-    if (pos != result) pos++; /* skip \n */
-    if (pos != result && *(pos - 1) != '\n') break;
+  /* Match a `require` at the very start of the buffer (offset 0) or
+     immediately after a newline. Re-checking offset 0 every iteration --
+     not just while `result == source` -- is what lets a first-line
+     `require` still be processed when a later `require` exists: once the
+     buffer is rebuilt below, `result != source`, and the old condition
+     stranded the line-1 require. */
+  for (;;) {
+    if (strncmp(result, "require ", 8) == 0) {
+      pos = result;
+    } else {
+      pos = strstr(result, "\nrequire ");
+      if (pos == NULL) break;
+      pos++; /* skip the matched newline */
+    }
     char *line_end = strchr(pos, '\n');
     if (!line_end) line_end = pos + strlen(pos);
 
@@ -1397,7 +1858,16 @@ static char *resolve_plain_requires(char *source, const char *exe_path) {
       free(canonical);
       content = read_file(lib_path);
       if (!content) {
-        content = strdup("# require not resolved");
+        if (sp_lib_is_native(lib_name)) {
+          /* Provided natively by the Spinel runtime; the require is a
+             harmless no-op, so don't warn. */
+          content = strdup("# require provided by Spinel runtime");
+        } else {
+          fprintf(stderr,
+                  "warning: '%s' is not available in Spinel; the require is ignored and code using it will fail\n",
+                  lib_name);
+          content = strdup("# require not resolved");
+        }
       } else {
         char *resolved = resolve_requires(content, lib_path);
         free(content);
@@ -1405,7 +1875,51 @@ static char *resolve_plain_requires(char *source, const char *exe_path) {
       }
     }
 
-    size_t line_len = (line_end - pos) + ((*line_end == '\n') ? 1 : 0);
+    /* A trailing same-line modifier (`rescue`, `if`, `unless`, `and`,
+       `&&`, ...) puts the require in expression position: `require 'x'
+       rescue nil`. Replacing it with inlined statements or a comment
+       strands the modifier and Prism reports `unexpected 'rescue'`.
+       Substitute a `nil` expression instead so the modifier attaches;
+       an optional/unavailable require degrades to nil, which is what the
+       `rescue` guards for. `;`, `#`, newline and EOF are statement
+       boundaries, not modifiers, and keep the normal inlining path. */
+    {
+      char *trail = end + 1;
+      while (*trail == ' ' || *trail == '\t') trail++;
+      /* `\r` is part of a CRLF line ending, not a modifier: treat it as a
+         statement boundary so Windows sources keep the normal inlining
+         path. */
+      if (*trail != '\n' && *trail != '\r' && *trail != ';' &&
+          *trail != '\0' && *trail != '#') {
+        free(content);
+        size_t rl_len = (size_t)((end + 1) - pos);   /* the `require 'x'` span */
+        size_t result_len = strlen(result);
+        size_t before_len = (size_t)(pos - result);
+        char *new_result = malloc(result_len - rl_len + 4);
+        memcpy(new_result, result, before_len);
+        memcpy(new_result + before_len, "nil", 3);
+        memcpy(new_result + before_len + 3, pos + rl_len,
+               result_len - before_len - rl_len + 1);
+        free(result);
+        result = new_result;
+        continue;
+      }
+    }
+
+    /* Debug: marker-wrap so plain-require'd lib content doesn't corrupt the
+       line map's accounting for code after the require. No-op without --debug. */
+    content = sp_wrap_included(content, lib_path);
+
+    /* Replace only the `require "name"` statement itself, not the whole
+       line, so `require "x"; code` keeps `code`. Consume trailing
+       horizontal whitespace and a single terminating newline (so a
+       require on its own line leaves no blank line); stop at `;` or any
+       other trailing code, which the inserted content's trailing newline
+       then pushes onto its own line. */
+    char *stmt_end = end + 1;  /* just past the closing quote */
+    while (*stmt_end == ' ' || *stmt_end == '\t') stmt_end++;
+    if (*stmt_end == '\n') stmt_end++;
+    size_t line_len = stmt_end - pos;
     size_t content_len = strlen(content);
     size_t result_len = strlen(result);
     size_t before_len = pos - result;
@@ -1423,8 +1937,21 @@ static char *resolve_plain_requires(char *source, const char *exe_path) {
 }
 
 /* ---- Syntax sugar rewriting ---- */
+
+/* Ruby method-name char class: idents, digits, `?` / `!` / `=` suffixes,
+   operator-method chars (`+`, `-`, `*`, etc.), and `[` / `]` for the
+   index operators `[]` and `[]=`. Digits are allowed in the body but
+   the macro rejects digit-leading names (invalid Ruby method syntax). */
+static int sp_is_method_name_char(char c) {
+  return c == '_' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+         (c >= '0' && c <= '9') || c == '?' || c == '!' || c == '+' ||
+         c == '-' || c == '*' || c == '/' || c == '<' || c == '>' ||
+         c == '=' || c == '&' || c == '|' || c == '^' || c == '~' ||
+         c == '%' || c == '[' || c == ']';
+}
+
 static char *rewrite_syntax_sugar(char *source) {
-  /* Rewrite .send(:method, args) → .method(args) */
+  /* Rewrite .send(:foo, args) / .send("foo", args) → .foo(args) */
   /* Rewrite &:symbol → { |_spx| _spx.symbol } */
   size_t len = strlen(source);
   size_t cap = len * 2 + 256;
@@ -1432,68 +1959,184 @@ static char *rewrite_syntax_sugar(char *source) {
   size_t oi = 0;
   size_t i = 0;
 
-  #define OUT_CHAR(c) do { if (oi >= cap - 1) { cap *= 2; out = realloc(out, cap); } out[oi++] = (c); } while(0)
+  #define OUT_CHAR(c) do { if (oi >= cap - 1) { size_t _nc = cap * 2; char *_no = realloc(out, _nc); if (!_no) { fprintf(stderr, "spinel_parse: out of memory\n"); exit(1); } out = _no; cap = _nc; } out[oi++] = (c); } while(0)
   #define OUT_STR(s) do { const char *_s = (s); while (*_s) { OUT_CHAR(*_s); _s++; } } while(0)
 
+  /* Rewrite one .send(:foo / .send("foo dispatch. `string_form` is 1
+     for the double-quoted variant (requires a closing `"`) and 0 for
+     the colon-symbol variant. On mismatch (empty / digit-leading
+     name, unclosed quote), emits the prefix verbatim and advances
+     past it so the outer loop resumes scanning. The args copy tracks
+     `"..."` and `'...'` state with `\` escape skipping so parens
+     inside string literals do not prematurely close the call. */
+  #define REWRITE_SEND_CALL(prefix_str, prefix_len, string_form) do {     \
+    size_t _save_i = i;                                                   \
+    i += (prefix_len);                                                    \
+    size_t _ns = i;                                                       \
+    while (i < len && sp_is_method_name_char(source[i])) i++;             \
+    size_t _name_len = i - _ns;                                           \
+    int _ok = (_name_len > 0);                                            \
+ /* Reject digit-leading names: `.123foo()` is not valid Ruby. */         \
+    if (_ok && source[_ns] >= '0' && source[_ns] <= '9') { _ok = 0; }     \
+    if (_ok && (string_form)) {                                           \
+      if (i >= len || source[i] != '"') { _ok = 0; }                      \
+      else { i++; /* skip closing quote */ }                              \
+    }                                                                     \
+    if (!_ok) { i = _save_i; OUT_STR(prefix_str); i += (prefix_len); }    \
+    else {                                                                \
+      OUT_CHAR('.');                                                      \
+      { size_t _k; for (_k = 0; _k < _name_len; _k++) OUT_CHAR(source[_ns + _k]); } \
+      if (i < len && source[i] == ')') {                                  \
+        i++; /* no args */                                                \
+      } else if (i < len && source[i] == ',') {                           \
+        i++;                                                              \
+        while (i < len && source[i] == ' ') i++;                          \
+        OUT_CHAR('(');                                                    \
+        { int _depth = 1; char _qc = 0;                                   \
+          while (i < len && _depth > 0) {                                 \
+            char _ac = source[i];                                         \
+            if (_qc != 0) {                                               \
+ /* Inside string: `\` escapes next char, skip it as a pair. */           \
+              if (_ac == '\\' && i + 1 < len) {                           \
+                OUT_CHAR(_ac); OUT_CHAR(source[i + 1]); i += 2; continue; \
+              }                                                            \
+              if (_ac == _qc) _qc = 0;                                    \
+              OUT_CHAR(_ac); i++; continue;                                \
+            }                                                              \
+            if (_ac == '"' || _ac == '\'') { _qc = _ac; OUT_CHAR(_ac); i++; continue; } \
+            if (_ac == '(') _depth++;                                     \
+            else if (_ac == ')') { _depth--; if (_depth == 0) { i++; break; } } \
+            OUT_CHAR(_ac); i++;                                           \
+          } }                                                             \
+        OUT_CHAR(')');                                                    \
+      }                                                                   \
+    }                                                                     \
+  } while(0)
+
   while (i < len) {
-    /* .send(:symbol ...) */
+    /* .send(:foo, args) → .foo(args) */
     if (i + 7 < len && strncmp(source + i, ".send(:", 7) == 0) {
-      i += 7; /* skip .send(: */
-      /* Extract method name */
-      size_t ns = i;
-      while (i < len && (source[i] == '_' || (source[i] >= 'a' && source[i] <= 'z') ||
-             (source[i] >= 'A' && source[i] <= 'Z') || (source[i] >= '0' && source[i] <= '9') ||
-             source[i] == '?' || source[i] == '!' || source[i] == '+' || source[i] == '-' ||
-             source[i] == '*' || source[i] == '/' || source[i] == '<' || source[i] == '>' ||
-             source[i] == '=' || source[i] == '&' || source[i] == '|' || source[i] == '^' ||
-             source[i] == '~' || source[i] == '%')) i++;
-      size_t name_len = i - ns;
-      if (name_len > 0) {
-        OUT_CHAR('.');
-        size_t k; for (k = 0; k < name_len; k++) OUT_CHAR(source[ns + k]);
-        /* Skip optional comma + space, then copy remaining args until ) */
-        if (i < len && source[i] == ')') {
-          i++; /* no args */
-        } else if (i < len && source[i] == ',') {
-          i++; /* skip comma */
-          while (i < len && source[i] == ' ') i++;
-          OUT_CHAR('(');
-          /* Copy args until matching ) */
-          int depth = 1;
-          while (i < len && depth > 0) {
-            if (source[i] == '(') depth++;
-            else if (source[i] == ')') { depth--; if (depth == 0) { i++; break; } }
-            OUT_CHAR(source[i]); i++;
-          }
-          OUT_CHAR(')');
-        }
-        continue;
-      }
-      /* Failed to parse, output original */
-      OUT_STR(".send(:");
+      REWRITE_SEND_CALL(".send(:", 7, 0);
+      continue;
+    }
+    /* .send("foo", args) → .foo(args). Plain string literal only;
+       interpolated strings parse as InterpolatedStringNode and are
+       left untouched (Spinel can't resolve the name statically). */
+    if (i + 7 < len && strncmp(source + i, ".send(\"", 7) == 0) {
+      REWRITE_SEND_CALL(".send(\"", 7, 1);
       continue;
     }
-    /* (&:symbol) → { |_spx| _spx.symbol } — also remove enclosing parens */
+    /* .__send__(:foo, args) → .foo(args). CRuby's overrides-resistant
+       alias of send; semantically identical for Spinel's static dispatch. */
+    if (i + 11 < len && strncmp(source + i, ".__send__(:", 11) == 0) {
+      REWRITE_SEND_CALL(".__send__(:", 11, 0);
+      continue;
+    }
+    /* .__send__("foo", args) → .foo(args). String-form variant. */
+    if (i + 11 < len && strncmp(source + i, ".__send__(\"", 11) == 0) {
+      REWRITE_SEND_CALL(".__send__(\"", 11, 1);
+      continue;
+    }
+    /* .public_send(:foo, args) → .foo(args). Visibility isn't modeled
+       in Spinel's static dispatch -- public_send is semantically
+       identical to send. Issue #735. */
+    if (i + 14 < len && strncmp(source + i, ".public_send(:", 14) == 0) {
+      REWRITE_SEND_CALL(".public_send(:", 14, 0);
+      continue;
+    }
+    if (i + 14 < len && strncmp(source + i, ".public_send(\"", 14) == 0) {
+      REWRITE_SEND_CALL(".public_send(\"", 14, 1);
+      continue;
+    }
+    /* `&:symbol` symbol-to-proc. Prism parses `&:sym` natively, but
+       Spinel only lowers the native BlockArgumentNode+SymbolNode shape
+       for a few methods (inject / reduce / sort_by); general block
+       takers rely on this textual rewrite to an explicit block. The
+       block has to land where Ruby reads it as a block, not a hash:
+         - sole parenthesized arg `m(&:s)`   -> `m { |_spx| _spx.s }`
+         - after a positional, paren call
+           `m(a, &:s)`                       -> `m(a) { |_spx| _spx.s }`
+         - after a positional, command call
+           `m a, &:s`                        -> `m a do |_spx| _spx.s end`
+         - command-position sole arg `m &:s` -> `m  { |_spx| _spx.s }`
+       The bare `{ |_spx| ... }` was only correct in block position; a
+       `,`-prefixed brace parses as a hash literal, which was the bundler
+       (`File.open(f, "r:UTF-8", &:read)`) / minitest
+       (`define_method :mu_pp, &:pretty_inspect`) parse failure.
+
+       Operator symbols (`&:+`) have name_len 0 here and are left for
+       Prism's native path (the arith reduce/inject lowering handles
+       them). Known limitation: a paren-less command carrying a
+       symbol-proc that is itself nested as an argument inside a paren
+       call -- `p(foo :a, &:s)` -- mis-binds the block to the outer
+       call, because textually its args sit at the same paren depth as
+       the enclosing call (indistinguishable without re-implementing
+       Ruby's command/arg disambiguation). Neither target gem hits
+       this; a robust fix is an AST-level lowering, deferred. */
     if (i + 2 < len && source[i] == '&' && source[i + 1] == ':') {
-      /* Check if preceded by ( and remove it */
-      int had_paren = 0;
-      if (oi > 0 && out[oi - 1] == '(') { oi--; had_paren = 1; }
+      /* Last emitted non-space char. Skip newlines too so a multi-line
+         `m(a,\n  &:s)` still sees the comma. */
+      size_t back = oi;
+      while (back > 0 && (out[back - 1] == ' ' || out[back - 1] == '\t' ||
+                          out[back - 1] == '\n' || out[back - 1] == '\r')) back--;
+      char prev = (back > 0) ? out[back - 1] : '\0';
       i += 2;
       size_t ns = i;
       while (i < len && (source[i] == '_' || (source[i] >= 'a' && source[i] <= 'z') ||
              (source[i] >= 'A' && source[i] <= 'Z') || (source[i] >= '0' && source[i] <= '9') ||
              source[i] == '?' || source[i] == '!')) i++;
       size_t name_len = i - ns;
-      if (name_len > 0) {
-        /* Skip closing paren if we removed opening */
-        if (had_paren && i < len && source[i] == ')') i++;
+      if (name_len == 0) {
+        /* Operator / empty symbol: leave `&:` for Prism's native path. */
+        OUT_STR("&:");
+        continue;
+      }
+      if (prev == '(') {
+        /* Sole parenthesized arg: drop the `(` (and any trailing ws)
+           and the matching `)` so the block binds paren-less. #792:
+           tolerate whitespace before the `)`. Restore `i` if no `)`
+           follows so trailing content isn't swallowed. */
+        oi = back - 1;
+        size_t after_sym = i;
+        while (i < len && (source[i] == ' ' || source[i] == '\t' ||
+                           source[i] == '\n' || source[i] == '\r')) i++;
+        if (i < len && source[i] == ')') i++;
+        else i = after_sym;
         OUT_STR(" { |_spx| _spx.");
-        size_t k; for (k = 0; k < name_len; k++) OUT_CHAR(source[ns + k]);
+        { size_t k; for (k = 0; k < name_len; k++) OUT_CHAR(source[ns + k]); }
         OUT_STR(" }");
         continue;
       }
-      if (had_paren) OUT_CHAR('('); /* restore if failed */
-      OUT_STR("&:");
+      if (prev == ',') {
+        /* After a positional arg. Drop the separating comma and
+           relocate the block: a parenthesized call closes first then
+           takes a brace block; a command call takes a trailing do..end
+           (a brace would still read as a hash). Only consume up to the
+           `)`; otherwise restore `i` so the newline/`end` that follows
+           a paren-less command is preserved. */
+        oi = back - 1;
+        size_t after_sym = i;
+        while (i < len && (source[i] == ' ' || source[i] == '\t' ||
+                           source[i] == '\n' || source[i] == '\r')) i++;
+        if (i < len && source[i] == ')') {
+          i++;
+          OUT_CHAR(')');
+          OUT_STR(" { |_spx| _spx.");
+          { size_t k; for (k = 0; k < name_len; k++) OUT_CHAR(source[ns + k]); }
+          OUT_STR(" }");
+        } else {
+          i = after_sym;
+          OUT_STR(" do |_spx| _spx.");
+          { size_t k; for (k = 0; k < name_len; k++) OUT_CHAR(source[ns + k]); }
+          OUT_STR(" end");
+        }
+        continue;
+      }
+      /* Command-position sole arg (`m &:s`): the brace binds as a
+         block (no comma precedes it). */
+      OUT_STR(" { |_spx| _spx.");
+      { size_t k; for (k = 0; k < name_len; k++) OUT_CHAR(source[ns + k]); }
+      OUT_STR(" }");
       continue;
     }
     OUT_CHAR(source[i]);
@@ -1520,11 +2163,51 @@ int main(int argc, char **argv) {
     return 1;
   }
 
+  /* Set the debug flag before resolving requires so the resolvers insert the
+     PUSH/POP markers used to rebuild the multi-file source map. */
+  {
+    const char *dbg = getenv("SPINEL_DEBUG");
+    const char *lm = getenv("SPINEL_LINE_MAP");
+    int on = (dbg != NULL && dbg[0] == '1' && dbg[1] == '\0')
+          || (lm  != NULL && lm[0]  == '1' && lm[1]  == '\0');
+    g_emit_line = on ? 1 : 0;
+  }
+
   /* Resolve require_relative and plain require */
   char *resolved = resolve_requires(source, source_file);
   free(source);
   source = resolve_plain_requires(resolved, argv[0]);
+
+  /* Debug: build the buffer-line -> (file, original line) map from the
+     marker-annotated buffer *before* syntax-sugar rewriting (which could
+     touch a marker line's text). Sugar preserves line count, so the map
+     stays aligned with the parsed node lines; if that ever fails to hold,
+     disable the map rather than emit wrong attributions. */
+  char *premap = NULL;
+  if (g_emit_line) {
+    premap = strdup(source);
+    if (!premap) { fprintf(stderr, "spinel_parse: out of memory\n"); exit(1); }
+  }
   source = rewrite_syntax_sugar(source);
+  if (g_emit_line) {
+    size_t la = 1, lb = 1;
+    for (const char *p = premap; *p; p++) if (*p == '\n') la++;
+    for (const char *p = source; *p; p++) if (*p == '\n') lb++;
+    if (la == lb) {
+      sp_build_line_map(premap, source_file);
+    } else {
+      /* Multi-file line attribution unavailable for this program; #line
+         falls back to buffer lines. Only worth a word under an explicit
+         --debug build (faithful stepping matters there); stay silent for
+         the default line-map so normal builds aren't noisy. */
+      const char *dbg = getenv("SPINEL_DEBUG");
+      if (dbg != NULL && dbg[0] == '1' && dbg[1] == '\0') {
+        fprintf(stderr, "spinel_parse: multi-file line map disabled "
+                        "(syntax-sugar changed line count)\n");
+      }
+    }
+    free(premap);
+  }
 
   size_t source_len = strlen(source);
 
@@ -1539,9 +2222,12 @@ int main(int argc, char **argv) {
     for (diag = (pm_diagnostic_t *)parser.error_list.head; diag; diag = (pm_diagnostic_t *)diag->node.next) {
       fprintf(stderr, "  %s\n", diag->message);
     }
+    /* Issue #764: free the registered include paths on the parse-
+       error exit path too. */
     pm_node_destroy(&parser, root);
     pm_parser_free(&parser);
     free(source);
+    sp_includes_free();
     return 1;
   }
 
@@ -1563,12 +2249,36 @@ int main(int argc, char **argv) {
     out = fopen(argv[2], "wb");
     if (!out) {
       fprintf(stderr, "spinel_parse: cannot write '%s'\n", argv[2]);
+      /* Issue #764: clean up before bailing on the output-open
+         failure. We've allocated source, g_source_file_escaped,
+         lines[], plus parser/root, and registered sp_included_paths
+         entries -- free all to avoid leaking on the way out. */
+      for (size_t i = 0; i < line_count; i++) free(lines[i]);
+      free(lines);
+      pm_node_destroy(&parser, root);
+      pm_parser_free(&parser);
+      free(source);
+      free(g_source_file_escaped);
+      g_source_file_escaped = NULL;
+      sp_includes_free();
       return 1;
     }
   }
 
   fprintf(out, "ROOT %d\n", root_id);
-  for (int i = 0; i < line_count; i++) {
+  /* Issue #878: emit the source file path as a top-level fact so
+     `__dir__` and similar compile-time helpers can recover it
+     even when the source contains no `__FILE__` reference. The
+     loader stashes it in @source_file_path. */
+  fprintf(out, "SOURCE_FILE %s\n", g_source_file_escaped);
+  /* Debug multi-file map: emit the id -> path table so codegen can resolve
+     each node's `node_file` id to a path for its `#line` directive. */
+  for (int i = 0; i < sp_file_count; i++) {
+    char *esc = escape_str((const uint8_t *)sp_file_table[i], strlen(sp_file_table[i]));
+    fprintf(out, "FILE %d %s\n", i, esc);
+    free(esc);
+  }
+  for (size_t i = 0; i < line_count; i++) {
     fprintf(out, "%s\n", lines[i]);
     free(lines[i]);
   }