Switched to the new rustc driver introduced in nightly.

ibabushkin · ibabushkin · commit 97534c5d9a6a · 2019-03-17T18:56:18.000+01:00
diff --git a/src/bin/rust_semverver.rs b/src/bin/rust_semverver.rs
@@ -1,18 +1,20 @@
 #![feature(rustc_private)]
+#![feature(result_map_or_else)]
 
 extern crate getopts;
 extern crate rustc;
 extern crate rustc_codegen_utils;
 extern crate rustc_driver;
 extern crate rustc_errors;
+extern crate rustc_interface;
 extern crate rustc_metadata;
 extern crate syntax;
 
 use log::debug;
 use rustc::{hir::def_id::*, middle::cstore::ExternCrate};
-use rustc_driver::{driver::CompileController, Compilation};
+use rustc_driver::Callbacks;
+use rustc_interface::interface;
 use semverver::run_analysis;
-use std::convert::TryInto;
 use std::{
     path::Path,
     process::{exit, Command},
@@ -33,7 +35,7 @@ fn main() {
 
     debug!("running rust-semverver compiler driver");
     exit(
-        rustc_driver::run(move || {
+        {
             use std::env;
 
             if std::env::args().any(|a| a == "--version" || a == "-V") {
@@ -86,59 +88,67 @@ fn main() {
                     .collect()
             };
 
-            let verbose = std::env::var("RUST_SEMVER_VERBOSE") == 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") {
-                ver
-            } else {
-                "no_version".to_owned()
-            };
-
-            let mut controller = CompileController::basic();
-
-            controller.after_analysis.callback = Box::new(move |state| {
-                debug!("running rust-semverver after_analysis...");
-                let tcx = state.tcx.unwrap();
-
-                // To select the old and new crates we look at the position of the declaration in the
-                // source file.  The first one will be the `old` and the other will be `new`.  This is
-                // unfortunately a bit hacky... See issue #64 for details.
-
-                let mut crates: Vec<_> = 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((span.data().lo.to_usize(), def_id)),
-                            _ => None,
+            struct SemverCallbacks;
+
+            impl Callbacks for SemverCallbacks {
+                fn after_analysis(&mut self, compiler: &interface::Compiler) -> bool {
+                    debug!("running rust-semverver after_analysis callback");
+
+                    let verbose =
+                        std::env::var("RUST_SEMVER_VERBOSE") == 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") {
+                        ver
+                    } else {
+                        "no_version".to_owned()
+                    };
+
+                    compiler.global_ctxt().unwrap().peek_mut().enter(|tcx| {
+                        // To select the old and new crates we look at the position of the
+                        // declaration in the source file. The first one will be the `old`
+                        // and the other will be `new`. This is unfortunately a bit hacky...
+                        // See issue #64 for details.
+
+                        let mut crates: Vec<_> = 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((span.data().lo.to_usize(), def_id)),
+                                    _ => None,
+                                }
+                            })
+                            .collect();
+
+                        crates.sort_by_key(|&(span_lo, _)| span_lo);
+
+                        if let [(_, old_def_id), (_, new_def_id)] = *crates.as_slice() {
+                            debug!("running semver analysis");
+                            let changes = run_analysis(tcx, old_def_id, new_def_id);
+                            changes.output(tcx.sess, &version, verbose, api_guidelines);
+                        } else {
+                            tcx.sess.err("could not find crate old and new crates");
                         }
-                    })
-                    .collect();
+                    });
 
-                crates.sort_by_key(|&(span_lo, _)| span_lo);
+                    debug!("rust-semverver after_analysis callback finished!");
 
-                if let [(_, old_def_id), (_, new_def_id)] = *crates.as_slice() {
-                    debug!("running semver analysis");
-                    let changes = run_analysis(tcx, old_def_id, new_def_id);
-                    changes.output(tcx.sess, &version, verbose, api_guidelines);
-                } else {
-                    tcx.sess.err("could not find crate old and new crates");
+                    false
                 }
-
-                debug!("running rust-semverver after_analysis finished!");
-            });
-            controller.after_analysis.stop = Compilation::Stop;
+            }
 
             let args = args;
-            rustc_driver::run_compiler(&args, Box::new(controller), None, None)
-        }).try_into()
-            .expect("exit code too large"),
+            rustc_driver::run_compiler(&args, &mut SemverCallbacks, None, None)
+        }
+        .map_or_else(|_| 1, |_| 0),
     )
 }
diff --git a/src/mapping.rs b/src/mapping.rs
@@ -143,6 +143,7 @@ impl IdMapping {
         match param.kind {
             GenericParamDefKind::Lifetime => unreachable!(),
             GenericParamDefKind::Type { .. } => (),
+            GenericParamDefKind::Const => unreachable!(),
         };
 
         self.type_params.insert(param.def_id, param.clone());
diff --git a/src/translate.rs b/src/translate.rs
@@ -149,7 +149,8 @@ impl<'a, 'gcx, 'tcx> TranslationContext<'a, 'gcx, 'tcx> {
                             success.set(false);
                             self.tcx.mk_param_from_def(def)
                         }
-                    }
+                    },
+                    GenericParamDefKind::Const => unreachable!(),
                 });
 
             if success.get() {
diff --git a/src/traverse.rs b/src/traverse.rs
@@ -24,8 +24,8 @@ use rustc::{
     },
     ty::{
         subst::{InternalSubsts, Subst},
-        AssociatedItem, GenericParamDef, GenericParamDefKind, Generics, Ty, TyCtxt, Visibility,
-        Visibility::Public,
+        AssociatedItem, DefIdTree, GenericParamDef, GenericParamDefKind, Generics, Ty, TyCtxt,
+        Visibility, Visibility::Public,
     },
 };
 use std::collections::{BTreeMap, HashSet, VecDeque};
@@ -1036,7 +1036,7 @@ fn diff_trait_impls<'a, 'tcx>(
         let old_trait_def_id = tcx.impl_trait_ref(*old_impl_def_id).unwrap().def_id;
 
         let old_impl_parent_def = tcx
-            .parent_def_id(*old_impl_def_id)
+            .parent(*old_impl_def_id)
             .and_then(|did| tcx.describe_def(did));
         let old_impl_parent_is_fn = match old_impl_parent_def {
             Some(Def::Fn(_)) | Some(Def::Method(_)) => true,
@@ -1050,7 +1050,7 @@ fn diff_trait_impls<'a, 'tcx>(
         if !match_trait_impl(tcx, &to_new, *old_impl_def_id) {
             changes.new_change_impl(
                 *old_impl_def_id,
-                tcx.item_path_str(*old_impl_def_id),
+                tcx.def_path_str(*old_impl_def_id),
                 tcx.def_span(*old_impl_def_id),
             );
             changes.add_change(ChangeType::TraitImplTightened, *old_impl_def_id, None);
@@ -1064,7 +1064,7 @@ fn diff_trait_impls<'a, 'tcx>(
         let new_trait_def_id = tcx.impl_trait_ref(*new_impl_def_id).unwrap().def_id;
 
         let new_impl_parent_def = tcx
-            .parent_def_id(*new_impl_def_id)
+            .parent(*new_impl_def_id)
             .and_then(|did| tcx.describe_def(did));
         let new_impl_parent_is_fn = match new_impl_parent_def {
             Some(Def::Fn(_)) | Some(Def::Method(_)) => true,
@@ -1078,7 +1078,7 @@ fn diff_trait_impls<'a, 'tcx>(
         if !match_trait_impl(tcx, &to_old, *new_impl_def_id) {
             changes.new_change_impl(
                 *new_impl_def_id,
-                tcx.item_path_str(*new_impl_def_id),
+                tcx.def_path_str(*new_impl_def_id),
                 tcx.def_span(*new_impl_def_id),
             );
             changes.add_change(ChangeType::TraitImplLoosened, *new_impl_def_id, None);
diff --git a/src/typeck.rs b/src/typeck.rs
@@ -195,7 +195,8 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
                 } else {
                     self.infcx.tcx.mk_param_from_def(def)
                 }
-            }
+            },
+            GenericParamDefKind::Const => unreachable!(),
         })
     }
 

Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,8 @@ impl<'a, 'gcx, 'tcx> TranslationContext<'a, 'gcx, 'tcx> {`
`149`	`149`	`success.set(false);`
`150`	`150`	`self.tcx.mk_param_from_def(def)`
`151`	`151`	`}`
`152`		`- }`
	`152`	`+ },`
	`153`	`+ GenericParamDefKind::Const => unreachable!(),`
`153`	`154`	`});`
`154`	`155`
`155`	`156`	`if success.get() {`
Original file line number	Diff line number	Diff line change
`@@ -195,7 +195,8 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {`
`195`	`195`	`} else {`
`196`	`196`	`self.infcx.tcx.mk_param_from_def(def)`
`197`	`197`	`}`
`198`		`- }`
	`198`	`+ },`
	`199`	`+ GenericParamDefKind::Const => unreachable!(),`
`199`	`200`	`})`
`200`	`201`	`}`
`201`	`202`