fix potential bug for calc prec

Author: hackwaly

src/lib/driver/driver.mbt

@@ -219,6 +219,30 @@ pub fn compile(
     augmented_start_nt.productions.push(production)
     production
   })
+
+  // fix prec for productions
+  for prod in productions {
+    match prod.prec {
+      Some(_) => ()
+      None => {
+        let rightmost_term = prod.rhs.rev_iter().find_first(fn(x) { x is T(_) })
+        match rightmost_term {
+          Some(T(terminal)) => {
+            let term = get_terminal_by_name(terminal.name)
+            prod.prec = match term.prec {
+              Some((prec, _)) => Some(prec)
+              None => None
+            }
+          }
+          Some(NT(_)) => panic()
+          None => ()
+        }
+      }
+    }
+  }
+  // for prod in productions {
+  //   println(prod)
+  // }
   let grammar : @grm.Grammar = { terminals, nonterminals, productions, starts }
   let automaton = @lr1.Automaton::build(grammar, user_eoi=input_mode is Pull)
   let errors = @lr1.resolve_conflicts(automaton.conflicts)

src/lib/elab/elaborate.mbt

@@ -312,27 +312,12 @@ pub fn elaborate(
           }
           Some(prec)
         }
-        None => {
-          /// FROM ocamlyacc's manual
-          // > Tokens and rules have precedences.
-          // > By default, the precedence of a rule is the precedence of its rightmost terminal.
-          // I don't what "rightmost terminal" means, but I guess it means the last terminal in the rule.
-          // So, I'll use the precedence of the last terminal in the rule.
-          let mut last_prec = None
-          for item in items.rev_iter() {
-            match item.term {
-              Token(token) => {
-                last_prec = match token.prec {
-                  None => None
-                  Some((prec, _assoc)) => Some(prec)
-                }
-                break
-              }
-              Param(_) | RuleCall(_) => ()
-            }
-          }
-          last_prec
-        }
+        None =>
+          // The prec should be determined by the rightmost terminal
+          // in the rule. But the items of rule may be modified later, So
+          // we will set it to None for now, and delay the decision
+          // at building lr1 grammar.
+          None
       }
       let clause = Clause::{
         items,