Fix (|) to ALWAYS error per ISO conformity test s#360

Per clarification on Issue #4 and conformity test s#360:
- (|) must be a syntax error regardless of operator status
- Even with op(1105,xfy,'|'), writeq((|)) must error
- The only valid way to write bar as atom is '|' (quoted)

Changes:
- Simplify reduce_brackets() to always reject HeadTailSeparator
- Remove op_dir parameter (no longer needed)
- Update lr_artifacts_3170 tests to use '|' instead of (|)
- Add conformity test s#360: (|) errors even with op defined
- Add test verifying '|' (quoted) is valid

Author: jjtolton

src/parser/parser.rs

@@ -812,7 +812,7 @@ impl<'a, R: CharRead> Parser<'a, R> {
         Ok(false)
     }
 
-    fn reduce_brackets(&mut self, op_dir: &CompositeOpDir) -> bool {
+    fn reduce_brackets(&mut self) -> bool {
         if self.stack.is_empty() {
             return false;
         }
@@ -835,18 +835,13 @@ impl<'a, R: CharRead> Parser<'a, R> {
                 // Reject incomplete reductions and ISO-forbidden syntax
                 // See: https://www.complang.tuwien.ac.at/ulrich/iso-prolog/dtc2#C2
                 match self.stack[idx].tt {
-                    TokenType::Comma => {
+                    TokenType::Comma | TokenType::HeadTailSeparator => {
+                        // ISO: (,) and (|) are NEVER valid syntax.
+                        // Bar and comma are solo characters but NOT atoms.
+                        // Use '|' or ',' (quoted) to write them as atoms.
+                        // See conformity test s#360: even with op(1105,xfy,'|'), (|) must error.
                         return false;
                     }
-                    TokenType::HeadTailSeparator => {
-                        // ISO TC2 C2: (|) is only valid when | IS an operator
-                        // When | is not an operator, bar is "not an atom" so (|) is invalid
-                        // When | IS an operator, bar is "equivalent to atom '|'" so (|) is valid
-                        if get_op_desc(atom!("|"), op_dir).is_none() {
-                            return false;
-                        }
-                        // Fall through - | is an operator, allow (|)
-                    }
                     _ => {}
                 }
 
@@ -1013,7 +1008,7 @@ impl<'a, R: CharRead> Parser<'a, R> {
             Token::Open => self.shift(Token::Open, 1300, DELIMITER),
             Token::OpenCT => self.shift(Token::OpenCT, 1300, DELIMITER),
             Token::Close => {
-                if !self.reduce_term() && !self.reduce_brackets(op_dir) {
+                if !self.reduce_term() && !self.reduce_brackets() {
                     return Err(ParserError::IncompleteReduction(
                         self.lexer.line_num,
                         self.lexer.col_num,

src/tests/iso_syntax_errors.pl

@@ -15,6 +15,25 @@
     )
 )).
 
+%% Conformity test s#360: (|) must error even when | IS an operator
+%% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing#360
+test("single_bar_in_parens_with_op_defined_should_error", (
+    op(1105, xfy, '|'),
+    catch(
+        (read_from_chars("(|).", _), false),
+        error(syntax_error(_), _),
+        true
+    ),
+    op(0, xfy, '|')
+)).
+
+%% ISO: The only valid way to write bar as an atom is '|' (quoted)
+%% Per Cor.2 8.14.3.4: permission_error(create, operator, '|')
+test("quoted_bar_atom_is_valid", (
+    read_from_chars("'|'.", T),
+    T == '|'
+)).
+
 test("op_create_empty_curly_should_error", (
     catch(
         (op(500, xfy, {}), false),

src/tests/lr_artifacts_3170.pl

@@ -86,10 +86,8 @@
     op(0, xfy, '|')
 )).
 
-test("quoted_bar_in_curly_succeeds", (
-    op(1105, xfy, '|'),
-    read_from_chars("{(|)}.", T),
-    op(0, xfy, '|'),
+test("quoted_bar_atom_in_curly_succeeds", (
+    read_from_chars("{'|'}.", T),
     T == '{}'('|')
 )).
 
@@ -100,10 +98,8 @@
     T == '{}'('|'(a,b))
 )).
 
-test("quoted_bar_in_expression_succeeds", (
-    op(1105, xfy, '|'),
-    read_from_chars("{a*(|)}.", T),
-    op(0, xfy, '|'),
+test("quoted_bar_atom_in_expression_succeeds", (
+    read_from_chars("{a*'|'}.", T),
     T == '{}'(a*'|')
 )).