Address review of the Sprintf fix and harden the differential probe

Three defects found reviewing the previous commit against its own intent.

The Sprintf rewriter passed a '%' that starts no directive straight through.
The point of the change was that Sprintf should stop producing functions that
fail when called, but a lone '%' is itself an error to format(), so
fmt.Sprintf("100%") still raised "unterminated format() type specifier" at run
time. It is now escaped to %% and reaches the caller as a literal percent.

The documentation understated what dropping a verb costs. Saying only that
flags and precision are dropped implies the difference is padding, but the
verbs that change an operand's representation are affected too: %x, %o, %b, %e
and %q all render what %s renders, so fmt.Sprintf("%x", 255) yields 255 rather
than ff. That is a wrong value rather than a wrong width, which is worse than
an error because it is silent, so both doc/plxgo.md and doc/LIMITATIONS.md now
say so and point at an explicit conversion.

The differential probe returned values verbatim on one output line per probe.
A value containing a newline, or a blank value dropped by the runner's filter,
would shift every later result onto the wrong probe. Counts usually catch that,
but a two-line value and a blank value in the same run cancel out and the
mis-mapping is silent. The probe now returns a sentinel for the empty string
and escapes newlines, so one probe is always exactly one line, and the runner
no longer discards blank lines.

Regression cases added for the bare percent, a percent followed by punctuation,
and the representation-changing verbs.

Verified on PostgreSQL 18.4: clean build with no warnings, 13/13 installcheck,
differentialcheck clean at 374 matching and 14 documented, and the check still
exits 1 on an injected defect after the probe change.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: plx

doc/LIMITATIONS.md

@@ -117,9 +117,14 @@ The per-dialect chapter is authoritative; this is a quick reference.
 - `+` for string concatenation (use `||` or build a slice and `array_to_string`).
 - Only a subset of `fmt`/`strings`/`math`/`strconv` is mapped; other calls pass
   through and must be valid PostgreSQL functions.
-- `fmt.Sprintf` keeps a `-` flag and a width, but drops Go's other flags and its
-  precision field, since SQL `format()` has no equivalent. `%.2f` therefore
-  prints the operand in full instead of rounding it to two decimal places.
+- `fmt.Sprintf` renders every operand in its SQL text form, because each Go verb
+  becomes `format()`'s `%s`. A `-` flag and a width are kept, so `%-8d` still
+  pads. Go's other flags and its precision field are dropped, so `%.2f` prints
+  the operand in full rather than rounding it. The verbs that change an
+  operand's representation rather than its padding do not do so here: `%x`,
+  `%o`, `%b`, `%e` and `%q` all produce the same text `%s` would, so
+  `fmt.Sprintf("%x", 255)` yields `255` and not `ff`. Convert explicitly (for
+  example `to_hex`) where the representation matters.
 
 ### plxcobol ([chapter](plxcobol.md))
 

doc/plxgo.md

@@ -147,7 +147,11 @@ string is reproduced. Every Go verb renders its operand as text, which is what
 A `-` flag and a width are kept, so `%-8d` still pads to eight columns. Go's
 other flags and its precision field have no `format()` equivalent and are
 dropped, so `%.2f` prints the operand's full text rather than rounding it to
-two decimal places. A doubled `%%` stays a literal `%`.
+two decimal places. Verbs that change an operand's representation rather than
+its padding are affected the same way: `%x`, `%o`, `%b`, `%e` and `%q` all
+render what `%s` would, so `fmt.Sprintf("%x", 255)` yields `255` and not `ff`.
+A doubled `%%` stays a literal `%`, and a `%` that starts no directive is
+passed through as a literal percent.
 
 ### Types (in declarations)
 

src/plx_dialect_go.c

@@ -416,7 +416,9 @@ go_emit_str(GoTok *tk, StringInfo out)
  * does, so every directive becomes %s. format() takes only a '-' flag and a
  * width, so Go's other flags and its precision field are dropped: the operand
  * still appears, just without the padding Go would have applied. A doubled
- * %% passes through, and a '%' that starts no directive is left alone.
+ * A doubled %% passes through, and a '%' that starts no directive is escaped
+ * to %%, so it reaches the caller as a literal percent instead of tripping
+ * format() at run time.
  */
 static void
 go_emit_format_str(GoTok *tk, StringInfo out)
@@ -470,7 +472,9 @@ go_emit_format_str(GoTok *tk, StringInfo out)
 			!((raw.data[j] >= 'a' && raw.data[j] <= 'z') ||
 			  (raw.data[j] >= 'A' && raw.data[j] <= 'Z')))
 		{
-			appendStringInfoChar(out, c);	/* not a directive */
+			/* starts no directive: escape it, since a lone '%' is itself
+			 * an error to format() */
+			appendStringInfoString(out, "%%");
 			continue;
 		}
 

test/differential.py

@@ -49,7 +49,12 @@ def psql(sql, stop_on_error=False):
   IF r IS NULL THEN
     RETURN '<NULL>';
   END IF;
-  RETURN r;
+  IF r = '' THEN
+    RETURN '<EMPTY>';
+  END IF;
+  /* One probe must occupy exactly one output line: an embedded newline, or a
+   * value that is blank, would shift every later result onto the wrong probe. */
+  RETURN replace(replace(r, E'\r', '\\r'), E'\n', '\\n');
 EXCEPTION WHEN OTHERS THEN
   RETURN 'ERROR ' || SQLSTATE;
 END;
@@ -96,7 +101,7 @@ def probe_all(created_ok):
     if not selects:
         return {}
     out, err, _ = psql("\n".join(s + ";" for s in selects))
-    lines = [ln for ln in out.splitlines() if ln != ""]
+    lines = out.splitlines()
     if len(lines) != len(keys):
         sys.stderr.write("probe count mismatch: %d results for %d probes\n%s\n"
                          % (len(lines), len(keys), err))

test/expected/plxgo.out

@@ -303,3 +303,33 @@ SELECT g_sprintf_prec(1.5) AS prec;
  1.5|     1.5
 (1 row)
 
+-- a '%' that starts no directive reaches the caller as a literal percent
+-- rather than tripping format() at run time
+CREATE FUNCTION g_sprintf_bare_pct() RETURNS text LANGUAGE plxgo AS $$
+	return fmt.Sprintf("100%")
+$$;
+SELECT g_sprintf_bare_pct() AS should_be_100_pct;
+ should_be_100_pct 
+-------------------
+ 100%
+(1 row)
+
+CREATE FUNCTION g_sprintf_pct_punct(n int) RETURNS text LANGUAGE plxgo AS $$
+	return fmt.Sprintf("%d%!", n)
+$$;
+SELECT g_sprintf_pct_punct(50) AS pct_then_punct;
+ pct_then_punct 
+----------------
+ 50%!
+(1 row)
+
+-- verbs that change an operand's representation render what %s renders
+CREATE FUNCTION g_sprintf_repr(n int) RETURNS text LANGUAGE plxgo AS $$
+	return fmt.Sprintf("%x|%o|%b|%q", n, n, n, n)
+$$;
+SELECT g_sprintf_repr(255) AS repr_verbs_are_text;
+ repr_verbs_are_text 
+---------------------
+ 255|255|255|255
+(1 row)
+

test/sql/plxgo.sql

@@ -212,3 +212,21 @@ CREATE FUNCTION g_sprintf_prec(x float8) RETURNS text LANGUAGE plxgo AS $$
 	return fmt.Sprintf("%.2f|%8.3f", x, x)
 $$;
 SELECT g_sprintf_prec(1.5) AS prec;
+
+-- a '%' that starts no directive reaches the caller as a literal percent
+-- rather than tripping format() at run time
+CREATE FUNCTION g_sprintf_bare_pct() RETURNS text LANGUAGE plxgo AS $$
+	return fmt.Sprintf("100%")
+$$;
+SELECT g_sprintf_bare_pct() AS should_be_100_pct;
+
+CREATE FUNCTION g_sprintf_pct_punct(n int) RETURNS text LANGUAGE plxgo AS $$
+	return fmt.Sprintf("%d%!", n)
+$$;
+SELECT g_sprintf_pct_punct(50) AS pct_then_punct;
+
+-- verbs that change an operand's representation render what %s renders
+CREATE FUNCTION g_sprintf_repr(n int) RETURNS text LANGUAGE plxgo AS $$
+	return fmt.Sprintf("%x|%o|%b|%q", n, n, n, n)
+$$;
+SELECT g_sprintf_repr(255) AS repr_verbs_are_text;