anchor.diff:      let pushCtxt tokenTup (newCtxt:Context) =
           let rec unindentationLimit strict stack = 
               match newCtxt,stack with 
  -            | _, [] -> (newCtxt.StartPos, -1) 
  +            | _, [] -> PositionWithColumn (newCtxt.StartPos, -1) 
   
               // ignore Vanilla because a SeqBlock is always coming 
               | _, (CtxtVanilla _ :: rest) -> unindentationLimit strict rest
  
positive.code: 
              | _ -> 
                  None
  
  
          let tokenBalancesHeadContext token stack = 
              match token,stack with 
              | END, (CtxtWithAsAugment(_)  :: _)
              | (ELSE | ELIF), (CtxtIf _ :: _)
              | DONE         , (CtxtDo _ :: _)
              // WITH balances except in the following contexts.... Phew - an overused keyword! 
              | WITH         , (  ((CtxtMatch _ | CtxtException _ | CtxtMemberHead _ | CtxtInterfaceHead _ | CtxtTry _ | CtxtTypeDefns _ | CtxtMemberBody _)  :: _)
                                      // This is the nasty record/object-expression case 
                                      | (CtxtSeqBlock _ :: CtxtParen(LBRACE,_)  :: _) )
              | FINALLY      , (CtxtTry _  :: _) -> 
                  true
  
              // for x in ienum ... 
              // let x = ... in
              | IN           , ((CtxtFor _ | CtxtLetDecl _) :: _) ->
                  true
              // 'query { join x in ys ... }'
              // 'query { ... 
              //          join x in ys ... }'
              // 'query { for ... do
              //          join x in ys ... }'
              | IN           , stack when detectJoinInCtxt stack ->
                  true
  
              // NOTE: ;; does not terminate a 'namespace' body. 
              | SEMICOLON_SEMICOLON, (CtxtSeqBlock _ :: CtxtNamespaceBody _ :: _) -> 
                  true
  
              | SEMICOLON_SEMICOLON, (CtxtSeqBlock _ :: CtxtModuleBody (_,true) :: _) -> 
                  true
  
              | t2           , (CtxtParen(t1,_) :: _) -> 
                  parenTokensBalance t1  t2
  
              | _ -> 
                  false
  
          let rec suffixExists p l = match l with [] -> false | _::t -> p t || suffixExists p t
  
          // Balancing rule. Every 'in' terminates all surrounding blocks up to a CtxtLetDecl, and will be swallowed by 
          // terminating the corresponding CtxtLetDecl in the rule below. 
  
negative.code:               | _ -> None
      Some([| for _c in angles do yield GREATER |],afterOp)
  
  [<Struct>]
  type PositionWithColumn =
      val Position: Position
      val Column: int
      new (position: Position, column: int) = { Position = position; Column = column }
  
  //----------------------------------------------------------------------------
  // build a LexFilter
  //--------------------------------------------------------------------------*)
  