Paint a code span in letters, so its inside is filled rather than gone

Leaving spans untouched kept a step from looking like a blank, since a
number followed by a command is filled. It only worked for the line a
span starts on: a span may cross lines, and an interior line reading
just a number was left exposed and reported as the blank somebody
forgot. A row of pipes inside a multiline span had the same problem.

Spans are now painted like everything else, in letters rather than
spaces. The caller says which: masked fills with a space, because a
heading inside a span must not be found, and the leftover scan fills
with a letter, because it needs the shape gone rather than the content.
A step becomes a number and a run of letters, which is not a blank, and
an interior line becomes a run of letters, which is not one either,
while a genuine bare number is untouched by any region and still is.

Author: Markus Paulsen

.github/scripts/CheckPullRequestTemplate.java

@@ -382,33 +382,33 @@ private static List<String> outOfOrder(List<String> required, List<String> found
      * in a fenced example, is not taken for a real one.
      */
     private static String masked(String text) {
-        return painted(text, true);
+        return painted(text, ' ');
     }
 
     /**
-     * The same, except that code between backticks is left alone. A line that is a number and a
-     * command, {@code 1. `mvn test`}, is a step somebody wrote, and painting its command out would
-     * leave a number and a full stop, which is what an unfilled blank looks like. The same goes for
-     * a table row whose cells hold code.
+     * The same, except that code between backticks is painted in letters rather than spaces. A
+     * line that is a number and a command, {@code 1. `mvn test`}, is a step somebody wrote, and
+     * blanking its command would leave a number and a full stop, which is what an unfilled blank
+     * looks like. A letter keeps such a line filled, whichever line of a span it falls on, and the
+     * same holds for a table row whose cells hold code.
      */
     private static String blocksOnly(String text) {
-        return painted(text, false);
+        return painted(text, 'x');
     }
 
     /**
-     * The text with the regions found by {@link #regions(String)} replaced by spaces of their own
-     * length, the line breaks kept, taking code between backticks only when asked. A span always
-     * covers what it holds, so a marker inside one is never markup, whether or not it is painted.
+     * The text with the regions found by {@link #regions(String)} replaced by as many characters
+     * as they held, the line breaks kept. Comments and fenced blocks become spaces; code between
+     * backticks becomes whatever the caller asks for, since one caller needs it gone and the other
+     * needs only its shape gone.
      */
-    private static String painted(String text, boolean spansToo) {
+    private static String painted(String text, char spanFiller) {
         StringBuilder result = new StringBuilder(text);
         for (int[] region : regions(text)) {
-            if (region[2] == SPAN && !spansToo) {
-                continue;
-            }
+            char filler = region[2] == SPAN ? spanFiller : ' ';
             for (int index = region[0]; index < region[1]; index++) {
                 if (result.charAt(index) != '\n') {
-                    result.setCharAt(index, ' ');
+                    result.setCharAt(index, filler);
                 }
             }
         }

AGENTS.md

@@ -107,11 +107,11 @@ template's own skeleton, a bare `1.` inside a comment, is read as a blank somebo
 That is wrong about a body written in good faith, and is the accepted cost of closing a
 hole where text hid from the length count.
 
-What is not prose is found in one left-to-right walk rather than by searching for each
-construct separately, which is how the two settle their overlaps: a fence opening a line
-beats a code span left open above it, because Markdown decides blocks first, and a span
-covers what it holds, so a comment marker inside one is text rather than the start of a
-comment. It deliberately does not require checklist boxes to be ticked. It
+What is not prose is found in one left-to-right walk rather than by searching for comments,
+fenced blocks and code spans separately. That walk is what settles the overlaps between the
+three: a fence opening a line beats a code span left open above it because Markdown decides
+blocks first, and a span covers what it holds, so a comment marker inside one is text rather
+than the start of a comment. It deliberately does not require checklist boxes to be ticked. It
 re-runs when the description is edited, so a failure is fixed by editing the body rather
 than by pushing a commit.