Fix: Reject list syntax before || operator and support | | spacing

Addresses feedback from @bakaq about [a,b,c]||S being incorrectly accepted
and support for spaced "| |" syntax per spec.

Issue 1: List syntax like [a,b,c] was incorrectly accepted
---------------------------------------------------------
The issue was that in chars mode, reduce_list() converts lists like [a,b,c]
to CompleteString terms, making them indistinguishable from actual string
literals "abc" by the time the || validation runs.

Solution: Introduce LIST_TERM spec constant to mark terms originating from
list syntax ([...]), distinct from string literals ("..."). The || operator
now correctly rejects list syntax while accepting only double-quoted strings.

Issue 2: Spaced "| |" syntax not supported
-------------------------------------------
The spec explicitly shows "a"| |"b"| |"c" as valid syntax with spaces
between the bars. Modified HeadTailSeparator handling to peek ahead and
detect two consecutive | tokens, treating them as DoubleBar.

Comments are supported in all positions per spec:
- Before bars: "a" /* comment */ || "b"
- After bars: "a" || /* comment */ "b"
- Between bars: "a" | /* comment */ | "b"
- Multiple positions: "a" /* c1 */ | /* c2 */ | /* c3 */ "b"
- Line comments: "a" | % comment
                     | "b"

Changes:
- src/parser/ast.rs: Add LIST_TERM = 0x5000 constant
- src/parser/parser.rs:
  * Set LIST_TERM spec in reduce_list()
  * Check LIST_TERM in || validation to reject list syntax
  * Detect | | token pair and handle as DoubleBar
- src/tests/double_bar.pl:
  * Document [a,b,c]||S as invalid case
  * Add tests for spaced "| |" syntax
  * Add comprehensive tests for comments in all positions

Tested:
✅ [a,b,c]||S correctly rejected
✅ [1,2,3]||K correctly rejected
✅ [_]||Rs correctly rejected
✅ "abc"||K works correctly
✅ "abc" | | K works correctly (spaced syntax)
✅ "a" | | "b" | | "c" works correctly
✅ Comments before, after, and between bars work correctly
✅ All 21 integration tests pass
✅ All cargo tests pass (no regressions)

Author: jjtolton

src/parser/ast.rs

@@ -141,6 +141,7 @@ pub const DELIMITER: u32 = 0x0100;
 pub const TERM: u32 = 0x1000;
 pub const LTERM: u32 = 0x3000;
 pub const BTERM: u32 = 0x11000;
+pub const LIST_TERM: u32 = 0x5000;
 
 pub const NEGATIVE_SIGN: u32 = 0x0200;
 

src/parser/parser.rs

@@ -757,7 +757,7 @@ impl<'a, R: CharRead> Parser<'a, R> {
         self.stack.push(TokenDesc {
             tt: TokenType::Term,
             priority: 0,
-            spec: TERM,
+            spec: LIST_TERM,
             unfold_bounds: 0,
         });
 
@@ -1044,30 +1044,74 @@ impl<'a, R: CharRead> Parser<'a, R> {
                 }
             }
             Token::HeadTailSeparator => {
-                /* '|' as an operator must have priority > 1000 and can only be infix.
-                 * See: http://www.complang.tuwien.ac.at/ulrich/iso-prolog/dtc2#Res_A78
-                 */
-                let (priority, spec) = get_op_desc(atom!("|"), op_dir)
-                    .map(|CompositeOpDesc { inf, spec, .. }| (inf, spec))
-                    .unwrap_or((1000, DELIMITER));
+                // Check if next token is also HeadTailSeparator (i.e., "| |" with space)
+                // This allows both "||" and "| |" syntax per spec
+                if matches!(self.tokens.last(), Some(Token::HeadTailSeparator)) {
+                    // Pop the second | and treat as DoubleBar
+                    self.tokens.pop();
+
+                    // Handle as DoubleBar - check validation constraints
+                    if let Some(last_stack) = self.stack.last() {
+                        if last_stack.tt == TokenType::Term && last_stack.spec == BTERM {
+                            return Err(ParserError::IncompleteReduction(
+                                self.lexer.line_num,
+                                self.lexer.col_num,
+                            ));
+                        }
+                        if last_stack.tt == TokenType::Term && last_stack.spec == LIST_TERM {
+                            return Err(ParserError::IncompleteReduction(
+                                self.lexer.line_num,
+                                self.lexer.col_num,
+                            ));
+                        }
+                    }
 
-                let old_stack_len = self.stack.len();
+                    let is_valid = if let Some(last_term) = self.terms.last() {
+                        match last_term {
+                            Term::CompleteString(_, _) => true,
+                            Term::PartialString(_, _, _) => true,
+                            _ => false,
+                        }
+                    } else {
+                        false
+                    };
 
-                self.reduce_op(priority);
+                    if !is_valid {
+                        return Err(ParserError::IncompleteReduction(
+                            self.lexer.line_num,
+                            self.lexer.col_num,
+                        ));
+                    }
 
-                let new_stack_len = self.stack.len();
+                    self.reduce_op(1);
+                    self.shift(Token::DoubleBar, 1, XFY as u32);
+                } else {
+                    // Handle as regular HeadTailSeparator
+                    /* '|' as an operator must have priority > 1000 and can only be infix.
+                     * See: http://www.complang.tuwien.ac.at/ulrich/iso-prolog/dtc2#Res_A78
+                     */
+                    let (priority, spec) = get_op_desc(atom!("|"), op_dir)
+                        .map(|CompositeOpDesc { inf, spec, .. }| (inf, spec))
+                        .unwrap_or((1000, DELIMITER));
 
-                if let Some(term_desc) = self.stack.last_mut() {
-                    term_desc.unfold_bounds = old_stack_len - new_stack_len;
-                }
+                    let old_stack_len = self.stack.len();
+
+                    self.reduce_op(priority);
+
+                    let new_stack_len = self.stack.len();
 
-                self.shift(Token::HeadTailSeparator, priority, spec);
+                    if let Some(term_desc) = self.stack.last_mut() {
+                        term_desc.unfold_bounds = old_stack_len - new_stack_len;
+                    }
+
+                    self.shift(Token::HeadTailSeparator, priority, spec);
+                }
             }
             Token::DoubleBar => {
                 // Double bar operator only valid after string literals
                 // NOT valid after parenthesized expressions or variables
 
-                // Check that the last stack element is not from brackets
+                // Check that the last stack element is not from brackets or list syntax
                 if let Some(last_stack) = self.stack.last() {
                     if last_stack.tt == TokenType::Term && last_stack.spec == BTERM {
                         // Term came from parentheses like ("a"), reject it
@@ -1076,6 +1120,13 @@ impl<'a, R: CharRead> Parser<'a, R> {
                             self.lexer.col_num,
                         ));
                     }
+                    if last_stack.tt == TokenType::Term && last_stack.spec == LIST_TERM {
+                        // Term came from list syntax like [a,b,c], reject it
+                        return Err(ParserError::IncompleteReduction(
+                            self.lexer.line_num,
+                            self.lexer.col_num,
+                        ));
+                    }
                 }
 
                 // Check that the last term is a string literal (CompleteString or PartialString)

src/tests/double_bar.pl

@@ -64,12 +64,64 @@
     L = [a,b,c]
 )).
 
+test("spaced double bar syntax", (
+    L = "abc" | | K,
+    L = [a,b,c|K]
+)).
+
+test("spaced double bar chain", (
+    L = "a" | | "b" | | "c",
+    L = [a,b,c]
+)).
+
+test("block comment between bars", (
+    L = "a" | /* comment */ | "b",
+    L = [a,b]
+)).
+
+test("line comment between bars", (
+    L = "a" | % line comment
+        | "b",
+    L = [a,b]
+)).
+
+test("block comment in spaced bar with tail", (
+    L = "abc" |/* comment */| K,
+    L = [a,b,c|K]
+)).
+
+test("comment before double bar", (
+    L = "a" /* before */ || "b",
+    L = [a,b]
+)).
+
+test("comment after double bar", (
+    L = "a" || /* after */ "b",
+    L = [a,b]
+)).
+
+test("comment before spaced bars", (
+    L = "a" /* before */ | | "b",
+    L = [a,b]
+)).
+
+test("comment after spaced bars", (
+    L = "a" | | /* after */ "b",
+    L = [a,b]
+)).
+
+test("multiple comments around bars", (
+    L = "a" /* before */ | /* between */ | /* after */ "b",
+    L = [a,b]
+)).
+
 % Note: These invalid cases are tested at parse time, not runtime
 % They cannot be included as test/2 predicates because they fail at read_term
 % The parser correctly rejects them with syntax_error(incomplete_reduction)
 %
 % Invalid cases (verified separately):
 % - [1,2,3]||K => syntax_error
 % - [_]||Rs => syntax_error
+% - [a,b,c]||S => syntax_error
 % - K||[] => syntax_error
 % - ("a")||[] => syntax_error