method private queue_assertion ?(pos = Before) assertion_list =
    (* add an assertion (with an optionally given status) in front of current statement *)
    match assertion_list with
      | [] -> ()
      | _ ->
        let stmt = Extlib.the (self#current_stmt) in
        let kf = Extlib.the (self#current_kf) in
        let already_posted_assertions =
          try
            HStmt.find assertion_table stmt
          with Not_found -> []
        in let pruned_assertion_list =
             (* do not keep an assertion if an equivalent assertion (content)
                is already scheduled *)

             List.rev (
               List.fold_left
                 (fun acc (assertion, status_opt) ->
                   if not (List.exists
                             (fun p ->
                               Logic_utils.is_same_predicate
                                 p assertion.content)
                             already_posted_assertions)
                   then (assertion, status_opt) :: acc
                   else acc
                 ) [] assertion_list
             )
           in let loc_add_assertion assertion assertion_status_opt =
                let rte_named_assertion =
                  (* give a name to assertion in order to indicate
                     it has been generated by RTE plugin *)

                  { content = assertion.content ;
                    loc = assertion.loc ; name = [ rte_prefix ] }
                in let annot =
                     Logic_const.new_code_annotation
                       (AAssert ([], rte_named_assertion))
                   in
                   Annotations.add
                     stmt
                     [ rte_dep_state ]
                     (match pos with
                       | Before -> Db_types.Before (Db_types.User annot)
                       | After ->
                         Db_types.After (Db_types.User annot) (* not used *));
                   let astatus = match assertion_status_opt with
                     | None -> Unknown
                     | Some checked_status -> checked_status
                   in
                   let ip = Property.ip_of_code_annot kf stmt annot in
                   List.iter (fun x -> S.set x [] astatus) ip
              in
              (* update scheduled assertions *)
              let () = HStmt.replace assertion_table stmt
                (List.rev_append
                   (List.rev_map (fun (a,_) -> a.content) pruned_assertion_list)
                   already_posted_assertions)
              in
              Queue.add
                (fun () ->
                  List.iter
                    (fun (assertion, assertion_status_opt) ->
                      loc_add_assertion assertion assertion_status_opt
                    ) pruned_assertion_list
                ) self#get_filling_actions