attempt to use librustc

gistfile1.rs

#![feature(rustc_private,old_path,int_uint,box_syntax)]

#[macro_use] extern crate log;

extern crate rustc_driver;
extern crate rustc_typeck;
extern crate rustc_resolve;
extern crate rustc;
extern crate syntax;

use rustc_driver::driver;
use rustc::session::{self, config, build_session};
use syntax::diagnostic;
use syntax::diagnostic::Emitter;
use syntax::codemap;
use syntax::codemap::{Span, CodeMap, DUMMY_SP};
use syntax::diagnostic::{Level, RenderSpan, Bug, Fatal, Error, Warning, Note, Help};
use syntax::{abi, ast, ast_map};
use rustc_typeck::middle::ty::{self, Ty};
use rustc_typeck::middle::lang_items;
use rustc_resolve as resolve;
use rustc_typeck::middle::resolve_lifetime;
use rustc_typeck::middle::region::{self, CodeExtent, DestructionScopeData};
use rustc_typeck::middle::stability;


// Stub error emitter
struct MyErrorEmitter;

impl Emitter for MyErrorEmitter {
    fn emit(&mut self,
            _cmsp: Option<(&codemap::CodeMap, Span)>,
            msg: &str,
            _: Option<&str>,
            lvl: Level)
    {
        println!("PHIL {:?} msg={}",lvl, msg);
        //remove_message(self, msg, lvl);
    }

    fn custom_emit(&mut self,
                   _cm: &codemap::CodeMap,
                   _sp: RenderSpan,
                   msg: &str,
                   lvl: Level)
    {
        println!("PHIL {:?} msg={}",lvl, msg);
    }
}


fn main() {
    let input = config::Input::Str("fn main() {}".to_string());

    let fpath = Path::new("/home/pld/src/rust/try-rustc/a.rs");

    let emitter = box MyErrorEmitter;

    let codemap =
        CodeMap::new();
    let diagnostic_handler =
        diagnostic::mk_handler(true, emitter);
    let span_diagnostic_handler =
        diagnostic::mk_span_handler(diagnostic_handler, codemap);

    // compile options
    let mut options = config::basic_options();
    options.maybe_sysroot = Some(Path::new("/usr/local"));
    options.debugging_opts.verbose = true;
    options.unstable_features = config::UnstableFeatures::Default;
    let mut crate_types = Vec::new();
    crate_types.push(config::CrateType::CrateTypeExecutable);
    options.crate_types = crate_types;

    println!("PHIL lib path = {:?}",options.maybe_sysroot);


    let sess = session::build_session_(options, Some(fpath), span_diagnostic_handler);
    let krate_config = Vec::new();
    //let input = config::Input::Str(source_string.to_string());
    let krate = driver::phase_1_parse_input(&sess, krate_config, &input);
    let krate = driver::phase_2_configure_and_expand(&sess, krate, "a", None)
                    .expect("phase 2 aborted");

    
    let mut forest = ast_map::Forest::new(krate);
    let arenas = ty::CtxtArenas::new();
    let ast_map = driver::assign_node_ids_and_map(&sess, &mut forest);
    let krate = ast_map.krate();


    let lang_items = lang_items::collect_language_items(krate, &sess);
    let resolve::CrateMap { def_map, freevars, .. } =
        resolve::resolve_crate(&sess, &ast_map, &lang_items, krate, resolve::MakeGlobMap::No);
    let named_region_map = resolve_lifetime::krate(&sess, krate, &def_map);
    let region_map = region::resolve_crate(&sess, krate);
    let tcx = ty::mk_ctxt(sess,
                          &arenas,
                          def_map,
                          named_region_map,
                          ast_map,
                          freevars,
                          region_map,
                          lang_items,
                          stability::Index::new(krate));
}