Fix compilation for the latest nightly.

Author: orium

Cargo.toml

@@ -27,17 +27,17 @@ name = "rust-semver-public"
 path = "src/bin/rust_semver_public.rs"
 
 [dependencies]
-cargo = "0.37"
-crates-io = "0.24"
+cargo = "0.39"
+crates-io = "0.27"
 curl = "0.4.21"
-env_logger = "0.6"
+env_logger = "0.7"
 failure = "0.1"
 log = "0.4"
-rand = "0.6"
+rand = "0.7"
 semver = "0.9"
 serde = "1.0.84"
 serde_derive = "1.0.84"
 serde_json = "1.0.34"
 
 [dev-dependencies]
-quickcheck = "0.7"
+quickcheck = "0.9"

src/bin/rust_semver_public.rs

@@ -7,7 +7,6 @@ extern crate rustc_interface;
 extern crate syntax;
 
 use log::debug;
-use rustc::middle::cstore::ExternCrate;
 use rustc_driver::{Callbacks, Compilation};
 use rustc_interface::interface;
 use semverver::run_traversal;
@@ -48,9 +47,7 @@ fn main() {
                                 let def_id = crate_num.as_def_id();
 
                                 match tcx.extern_crate(def_id) {
-                                    Some(ExternCrate {
-                                        span, direct: true, ..
-                                    }) if span.data().lo.to_usize() > 0 => Some(def_id),
+                                    Some(extern_crate) if extern_crate.is_direct() && extern_crate.span.data().lo.to_usize() > 0 => Some(def_id),
                                     _ => None,
                                 }
                             })

src/bin/rust_semverver.rs

@@ -10,7 +10,6 @@ extern crate rustc_metadata;
 extern crate syntax;
 
 use log::debug;
-use rustc::middle::cstore::ExternCrate;
 use rustc_driver::{Callbacks, Compilation};
 use rustc_interface::interface;
 use semverver::run_analysis;
@@ -69,10 +68,8 @@ fn main() {
                                 let def_id = crate_num.as_def_id();
 
                                 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)),
+                                    Some(extern_crate) if extern_crate.is_direct() && extern_crate.span.data().lo.to_usize() > 0 =>
+                                        Some((extern_crate.span.data().lo.to_usize(), def_id)),
                                     _ => None,
                                 }
                             })

src/mismatch.rs

@@ -87,7 +87,7 @@ impl<'a, 'tcx> MismatchRelation<'a, 'tcx> {
 
     /// Ensure that the pair of given `SubstsRef`s is suitable to be related.
     fn check_substs(&self, a_substs: SubstsRef<'tcx>, b_substs: SubstsRef<'tcx>) -> bool {
-        use rustc::ty::subst::UnpackedKind::*;
+        use rustc::ty::subst::GenericArgKind::*;
 
         for (a, b) in a_substs.iter().zip(b_substs) {
             match (a.unpack(), b.unpack()) {
@@ -142,7 +142,7 @@ impl<'a, 'tcx> TypeRelation<'tcx> for MismatchRelation<'a, 'tcx> {
         self.current_new_types.insert(b);
 
         debug!("tys: mismatch relation: a: {:?}, b: {:?}", a, b);
-        let matching = match (&a.sty, &b.sty) {
+        let matching = match (&a.kind, &b.kind) {
             (&TyKind::Adt(a_def, a_substs), &TyKind::Adt(b_def, b_substs)) => {
                 if self.check_substs(a_substs, b_substs) {
                     let _ = self.relate_item_substs(a_def.did, a_substs, b_substs)?;

src/translate.rs

@@ -8,7 +8,7 @@ use rustc::{
     infer::InferCtxt,
     ty::{
         fold::{BottomUpFolder, TypeFoldable, TypeFolder},
-        subst::{InternalSubsts, Kind, SubstsRef},
+        subst::{InternalSubsts, GenericArg, SubstsRef},
         GenericParamDefKind, ParamEnv, Predicate, Region, TraitRef, Ty, TyCtxt,
     },
 };
@@ -103,7 +103,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
         orig_def_id: DefId,
         orig_substs: SubstsRef<'tcx>,
     ) -> Option<(DefId, SubstsRef<'tcx>)> {
-        use rustc::ty::subst::UnpackedKind;
+        use rustc::ty::subst::GenericArgKind;
         use rustc::ty::ReEarlyBound;
         use std::cell::Cell;
 
@@ -119,10 +119,10 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
 
             let target_substs =
                 InternalSubsts::for_item(self.tcx, target_def_id, |def, _| match def.kind {
-                    GenericParamDefKind::Lifetime => Kind::from(if !success.get() {
+                    GenericParamDefKind::Lifetime => GenericArg::from(if !success.get() {
                         self.tcx
                             .mk_region(ReEarlyBound(def.to_early_bound_region_data()))
-                    } else if let Some(UnpackedKind::Lifetime(region)) =
+                    } else if let Some(GenericArgKind::Lifetime(region)) =
                         orig_substs.get(def.index as usize).map(|k| k.unpack())
                     {
                         self.translate_region(region)
@@ -134,15 +134,15 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                     GenericParamDefKind::Type { .. } => {
                         if !success.get() {
                             self.tcx.mk_param_from_def(def)
-                        } else if let Some(UnpackedKind::Type(type_)) =
+                        } else if let Some(GenericArgKind::Type(type_)) =
                             orig_substs.get(def.index as usize).map(|k| k.unpack())
                         {
-                            self.translate(index_map, &Kind::from(type_))
+                            self.translate(index_map, &GenericArg::from(type_))
                         } else if self
                             .id_mapping
                             .is_non_mapped_defaulted_type_param(def.def_id)
                         {
-                            Kind::from(self.tcx.type_of(def.def_id))
+                            GenericArg::from(self.tcx.type_of(def.def_id))
                         } else if self.tcx.generics_of(target_def_id).has_self && def.index == 0 {
                             self.tcx.mk_param_from_def(def)
                         } else {
@@ -171,7 +171,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
         orig.fold_with(&mut BottomUpFolder {
             tcx: self.tcx,
             ty_op: |ty| {
-                match ty.sty {
+                match ty.kind {
                     TyKind::Adt(&AdtDef { ref did, .. }, substs)
                         if self.needs_translation(*did) =>
                     {
@@ -293,14 +293,14 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                             // `Self` is special
                             let orig_def_id = index_map[&param.index];
                             if self.needs_translation(orig_def_id) {
-                                use rustc::ty::subst::UnpackedKind;
+                                use rustc::ty::subst::GenericArgKind;
 
                                 let target_def_id = self.translate_orig(orig_def_id);
                                 debug!("translating type param: {:?}", param);
                                 let type_param = self.id_mapping.get_type_param(&target_def_id);
                                 debug!("translated type param: {:?}", type_param);
                                 match self.tcx.mk_param_from_def(&type_param).unpack() {
-                                    UnpackedKind::Type(param_t) => param_t,
+                                    GenericArgKind::Type(param_t) => param_t,
                                     _ => unreachable!(),
                                 }
                             } else {
@@ -542,7 +542,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for InferenceCleanupFolder<'a, 'tcx> {
         use rustc::ty::TypeAndMut;
 
         let t1 = ty.super_fold_with(self);
-        match t1.sty {
+        match t1.kind {
             TyKind::Ref(region, ty, mutbl) if region.needs_infer() => {
                 let ty_and_mut = TypeAndMut { ty, mutbl };
                 self.infcx

src/traverse.rs

@@ -560,7 +560,7 @@ fn diff_traits<'tcx>(
     output: bool,
 ) {
     use rustc::hir::Unsafety::Unsafe;
-    use rustc::ty::subst::UnpackedKind::Type;
+    use rustc::ty::subst::GenericArgKind::Type;
     use rustc::ty::{ParamTy, Predicate, TyS};
 
     debug!(
@@ -590,7 +590,7 @@ fn diff_traits<'tcx>(
 
             if id_mapping.is_private_trait(trait_ref.def_id) && trait_ref.substs.len() == 1 {
                 if let Type(&TyS {
-                    sty: TyKind::Param(ParamTy { index: 0, .. }),
+                    kind: TyKind::Param(ParamTy { index: 0, .. }),
                     ..
                 }) = trait_ref.substs[0].unpack()
                 {
@@ -1087,7 +1087,7 @@ fn diff_inherent_impls<'tcx>(
 #[allow(clippy::match_same_arms)]
 fn is_impl_trait_public<'tcx>(tcx: TyCtxt<'tcx>, impl_def_id: DefId) -> bool {
     fn type_visibility(tcx: TyCtxt, ty: Ty) -> Visibility {
-        match ty.sty {
+        match ty.kind {
             TyKind::Adt(def, _) => tcx.visibility(def.did),
 
             TyKind::Array(t, _)

src/typeck.rs

@@ -16,7 +16,7 @@ use rustc::{
     ty::{
         error::TypeError,
         fold::TypeFoldable,
-        subst::{InternalSubsts, Kind, SubstsRef},
+        subst::{InternalSubsts, GenericArg, SubstsRef},
         GenericParamDefKind, ParamEnv, Predicate, TraitRef, Ty, TyCtxt,
     },
 };
@@ -181,7 +181,7 @@ impl<'a, 'tcx> TypeComparisonContext<'a, 'tcx> {
         use rustc::ty::ReEarlyBound;
 
         InternalSubsts::for_item(self.infcx.tcx, target_def_id, |def, _| match def.kind {
-            GenericParamDefKind::Lifetime => Kind::from(
+            GenericParamDefKind::Lifetime => GenericArg::from(
                 self.infcx
                     .tcx
                     .mk_region(ReEarlyBound(def.to_early_bound_region_data())),
@@ -191,7 +191,7 @@ impl<'a, 'tcx> TypeComparisonContext<'a, 'tcx> {
                     .id_mapping
                     .is_non_mapped_defaulted_type_param(def.def_id)
                 {
-                    Kind::from(self.infcx.tcx.type_of(def.def_id))
+                    GenericArg::from(self.infcx.tcx.type_of(def.def_id))
                 } else {
                     self.infcx.tcx.mk_param_from_def(def)
                 }

tests/full.rs

@@ -10,16 +10,6 @@ mod full {
     };
 
     fn test_full(crate_name: &str, old_version: &str, new_version: &str, expected_result: bool) {
-        // Full test are not working on windows.  See issue #105.
-        /* if std::env::var_os("CI").is_some() && cfg!(all(target_os = "windows", target_env = "msvc"))
-        {
-            eprintln!(
-                "Skipping full test of crate {} ({} -> {}) on windows. See issue #105.",
-                crate_name, old_version, new_version
-            );
-            return;
-        } */
-
         // Add target dir to PATH so cargo-semver will call the right rust-semverver
         if let Some(path) = env::var_os("PATH") {
             let mut paths = env::split_paths(&path).collect::<Vec<_>>();