anchor.diff:  //         nextHigherPrecedenceExpression
   //                 (OPERATOR nextHigherPrecedenceExpression)*
   // which is a standard recursive definition for a parsing an expression.
  -// The operators in java have the following precedences:
  -//      lowest  ( 15)  = **= *= /= %= += -= <<= >>= >>>= &= ^= |=
  +// The operators have the following precedences:
  +//      lowest  ( 15)  = **= *= /= %= += -= <<= >>= >>>= &= ^= |= (assignments)
   //              ( 14)  ?: (conditional expression and elvis)
  -//              ( 13)  ||
  -//              ( 12)  &&
  -//              ( 11)  |
  -//              ( 10)  ^
  -//              (  9)  &
  -//              (8.5)  =~ ==~
  -//              (  8)  == != <=> === !==
  -//              (  7)  < <= > >= instanceof as in
  -//              (  6)  << >> .. ..<
  -//              (  5)  +(binary) -(binary)
  -//              (  4)  * / %
  -//              (  3)  **(power)
  -//              (  2)  ++(pre) --(pre) +(unary) -(unary)
  -//              (  1)  ~  ! $ (type) ++(post) --(post)
  -//                     . ?. *. (dot -- identifier qualification)
  -//                     []   () (method call)  {} (closableBlock)  [] (list/map)
  -//                     new  () (explicit parenthesis)
  -//                     $x (scope escape)
  +//              ( 13)  || (logical or)
  +//              ( 12)  && (logical and)
  +//              ( 11)  | ()binary or
  +//              ( 10)  ^ (binary xor)
  +//              (  9)  & (binary and)
  +//              (8.5)  =~ ==~ (regex find/match)
  +//              (  8)  == != <=> === !== (equals, not equals, compareTo)
  +//              (  7)  < <= > >= instanceof as in (relational, in, instanceof, type coercion)
  +//              (  6)  << >> >>> .. ..< (shift, range)
  +//              (  5)  + - (addition, subtraction)
  +//              (  4)  * / % (multiply div modulo)
  +//              (  3)  ++ -- + - (pre dec/increment, unary signs)
  +//              (  2)  ** (power)
  +//              (  1)  ~ ! $ (type) (negate, not, typecast)
  +//                     ?. * *. *: (safe dereference, spread, spread-dot, spread-map)
  +//                     . .& .@ (member access, method closure, field/attribute access)
  +//                     [] ++ -- (list/map/array index, post inc/decrement)
  +//                     () {} [] (method call, closableBlock, list/map literal)
  +//                     new () (object creation, explicit parenthesis)
   //
   // the last two are not usually on a precedence chart; I put them in
   // to point out that new has a higher precedence than '.', so you
  
positive.code:     |   unaryExpressionNotPlusMinus[lc_stmt]
      ;
  
  // ~(BNOT)/!(LNOT)/(type casting) (level 1)
  unaryExpressionNotPlusMinus[int lc_stmt]
      :   //BAND^    {#BAND.setType(MEMBER_POINTER_DEFAULT);}   nls!  namePart
      //|
          BNOT^ nls! unaryExpression[0]
      |   LNOT^ nls! unaryExpression[0]
      |   (   // subrule allows option to shut off warnings
              options {
  
negative.code:         )
      ;
  
  // qualified names, array expressions, method invocation, post inc/dec (level 1)
  postfixExpression[int lc_stmt]
      :
          pathExpression[lc_stmt]
  