Auto merge of #198 - JohnTitor:update-nightly, r=JohnTitor

Rustup to nightly-2021-06-14

r? `@Xanewok`

Author: bors

README.md

@@ -27,13 +27,13 @@ repository and compiled from source or installed from
 of the nightly toolchain is supported at any given time.
 
 <!-- NOTE: Keep in sync with nightly date on rust-toolchain. -->
-It's recommended to use `nightly-2021-05-21` toolchain.
-You can install it by using `rustup install nightly-2021-05-21` if you already have rustup.
+It's recommended to use `nightly-2021-06-14` toolchain.
+You can install it by using `rustup install nightly-2021-06-14` if you already have rustup.
 Then you can do:
 
 ```sh
-$ rustup component add rustc-dev llvm-tools-preview --toolchain nightly-2021-05-21
-$ cargo +nightly-2021-05-21 install --git https://github.com/rust-lang/rust-semverver
+$ rustup component add rustc-dev llvm-tools-preview --toolchain nightly-2021-06-14
+$ cargo +nightly-2021-06-14 install --git https://github.com/rust-lang/rust-semverver
 ```
 
 You'd also need `cmake` for some dependencies, and a few common libraries (if you hit

rust-toolchain

@@ -1,4 +1,4 @@
 # NOTE: Keep in sync with nightly date on README
 [toolchain]
-channel = "nightly-2021-05-21"
+channel = "nightly-2021-06-14"
 components = ["llvm-tools-preview", "rustc-dev"]

src/bin/cargo-semver.rs

@@ -431,8 +431,8 @@ pub struct WorkInfo<'a> {
 impl<'a> WorkInfo<'a> {
     /// Construct a package/workspace pair for the `manifest_path`
     pub fn local(config: &'a cargo::Config, manifest_path: &Path) -> Result<WorkInfo<'a>> {
-        let workspace = Workspace::new(&manifest_path, config)?;
-        let package = workspace.load(&manifest_path)?;
+        let workspace = Workspace::new(manifest_path, config)?;
+        let package = workspace.load(manifest_path)?;
         Ok(Self { package, workspace })
     }
 
@@ -443,7 +443,7 @@ impl<'a> WorkInfo<'a> {
         &PackageNameAndVersion { name, version }: &PackageNameAndVersion,
     ) -> Result<WorkInfo<'a>> {
         let source = {
-            let source_id = SourceId::crates_io(&config)?;
+            let source_id = SourceId::crates_io(config)?;
             let mut source = RegistrySource::remote(source_id, &HashSet::new(), config);
 
             debug!("source id loaded: {:?}", source_id);

src/changes.rs

@@ -1182,7 +1182,7 @@ impl<'a> Serialize for RPathChanges<'a> {
         let mut seq = serializer.serialize_seq(Some(self.1.len()))?;
 
         for e in &self.1 {
-            seq.serialize_element(&RPathChange(self.0, &e))?;
+            seq.serialize_element(&RPathChange(self.0, e))?;
         }
 
         seq.end()
@@ -1263,14 +1263,14 @@ pub mod tests {
 
     impl Arbitrary for DefId_ {
         fn arbitrary(g: &mut Gen) -> DefId_ {
-            use rustc_hir::def_id::{CrateId, CrateNum, DefIndex};
+            use rustc_hir::def_id::{CrateNum, DefIndex};
 
             // NOTE: These inner types are defined via `rustc_index::newtype_index`
             // macro which leaves trailing 256 values for possible enum-packing
             // so make sure to generate values only from valid value range
             let a: u32 = Arbitrary::arbitrary(g);
-            let a = if a > CrateId::MAX_AS_U32 {
-                CrateId::MAX_AS_U32
+            let a = if a > CrateNum::MAX_AS_U32 {
+                CrateNum::MAX_AS_U32
             } else {
                 a
             };
@@ -1282,7 +1282,7 @@ pub mod tests {
             };
 
             DefId_(DefId {
-                krate: CrateNum::Index(CrateId::from_u32(a)),
+                krate: CrateNum::from_u32(a),
                 index: DefIndex::from(b),
             })
         }

src/mismatch.rs

@@ -118,6 +118,7 @@ impl<'a, 'tcx> TypeRelation<'tcx> for MismatchRelation<'a, 'tcx> {
     fn relate_with_variance<T: Relate<'tcx>>(
         &mut self,
         _: ty::Variance,
+        _: ty::VarianceDiagInfo<'tcx>,
         a: T,
         b: T,
     ) -> RelateResult<'tcx, T> {
@@ -197,7 +198,12 @@ impl<'a, 'tcx> TypeRelation<'tcx> for MismatchRelation<'a, 'tcx> {
                 None
             }
             (&TyKind::RawPtr(a_mt), &TyKind::RawPtr(b_mt)) => {
-                let _ = self.relate(a_mt, b_mt)?;
+                let _ = ty::relate::relate_type_and_mut(
+                    self,
+                    a_mt,
+                    b_mt,
+                    ty::VarianceDiagMutKind::RawPtr,
+                )?;
                 None
             }
             (&TyKind::Ref(a_r, a_ty, _), &TyKind::Ref(b_r, b_ty, _)) => {

src/translate.rs

@@ -311,7 +311,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                                 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() {
+                                match self.tcx.mk_param_from_def(type_param).unpack() {
                                     GenericArgKind::Type(param_t) => param_t,
                                     _ => unreachable!(),
                                 }
@@ -366,7 +366,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
 
     /// Translate an item's type.
     pub fn translate_item_type(&self, orig_def_id: DefId, orig: Ty<'tcx>) -> Ty<'tcx> {
-        self.translate(&self.construct_index_map(orig_def_id), &orig)
+        self.translate(&self.construct_index_map(orig_def_id), orig)
     }
 
     /// Translate a predicate using a type parameter index map.
@@ -420,7 +420,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                                 substs: target_substs,
                                 item_def_id: target_def_id,
                             },
-                            ty: self.translate(index_map, &pred.ty),
+                            ty: self.translate(index_map, pred.ty),
                         }
                     } else {
                         return None;
@@ -434,7 +434,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                 }
                 PredicateKind::ClosureKind(did, substs, kind) => PredicateKind::ClosureKind(
                     self.translate_orig(did),
-                    self.translate(index_map, &substs),
+                    self.translate(index_map, substs),
                     kind,
                 ),
                 PredicateKind::Subtype(pred) => PredicateKind::Subtype({
@@ -459,8 +459,8 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                     }
                 }
                 PredicateKind::ConstEquate(c1, c2) => PredicateKind::ConstEquate(
-                    self.translate(index_map, &c1),
-                    self.translate(index_map, &c2),
+                    self.translate(index_map, c1),
+                    self.translate(index_map, c2),
                 ),
                 // NOTE: Only used for Chalk trait solver
                 PredicateKind::TypeWellFormedFromEnv(_) => unimplemented!(),
@@ -513,7 +513,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
         let index_map = self.construct_index_map(orig_def_id);
         TraitRef {
             def_id: self.translate_orig(orig_trait_ref.def_id),
-            substs: self.translate(&index_map, &orig_trait_ref.substs),
+            substs: self.translate(&index_map, orig_trait_ref.substs),
         }
     }