grammar: Remove Ignore expression to avoid parsing ambiguity :'(

grammar.ebnf

@@ -15,14 +15,13 @@ Fn          = "fn" Identifier Block ; (* TODO: params, return value*)
 
 (* # Expressions *)
 (* expression *)
-Expr        = Ignore ;
+Expr        = Assign ;
 Block       = '{' Expr '}' ;
 Group       = '(' Expr? ')' ;
 Primary     = Item | Identifier | Literal
               | Block | Group | Branch ;
 
 (* expression::math *)
-Ignore      = Assign  (IgnoreOp  Assign )* ;
 Assign      = Compare (AssignOp  Compare)* ;
 Compare     = Range   (CompareOp Range  )* ;
 Range       = Logic   (RangeOp   Logic  )* ;
@@ -34,7 +33,6 @@ Factor      = Unary   (FactorOp  Unary  )* ;
 Unary       = (UnaryOp)* Primary ;
 
 (* expression::math::operator *)
-IgnoreOp    =  ';' ;
 AssignOp    =  '=' | "+=" | "-=" | "*=" | "/=" |
               "&=" | "|=" | "^=" |"<<=" |">>=" ;
 CompareOp   =  '<' | "<=" | "==" | "!=" | ">=" | '>' ;

libconlang/src/ast.rs

@@ -270,18 +270,16 @@ pub mod expression {
         r"  | 8 |    Assign |", r"`*=`, `/=`, `%=`, `+=`, `-=`, ",//|
         /*  |   |           |*/ r"`&=`, <code>&#124;=</code>, ",  //|
         /*  |   |           |*/ r"`^=`, `<<=`, `>>=`",            r"| Right to Left")]
-        //! | 9 |    Ignore | `;` |
         //!
         //! <!-- Note: '&#124;' == '|' /-->
         //!
         //! ## Syntax
         //! ```ignore
         //! /* All precedence levels other than Unary fold into Binary */
-        //! Ignore  := Assign  (CompareOp Assign )*
-        //! Assign  := Compare (IgnoreOp  Compare)*
-        //! Compare := Logic   (AssignOp  Logic  )*
+        //! Assign  := Compare (AssignOp  Compare)*
+        //! Compare := Logic   (CompareOp Logic  )*
         //! Logic   := Bitwise (LogicOp   Bitwise)*
-        //! Bitwise := Shift   (BitOp     Shift  )*
+        //! Bitwise := Shift   (BitwiseOp Shift  )*
         //! Shift   := Term    (ShiftOp   Term   )*
         //! Term    := Factor  (TermOp    Factor )*
         //! Factor  := Unary   (FactorOp  Unary  )*
@@ -324,7 +322,7 @@ pub mod expression {
               r"| 7 |", r"`*=`, `/=`, `%=`, `+=`, `-=`, ",//|
             /*  |   |*/ r"`&=`, <code>&#124;=</code>, ",  //|
             /*  |   |*/ r"`^=`, `<<=`, `>>=`, `=`",       r"| Left to Right")]
-            //! | 8 | `;`                                   |
+            //! | 8 | `,`                                   |
 
             /// Operators which take a single argument
             ///
@@ -430,9 +428,6 @@ pub mod expression {
                 ShlAssign,
                 /// `>>=`: Right Shift In-place Assignment
                 ShrAssign,
-                // Ignorance operators
-                /// `;`: Ignore
-                Ignore,
             }
         }
     }

libconlang/src/parser.rs

@@ -341,7 +341,7 @@ impl Parser {
 impl Parser {
     fn expr(&mut self) -> PResult<expression::Expr> {
         use expression::Expr;
-        Ok(Expr { ignore: self.ignore()? })
+        Ok(Expr { ignore: self.assign()? })
     }
     fn block(&mut self) -> PResult<expression::Block> {
         self.delimited(Type::LCurly, |p| p.expr(), Type::RCurly)
@@ -408,8 +408,7 @@ macro binary ($($f:ident = $a:ident, $b:ident);*$(;)?) {$(
 /// # [Arithmetic and Logical Subexpressions](math)
 impl Parser {
     binary! {
-        //name    operands operators
-        ignore  = assign,  ignore_op;
+        // name   operands operators
         assign  = compare, assign_op;
         compare = range,   compare_op;
         range   = logic,   range_op;
@@ -491,10 +490,6 @@ impl Parser {
             Type::LtLtEq => ShlAssign,
             Type::GtGtEq => ShrAssign,
         }
-        ignore_op: {
-            Type::Semi => Ignore,
-        }
-
     }
     /// Parse a [unary operator](operator::Unary)
     fn unary_op(&mut self) -> PResult<operator::Unary> {

libconlang/src/pretty_printer.rs

@@ -147,7 +147,6 @@ impl<W: Write> Visitor<IOResult<()>> for Printer<W> {
             Binary::BitXorAssign => "^=",
             Binary::ShlAssign => "<<=",
             Binary::ShrAssign => ">>=",
-            Binary::Ignore => ";",
         })
     }
     fn visit_unary_op(&mut self, op: &operator::Unary) -> IOResult<()> {