Add codes mode support for double bar operator

Implements support for the double bar (||) operator when double_quotes
flag is set to codes, fixing issue #3142. The operator now correctly
handles string literals in all three modes (chars, codes, atom).

Changes:
- Modified parser to accept Term::Cons and empty list literals for
  codes-mode strings before the || operator
- Added replace_cons_tail helper to properly replace the tail of
  codes-mode lists
- Extended push_binary_op to handle codes-mode string concatenation

Tests:
- Added 35 comprehensive tests (8 chars mode + 27 codes mode)
- Full parity in comment handling, spacing, unicode, and edge cases
- All 56 tests passing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: jjtolton

src/parser/parser.rs

@@ -331,6 +331,25 @@ impl<'a, R: CharRead> Parser<'a, R> {
         }
     }
 
+    // Helper function to replace the tail of a Cons list with a new tail
+    fn replace_cons_tail(cons: Term, new_tail: Term) -> Term {
+        match cons {
+            Term::Cons(cell, head, tail) => {
+                match *tail {
+                    Term::Literal(_, Literal::Atom(atom)) if atom == atom!("[]") => {
+                        // Found the empty list tail, replace it
+                        Term::Cons(cell, head, Box::new(new_tail))
+                    }
+                    _ => {
+                        // Recurse on the tail
+                        Term::Cons(cell, head, Box::new(Self::replace_cons_tail(*tail, new_tail)))
+                    }
+                }
+            }
+            _ => cons,  // Not a Cons, return as-is (shouldn't happen)
+        }
+    }
+
     fn push_binary_op(&mut self, td: TokenDesc, spec: Specifier) {
         if let Some(arg2) = self.terms.pop() {
             if let Some(name) = self.get_term_name(td) {
@@ -346,6 +365,15 @@ impl<'a, R: CharRead> Parser<'a, R> {
                                     Term::PartialString(Cell::default(), s, Box::new(arg2))
                                 }
                             }
+                            Term::Literal(_, Literal::Atom(atom)) if atom == atom!("[]") => {
+                                // Empty string in codes mode: ""||K => K
+                                arg2
+                            }
+                            Term::Cons(_, _, _) => {
+                                // Handle codes mode: "abc" becomes Term::Cons([97,98,99])
+                                // Replace the [] tail with arg2
+                                Self::replace_cons_tail(arg1, arg2)
+                            }
                             _ => {
                                 // Should never reach here due to validation, but handle gracefully
                                 Term::Clause(Cell::default(), name, vec![arg1, arg2])
@@ -1129,12 +1157,14 @@ impl<'a, R: CharRead> Parser<'a, R> {
                     }
                 }
 
-                // Check that the last term is a string literal (CompleteString or PartialString)
-                // NOT arbitrary lists like [1,2,3] or variables
+                // Check that the last term is a string literal (CompleteString, PartialString, or Cons from codes mode)
+                // NOT arbitrary lists like [1,2,3] or variables from list syntax
                 let is_valid = if let Some(last_term) = self.terms.last() {
                     match last_term {
                         Term::CompleteString(_, _) => true,
                         Term::PartialString(_, _, _) => true,
+                        Term::Cons(_, _, _) => true,  // Allows codes mode: "abc" becomes [97,98,99]
+                        Term::Literal(_, Literal::Atom(atom)) if *atom == atom!("[]") => true,  // Empty string in codes mode
                         _ => false,
                     }
                 } else {

src/tests/double_bar.pl

@@ -125,3 +125,194 @@
 % - [a,b,c]||S => syntax_error
 % - K||[] => syntax_error
 % - ("a")||[] => syntax_error
+
+
+
+test("double bar chars mode empty at start of chain", (
+    L = ""||"abc"||"de",
+    L = [a,b,c,d,e]
+)).
+
+test("double bar chars mode empty in middle of chain", (
+    L = "ab"||""||"cd",
+    L = [a,b,c,d]
+)).
+
+test("double bar chars mode empty at end of chain", (
+    L = "abc"||"de"||"",
+    L = [a,b,c,d,e]
+)).
+
+test("double bar chars mode single character strings", (
+    L = "x"||"y"||"z",
+    L = [x,y,z]
+)).
+
+test("double bar chars mode unicode characters", (
+    L = "α"||"β"||tail,
+    L = [α,β|tail]
+)).
+
+test("double bar chars mode longer strings", (
+    L = "hello"||"world",
+    L = [h,e,l,l,o,w,o,r,l,d]
+)).
+
+test("double bar chars mode nested unification", (
+    "a"||"b"||X = [a,b,c],
+    X = [c]
+)).
+
+test("double bar chars mode with numeric tail", (
+    L = "abc"||123,
+    L = [a,b,c|123]
+)).
+% Tests for double bar with double_quotes set to codes
+% These must be in a separate section with the flag set at parse time
+
+:- set_prolog_flag(double_quotes, codes).
+
+test("double bar with codes mode basic", (
+    L = "abc"||K,
+    L = [97,98,99|K]
+)).
+
+test("double bar with codes mode empty string", (
+    L = ""||K,
+    L == K
+)).
+
+test("double bar with codes mode chain", (
+    L = "a"||"b"||"c",
+    L = [97,98,99]
+)).
+
+test("double bar with codes mode unification", (
+    "abc"||X = [97,98,99,100,101],
+    X = [100,101]
+)).
+
+test("double bar with codes mode mixed empty and non-empty", (
+    L = ""||"hello"||""||world,
+    L = [104,101,108,108,111|world]
+)).
+
+test("double bar with codes mode with atom tail", (
+    L = "abc"||xyz,
+    L = [97,98,99|xyz]
+)).
+
+
+test("double bar with codes mode multi-line with line comment", (
+    L = "a"|| % multiple lines
+        "b"||
+        "c",
+    L = [97,98,99]
+)).
+
+test("double bar with codes mode multi-line with block comment", (
+    L = "a"||"b"|| /* with comments */ "c",
+    L = [97,98,99]
+)).
+
+test("double bar with codes mode multi-line complex", (
+    L = "a"|| % first line
+        "b"|| /* second */
+        "c",
+    L = [97,98,99]
+)).
+
+test("double bar with codes mode spaced syntax", (
+    L = "abc" | | K,
+    L = [97,98,99|K]
+)).
+
+test("double bar with codes mode spaced chain", (
+    L = "a" | | "b" | | "c",
+    L = [97,98,99]
+)).
+
+test("double bar with codes mode block comment between bars", (
+    L = "a" | /* comment */ | "b",
+    L = [97,98]
+)).
+
+test("double bar with codes mode line comment between bars", (
+    L = "a" | % line comment
+        | "b",
+    L = [97,98]
+)).
+
+test("double bar with codes mode block comment in spaced bar with tail", (
+    L = "abc" |/* comment */| K,
+    L = [97,98,99|K]
+)).
+
+test("double bar with codes mode comment before double bar", (
+    L = "a" /* before */ || "b",
+    L = [97,98]
+)).
+
+test("double bar with codes mode comment after double bar", (
+    L = "a" || /* after */ "b",
+    L = [97,98]
+)).
+
+test("double bar with codes mode comment before spaced bars", (
+    L = "a" /* before */ | | "b",
+    L = [97,98]
+)).
+
+test("double bar with codes mode comment after spaced bars", (
+    L = "a" | | /* after */ "b",
+    L = [97,98]
+)).
+
+test("double bar with codes mode multiple comments around bars", (
+    L = "a" /* before */ | /* between */ | /* after */ "b",
+    L = [97,98]
+)).
+
+test("double bar with codes mode empty at start of chain", (
+    L = ""||"abc"||"de",
+    L = [97,98,99,100,101]
+)).
+
+test("double bar with codes mode empty in middle of chain", (
+    L = "ab"||""||"cd",
+    L = [97,98,99,100]
+)).
+
+test("double bar with codes mode empty at end of chain", (
+    L = "abc"||"de"||"",
+    L = [97,98,99,100,101]
+)).
+
+test("double bar with codes mode single character strings", (
+    L = "x"||"y"||"z",
+    L = [120,121,122]
+)).
+
+test("double bar with codes mode unicode characters", (
+    L = "α"||"β"||tail,
+    L = [945,946|tail]
+)).
+
+test("double bar with codes mode longer strings", (
+    L = "hello"||"world",
+    L = [104,101,108,108,111,119,111,114,108,100]
+)).
+
+test("double bar with codes mode nested unification", (
+    "a"||"b"||X = [97,98,99],
+    X = [99]
+)).
+
+
+test("double bar with codes mode with numeric tail", (
+    L = "abc"||123,
+    L = [97,98,99|123]
+)).
+
+
+:- set_prolog_flag(double_quotes, chars).