Accept Text Blocks In Switch Cases And Implement JEP 378 Escapes

Extend the Apex grammar so TextBlockLiteral is a valid whenLiteral,
letting switch statements dispatch on multi-line string literals the
same way they dispatch on single-quoted strings.

Update the lexer with two JEP 378 escapes inside text blocks: a
backslash followed by any character (so \''' no longer prematurely
closes the block) and \s inside ordinary single-quoted string
literals. Update the text-block state scanner used by the formatter
to walk character-by-character while inside a block so the same
backslash-escaped triple-quote sequence does not flip it into the
outside state and un-indent subsequent code.

Author: cwarden

formatter/text_block_test.go

@@ -265,6 +265,118 @@ func TestFormatter_AdjacentTextBlocksStayIndependent(t *testing.T) {
 	}
 }
 
+// TestFormatter_TextBlockWithJep378Escapes asserts apexfmt round-trips
+// the JEP 378 escape sequences — \s (space), \<line-terminator>, and
+// \”' (escaped triple quote) — without corrupting them. These escapes
+// are lexer-level constructs that the formatter must preserve verbatim
+// the same way it preserves \n and \t.
+func TestFormatter_TextBlockWithJep378Escapes(t *testing.T) {
+	input := "public class Foo {\n" +
+		"\tpublic static String fenced() {\n" +
+		"\t\treturn '''\n" +
+		"red  \\s\n" +
+		"green\\s\n" +
+		"blue \\s\n" +
+		"''';\n" +
+		"\t}\n" +
+		"\n" +
+		"\tpublic static String continued() {\n" +
+		"\t\treturn '''\n" +
+		"one \\\n" +
+		"two''';\n" +
+		"\t}\n" +
+		"\n" +
+		"\tpublic static String withTriple() {\n" +
+		"\t\treturn '''\n" +
+		"before \\''' after''';\n" +
+		"\t}\n" +
+		"}\n"
+	f := NewFormatter("", strings.NewReader(input))
+	if err := f.Format(); err != nil {
+		t.Fatalf("Format() failed: %v", err)
+	}
+	got := string(f.formatted)
+	if got != input {
+		t.Fatalf("JEP 378 escapes were altered\nwant:\n%q\n got:\n%q", input, got)
+	}
+}
+
+// TestFormatter_SlashSInRegularString asserts \s is accepted by the
+// single-quoted StringLiteral grammar and formatted unchanged.
+func TestFormatter_SlashSInRegularString(t *testing.T) {
+	input := "public class Foo {\n" +
+		"\tpublic static String s = 'a\\sb';\n" +
+		"}\n"
+	f := NewFormatter("", strings.NewReader(input))
+	if err := f.Format(); err != nil {
+		t.Fatalf("Format() failed: %v", err)
+	}
+	got := string(f.formatted)
+	if got != input {
+		t.Fatalf("\\s in string literal was altered\nwant:\n%q\n got:\n%q", input, got)
+	}
+}
+
+// TestFormatter_TextBlockAsSwitchCaseLiteral asserts that a text block is
+// accepted as a switch-when case value. The whenLiteral grammar rule must
+// accept TextBlockLiteral in the same positions as StringLiteral so that
+// multi-line case literals round-trip through the formatter unchanged.
+func TestFormatter_TextBlockAsSwitchCaseLiteral(t *testing.T) {
+	input := "public class Foo {\n" +
+		"\tpublic static String classify(String s) {\n" +
+		"\t\tString branch = '';\n" +
+		"\t\tswitch on s {\n" +
+		"\t\t\twhen '''\n" +
+		"hello''' {\n" +
+		"\t\t\t\tbranch = 'matched';\n" +
+		"\t\t\t}\n" +
+		"\t\t\twhen else {\n" +
+		"\t\t\t\tbranch = 'other';\n" +
+		"\t\t\t}\n" +
+		"\t\t}\n" +
+		"\t\treturn branch;\n" +
+		"\t}\n" +
+		"}\n"
+	f := NewFormatter("", strings.NewReader(input))
+	if err := f.Format(); err != nil {
+		t.Fatalf("Format() failed: %v", err)
+	}
+	got := string(f.formatted)
+	if got != input {
+		t.Fatalf("text block in switch case was altered\nwant:\n%q\n got:\n%q", input, got)
+	}
+}
+
+// TestFormatter_MultipleTextBlockSwitchCases asserts the comma-separated
+// whenLiteral list accepts multiple text block literals back-to-back.
+func TestFormatter_MultipleTextBlockSwitchCases(t *testing.T) {
+	input := "public class Foo {\n" +
+		"\tpublic static String classify(String s) {\n" +
+		"\t\tString branch = '';\n" +
+		"\t\tswitch on s {\n" +
+		"\t\t\twhen '''\n" +
+		"one''', '''\n" +
+		"two''', '''\n" +
+		"three''' {\n" +
+		"\t\t\t\tbranch = 'hit';\n" +
+		"\t\t\t}\n" +
+		"\t\t\twhen else {\n" +
+		"\t\t\t\tbranch = 'miss';\n" +
+		"\t\t\t}\n" +
+		"\t\t}\n" +
+		"\t\treturn branch;\n" +
+		"\t}\n" +
+		"}\n"
+	f := NewFormatter("", strings.NewReader(input))
+	if err := f.Format(); err != nil {
+		t.Fatalf("Format() failed: %v", err)
+	}
+	got := string(f.formatted)
+	if got != input {
+		t.Fatalf("comma-separated text block cases were altered\nwant:\n%q\n got:\n%q", input, got)
+	}
+}
+
 // TestFormatter_TextBlockInsideIndentedMethodBody is the end-to-end
 // regression: a text block nested inside two levels of block indentation
 // must come out with the surrounding code re-indented normally but its

formatter/visitor.go

@@ -377,12 +377,24 @@ func updateTextBlockState(line string, insideTextBlock bool) bool {
 	i := 0
 	for i < len(line) {
 		if insideTextBlock {
-			if idx := strings.Index(line[i:], "'''"); idx >= 0 {
-				i += idx + 3
-				insideTextBlock = false
-				continue
+			// Walk forward char by char so backslash-escaped delimiters
+			// (\''' per JEP 378) do not spuriously close the block.
+			for i < len(line) {
+				if line[i] == '\\' && i+1 < len(line) {
+					i += 2
+					continue
+				}
+				if i+2 < len(line) && line[i] == '\'' && line[i+1] == '\'' && line[i+2] == '\'' {
+					i += 3
+					insideTextBlock = false
+					break
+				}
+				i++
 			}
-			return insideTextBlock
+			if insideTextBlock {
+				return insideTextBlock
+			}
+			continue
 		}
 		c := line[i]
 		switch {

grammar/ApexLexer.g4

@@ -330,9 +330,12 @@ BooleanLiteral
 
 // Triple-quoted (multi-line) string literal. Must be matched before
 // StringLiteral so the longest-match rule picks it up on inputs that
-// start with three single quotes.
+// start with three single quotes. The content allows backslash-escaped
+// characters (including an escaped ''' sequence via \''' and an explicit
+// line continuation \<line-terminator>); non-greedy '.*?' stops at the
+// first unescaped ''' triple.
 TextBlockLiteral
-    :   '\'\'\'' .*? '\'\'\''
+    :   '\'\'\'' ( '\\' . | ~[\\] )*? '\'\'\''
     ;
 
 StringLiteral
@@ -351,10 +354,12 @@ StringCharacter
     ;
 
 // §3.10.6 Escape Sequences for Character and String Literals
-
+// 's' (space) is a Java text-block escape; it is also accepted in
+// single-quoted string literals so that source produced by
+// copy-pasting from a text block keeps working.
 fragment
 EscapeSequence
-    :   '\\' [btnfr"'\\]
+    :   '\\' [btnfrs"'\\]
     |   '\\u' HexCharacter HexCharacter HexCharacter HexCharacter
     ;
 

grammar/ApexParser.g4

@@ -320,6 +320,7 @@ whenLiteral
     : (SUB)? IntegerLiteral
     | LongLiteral
     | StringLiteral
+    | TextBlockLiteral
     | NULL
     | id
     // Salesforce tolerates paren pairs around each literal,