Implemented a basic vesion of exported type querying.

As requested in rust-lang#63, this adds a way to list all items in the type
namespace of a crate.

Author: ibabushkin

Cargo.toml

@@ -22,6 +22,10 @@ path = "src/bin/cargo_semver.rs"
 name = "rust-semverver"
 path = "src/bin/rust_semverver.rs"
 
+[[bin]]
+name = "rust-semver-public"
+path = "src/bin/rust_semver_public.rs"
+
 [dependencies]
 cargo = "0.36"
 crates-io = "0.24"

src/bin/cargo_semver.rs

@@ -107,6 +107,52 @@ fn run(config: &cargo::Config, matches: &getopts::Matches) -> Result<()> {
     };
     let name = current.package.name().to_owned();
 
+    if matches.opt_present("show-public") {
+        let (current_rlib, current_deps_output) =
+            current.rlib_and_dep_output(config, &name, true, matches)?;
+
+        let mut child = Command::new("rust-semver-public");
+        child
+            .arg("--crate-type=lib")
+            .args(&["--extern", &*format!("new={}", current_rlib.display())])
+            .args(&[format!("-L{}", current_deps_output.display())]);
+
+        if let Some(target) = matches.opt_str("target") {
+            child.args(&["--target", &target]);
+        }
+
+        if !matches.opt_present("no-default-features") {
+            child.args(&["--cfg", "feature=\"default\""]);
+        }
+
+        let mut child = child
+            .arg("-")
+            .stdin(Stdio::piped())
+            .spawn()
+            .map_err(|e| failure::err_msg(format!("could not spawn rustc: {}", e)))?;
+
+        if let Some(ref mut stdin) = child.stdin {
+            stdin.write_fmt(format_args!(
+                "#[allow(unused_extern_crates)] \
+                 extern crate new;"
+            ))?;
+        } else {
+            return Err(failure::err_msg(
+                "could not pipe to rustc (wtf?)".to_owned(),
+            ));
+        }
+
+        let exit_status = child
+            .wait()
+            .map_err(|e| failure::err_msg(format!("failed to wait for rustc: {}", e)))?;
+
+        return if exit_status.success() {
+            Ok(())
+        } else {
+            Err(failure::err_msg("rustc-semver-public errored".to_owned()))
+        };
+    }
+
     // Obtain WorkInfo for the "stable" version
     let (stable, stable_version) = if let Some(name_and_version) = matches.opt_str("S") {
         // -S "name:version" requires fetching the appropriate package:
@@ -227,6 +273,11 @@ mod cli {
             "quiet",
             "surpress regular cargo output, print only important messages",
         );
+        opts.optflag(
+            "",
+            "show-public",
+            "print the public types in the current crate given by -c or -C and exit",
+        );
         opts.optflag("d", "debug", "print command to debug and exit");
         opts.optflag(
             "a",

src/bin/rust_semver_public.rs

@@ -0,0 +1,131 @@
+#![feature(rustc_private)]
+#![feature(result_map_or_else)]
+
+extern crate rustc;
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate syntax;
+
+use log::debug;
+use rustc::{hir::def_id::*, middle::cstore::ExternCrate};
+use rustc_driver::Callbacks;
+use rustc_interface::interface;
+use semverver::run_traversal;
+use std::{
+    path::Path,
+    process::{exit, Command},
+};
+use syntax::source_map::Pos;
+
+/// Display semverver version.
+fn show_version() {
+    println!(env!("CARGO_PKG_VERSION"));
+}
+
+/// Main routine.
+///
+/// Find the sysroot before passing our args to the custom compiler driver we register.
+fn main() {
+    rustc_driver::init_rustc_env_logger();
+
+    debug!("running rust-semver-public compiler driver");
+
+    exit(
+        {
+            use std::env;
+
+            struct PubCallbacks;
+
+            impl Callbacks for PubCallbacks {
+                fn after_analysis(&mut self, compiler: &interface::Compiler) -> bool {
+                    debug!("running rust-semver-public after_analysis callback");
+
+                    compiler.global_ctxt().unwrap().peek_mut().enter(|tcx| {
+                        let krate = tcx
+                            .crates()
+                            .iter()
+                            .flat_map(|crate_num| {
+                                let def_id = DefId {
+                                    krate: *crate_num,
+                                    index: CRATE_DEF_INDEX,
+                                };
+
+                                match tcx.extern_crate(def_id) {
+                                    Some(ExternCrate {
+                                        span, direct: true, ..
+                                    }) if span.data().lo.to_usize() > 0 => Some(def_id),
+                                    _ => None,
+                                }
+                            })
+                            .next();
+
+                        if let Some(krate_def_id) = krate {
+                            debug!("running semver analysis");
+                            run_traversal(tcx, krate_def_id);
+                        } else {
+                            tcx.sess.err("could not find `new` crate");
+                        }
+                    });
+
+                    debug!("rust-semver-public after_analysis callback finished!");
+
+                    false
+                }
+            }
+
+            if env::args().any(|a| a == "--version" || a == "-V") {
+                show_version();
+                exit(0);
+            }
+
+            let sys_root = option_env!("SYSROOT")
+                .map(String::from)
+                .or_else(|| env::var("SYSROOT").ok())
+                .or_else(|| {
+                    let home = option_env!("RUSTUP_HOME").or(option_env!("MULTIRUST_HOME"));
+                    let toolchain = option_env!("RUSTUP_TOOLCHAIN").or(option_env!("MULTIRUST_TOOLCHAIN"));
+                    home.and_then(|home| toolchain.map(|toolchain| format!("{}/toolchains/{}", home, toolchain)))
+                })
+                .or_else(|| {
+                    Command::new("rustc")
+                        .arg("--print")
+                        .arg("sysroot")
+                        .output()
+                        .ok()
+                        .and_then(|out| String::from_utf8(out.stdout).ok())
+                        .map(|s| s.trim().to_owned())
+                })
+                .expect("need to specify SYSROOT env var during clippy compilation, or use rustup or multirust");
+
+            // Setting RUSTC_WRAPPER causes Cargo to pass 'rustc' as the first argument.
+            // We're invoking the compiler programmatically, so we ignore this/
+            let mut orig_args: Vec<String> = env::args().collect();
+            if orig_args.len() <= 1 {
+                std::process::exit(1);
+            }
+
+            if Path::new(&orig_args[1]).file_stem() == Some("rustc".as_ref()) {
+                // we still want to be able to invoke it normally though
+                orig_args.remove(1);
+            }
+
+            // this conditional check for the --sysroot flag is there so users can call
+            // `clippy_driver` directly
+            // without having to pass --sysroot or anything
+            let args: Vec<String> = if orig_args.iter().any(|s| s == "--sysroot") {
+                orig_args.clone()
+            } else {
+                orig_args
+                    .clone()
+                    .into_iter()
+                    .chain(Some("--sysroot".to_owned()))
+                    .chain(Some(sys_root))
+                    .collect()
+            };
+
+            let args = args;
+            rustc_driver::run_compiler(&args, &mut PubCallbacks, None, None)
+        }
+        .map_or_else(|_| 1, |_| 0),
+    )
+}

src/bin/rust_semverver.rs

@@ -1,7 +1,6 @@
 #![feature(rustc_private)]
 #![feature(result_map_or_else)]
 
-extern crate getopts;
 extern crate rustc;
 extern crate rustc_codegen_utils;
 extern crate rustc_driver;
@@ -28,8 +27,7 @@ fn show_version() {
 
 /// Main routine.
 ///
-/// Find the sysroot before passing our args to the compiler driver, after registering our custom
-/// compiler driver.
+/// Find the sysroot before passing our args to the custom compiler driver we register.
 fn main() {
     rustc_driver::init_rustc_env_logger();
 
@@ -45,12 +43,12 @@ fn main() {
                     debug!("running rust-semverver after_analysis callback");
 
                     let verbose =
-                        std::env::var("RUST_SEMVER_VERBOSE") == Ok("true".to_string());
+                        env::var("RUST_SEMVER_VERBOSE") == Ok("true".to_string());
                     let compact =
-                        std::env::var("RUST_SEMVER_COMPACT") == Ok("true".to_string());
+                        env::var("RUST_SEMVER_COMPACT") == Ok("true".to_string());
                     let api_guidelines =
-                        std::env::var("RUST_SEMVER_API_GUIDELINES") == Ok("true".to_string());
-                    let version = if let Ok(ver) = std::env::var("RUST_SEMVER_CRATE_VERSION") {
+                        env::var("RUST_SEMVER_API_GUIDELINES") == Ok("true".to_string());
+                    let version = if let Ok(ver) = env::var("RUST_SEMVER_CRATE_VERSION") {
                         ver
                     } else {
                         "no_version".to_owned()
@@ -88,7 +86,7 @@ fn main() {
                             let changes = run_analysis(tcx, old_def_id, new_def_id);
                             changes.output(tcx.sess, &version, verbose, compact, api_guidelines);
                         } else {
-                            tcx.sess.err("could not find crate old and new crates");
+                            tcx.sess.err("could not find `old` and `new` crates");
                         }
                     });
 
@@ -98,14 +96,14 @@ fn main() {
                 }
             }
 
-            if std::env::args().any(|a| a == "--version" || a == "-V") {
+            if env::args().any(|a| a == "--version" || a == "-V") {
                 show_version();
                 exit(0);
             }
 
             let sys_root = option_env!("SYSROOT")
                 .map(String::from)
-                .or_else(|| std::env::var("SYSROOT").ok())
+                .or_else(|| env::var("SYSROOT").ok())
                 .or_else(|| {
                     let home = option_env!("RUSTUP_HOME").or(option_env!("MULTIRUST_HOME"));
                     let toolchain = option_env!("RUSTUP_TOOLCHAIN").or(option_env!("MULTIRUST_TOOLCHAIN"));

src/lib.rs

@@ -14,4 +14,4 @@ mod translate;
 mod traverse;
 mod typeck;
 
-pub use self::traverse::run_analysis;
+pub use self::traverse::{run_analysis, run_traversal};

src/traverse.rs

@@ -69,6 +69,47 @@ pub fn run_analysis<'a, 'tcx>(
     changes
 }
 
+// Get the visibility of the inner item, given the outer item's visibility.
+fn get_vis(outer_vis: Visibility, def: Export<HirId>) -> Visibility {
+    if outer_vis == Public {
+        def.vis
+    } else {
+        outer_vis
+    }
+}
+
+pub fn run_traversal<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, new: DefId) {
+    use rustc::hir::def::DefKind::*;
+    let mut visited = HashSet::new();
+    let mut mod_queue = VecDeque::new();
+
+    // Start off with the root module.
+    mod_queue.push_back((new, Public));
+
+    // Pull a module from the queue, with its global visibility.
+    while let Some((new_def_id, new_vis)) = mod_queue.pop_front() {
+        for item in tcx.item_children(new_def_id).to_vec() {
+            let n_vis = get_vis(new_vis, item);
+            match item.res {
+                Def(Mod, n_def_id) => {
+                    if visited.insert(n_def_id) {
+                        mod_queue.push_back((n_def_id, n_vis));
+                    }
+                },
+                Def(n_kind, n_def_id) if n_vis == Public => {
+                    match n_kind {
+                        TyAlias | Struct | Union | Enum | Trait => { 
+                            println!("{:?}", n_def_id);
+                        },
+                        _ => (),
+                    };
+                },
+                _ => (),
+            }
+        }
+    }
+}
+
 // Below functions constitute the first pass of analysis, in which module structure, ADT
 // structure, public and private status of items, and generics are examined for changes.
 
@@ -87,15 +128,6 @@ fn diff_structure<'a, 'tcx>(
 ) {
     use rustc::hir::def::DefKind::*;
 
-    // Get the visibility of the inner item, given the outer item's visibility.
-    fn get_vis(outer_vis: Visibility, def: Export<HirId>) -> Visibility {
-        if outer_vis == Public {
-            def.vis
-        } else {
-            outer_vis
-        }
-    }
-
     let mut visited = HashSet::new();
     let mut children = NameMapping::default();
     let mut mod_queue = VecDeque::new();