callback.rs

#![feature(rustc_private)]
extern crate rustc_hir;
extern crate rustc_middle;
 
// Doesn't work.
 
use rustc_hir::intravisit::Visitor;
use rustc_middle::ty::TyCtxt;
 
 
// Works
 
// #[derive(Clone)]
// struct TyCtxt<'tcx>(&'tcx i32);
// impl<'tcx> TyCtxt<'tcx> {
//     fn hir_visit_all_item_likes_in_crate<V: Visitor<'tcx>>(self, visitor: &mut V) {}
// }
// trait Visitor<'tcx> {}
 
 
 
trait DynVisitor<'tcx> {}
 
impl<'tcx, V: Visitor<'tcx>> DynVisitor<'tcx> for V {}
 
struct DynWrapper<'tcx>(Box<dyn DynVisitor<'tcx> + 'tcx>);
 
impl<'tcx> Visitor<'tcx> for DynWrapper<'tcx> {}
 
trait Pass: Send {
    fn visitor<'tcx>(&'tcx mut self, tcx: TyCtxt<'tcx>) -> DynWrapper<'tcx>;
}
 
 
struct MyPass(Vec<String>);
 
impl Pass for MyPass {
    fn visitor<'tcx>(&'tcx mut self, tcx: TyCtxt<'tcx>) -> DynWrapper<'tcx> {
        DynWrapper(Box::new(MyVisitor(tcx, &mut self.0)))
    }
}
 
struct MyVisitor<'a, 'tcx>(TyCtxt<'tcx>, &'a mut Vec<String>);
 
impl<'a, 'tcx> Visitor<'tcx> for MyVisitor<'a, 'tcx> {}
 
 
#[derive(Default)]
struct MyCallback(Vec<String>, Vec<Box<dyn Pass>>);
 
impl MyCallback {
    fn add_pass(&mut self, pass: Box<dyn Pass>) {
        self.1.push(pass);
    }
 
    fn findings(&self) -> &[String] {
        &self.0
    }
}
 
trait Callback {
    fn do_work<'tcx>(&mut self, tcx: TyCtxt<'tcx>);
}
 
impl Callback for MyCallback {
    fn do_work<'tcx>(&mut self, tcx: TyCtxt<'tcx>) {
        for pass in &mut self.1 {
            let mut visitor = pass.visitor(tcx.clone());
            // tcx.hir_visit_all_item_likes_in_crate(&mut visitor);
        }
    }
}
 
 
fn run() -> Vec<String> {
    let mut callbacks = MyCallback::default();
    let unsafe_pass = Box::new(MyPass(Vec::new()));
    callbacks.add_pass(unsafe_pass);
    callbacks.0
}