who told you this was unsound!

lcnr · lcnr · commit ae7828a15e1b · 2020-06-26T14:12:27.000+02:00
diff --git a/src/librustc_codegen_ssa/back/symbol_export.rs b/src/librustc_codegen_ssa/back/symbol_export.rs
@@ -249,9 +249,9 @@ fn exported_symbols_provider_local(
             }
 
             match *mono_item {
-                MonoItem::Fn(Instance { def: InstanceDef::Item(def_id, _), substs }) => {
+                MonoItem::Fn(Instance { def: InstanceDef::Item(def), substs }) => {
                     if substs.non_erasable_generics().next().is_some() {
-                        let symbol = ExportedSymbol::Generic(def_id, substs);
+                        let symbol = ExportedSymbol::Generic(def.did, substs);
                         symbols.push((symbol, SymbolExportLevel::Rust));
                     }
                 }
diff --git a/src/librustc_middle/mir/mono.rs b/src/librustc_middle/mir/mono.rs
@@ -346,8 +346,8 @@ impl<'tcx> CodegenUnit<'tcx> {
                             // instances into account. The others don't matter for
                             // the codegen tests and can even make item order
                             // unstable.
-                            InstanceDef::Item(def_id, _) => {
-                                def_id.as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id))
+                            InstanceDef::Item(def) => {
+                                def.did.as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id))
                             }
                             InstanceDef::VtableShim(..)
                             | InstanceDef::ReifyShim(..)
diff --git a/src/librustc_middle/ty/instance.rs b/src/librustc_middle/ty/instance.rs
@@ -160,8 +160,8 @@ impl<'tcx> Instance<'tcx> {
         self.substs.non_erasable_generics().next()?;
 
         match self.def {
-            InstanceDef::Item(def_id, _) => tcx
-                .upstream_monomorphizations_for(def_id)
+            InstanceDef::Item(def) => tcx
+                .upstream_monomorphizations_for(def.did)
                 .and_then(|monos| monos.get(&self.substs).cloned()),
             InstanceDef::DropGlue(_, Some(_)) => tcx.upstream_drop_glue_for(self.substs),
             _ => None,
@@ -173,8 +173,8 @@ impl<'tcx> InstanceDef<'tcx> {
     #[inline]
     pub fn def_id(&self) -> DefId {
         match *self {
-            InstanceDef::Item(def_id, _)
-            | InstanceDef::VtableShim(def_id)
+            InstanceDef::Item(def) => def.did,
+            InstanceDef::VtableShim(def_id)
             | InstanceDef::ReifyShim(def_id)
             | InstanceDef::FnPtrShim(def_id, _)
             | InstanceDef::Virtual(def_id, _)
@@ -186,12 +186,8 @@ impl<'tcx> InstanceDef<'tcx> {
     }
 
     #[inline]
-    pub fn with_opt_param(&self, tcx: TyCtxt<'tcx>) -> ty::WithOptParam<DefId> {
-        ty::WithOptParam {
-            did: self.def_id(),
-            param_did: if let InstanceDef::Item(_, param_did) = *self { param_did } else { None }
-                .or_else(|| tcx.const_param_of(self.def_id())),
-        }
+    pub fn with_opt_param(self) -> ty::WithOptParam<DefId> {
+        if let InstanceDef::Item(def) = self { def } else { ty::WithOptParam::dummy(self.def_id()) }
     }
 
     #[inline]
@@ -207,7 +203,7 @@ impl<'tcx> InstanceDef<'tcx> {
     pub fn requires_inline(&self, tcx: TyCtxt<'tcx>) -> bool {
         use rustc_hir::definitions::DefPathData;
         let def_id = match *self {
-            ty::InstanceDef::Item(def_id, _) => def_id,
+            ty::InstanceDef::Item(def) => def.did,
             ty::InstanceDef::DropGlue(_, Some(_)) => return false,
             _ => return true,
         };
@@ -253,8 +249,8 @@ impl<'tcx> InstanceDef<'tcx> {
 
     pub fn requires_caller_location(&self, tcx: TyCtxt<'_>) -> bool {
         match *self {
-            InstanceDef::Item(def_id, _) => {
-                tcx.codegen_fn_attrs(def_id).flags.contains(CodegenFnAttrFlags::TRACK_CALLER)
+            InstanceDef::Item(def) => {
+                tcx.codegen_fn_attrs(def.did).flags.contains(CodegenFnAttrFlags::TRACK_CALLER)
             }
             _ => false,
         }
@@ -271,7 +267,7 @@ impl<'tcx> fmt::Display for Instance<'tcx> {
         })?;
 
         match self.def {
-            InstanceDef::Item(_, _) => Ok(()),
+            InstanceDef::Item(_) => Ok(()),
             InstanceDef::VtableShim(_) => write!(f, " - shim(vtable)"),
             InstanceDef::ReifyShim(_) => write!(f, " - shim(reify)"),
             InstanceDef::Intrinsic(_) => write!(f, " - intrinsic"),
@@ -292,7 +288,7 @@ impl<'tcx> Instance<'tcx> {
             did,
             substs
         );
-        Instance { def: InstanceDef::Item(did, None), substs }
+        Instance { def: InstanceDef::Item(ty::WithOptParam::dummy(did)), substs }
     }
 
     pub fn mono(tcx: TyCtxt<'tcx>, def_id: DefId) -> Instance<'tcx> {
@@ -304,11 +300,6 @@ impl<'tcx> Instance<'tcx> {
         self.def.def_id()
     }
 
-    #[inline]
-    pub fn with_opt_param(&self, tcx: TyCtxt<'tcx>) -> ty::WithOptParam<DefId> {
-        self.def.with_opt_param(tcx)
-    }
-
     /// Identical to `resolve`, but may also take an optional `param_def_id` for
     /// generic const arguments.
     pub fn resolve_const_arg(
@@ -378,9 +369,9 @@ impl<'tcx> Instance<'tcx> {
         debug!("resolve(def_id={:?}, substs={:?})", def_id, substs);
         Instance::resolve(tcx, param_env, def_id, substs).ok().flatten().map(|mut resolved| {
             match resolved.def {
-                InstanceDef::Item(def_id, _) if resolved.def.requires_caller_location(tcx) => {
+                InstanceDef::Item(def) if resolved.def.requires_caller_location(tcx) => {
                     debug!(" => fn pointer created for function with #[track_caller]");
-                    resolved.def = InstanceDef::ReifyShim(def_id);
+                    resolved.def = InstanceDef::ReifyShim(def.did);
                 }
                 InstanceDef::Virtual(def_id, _) => {
                     debug!(" => fn pointer created for virtual call");
@@ -476,7 +467,7 @@ impl<'tcx> Instance<'tcx> {
             | InstanceDef::DropGlue(..)
             // FIXME(#69925): `FnPtrShim` should be in the other branch.
             | InstanceDef::FnPtrShim(..)
-            | InstanceDef::Item(_, _)
+            | InstanceDef::Item(_)
             | InstanceDef::Intrinsic(..)
             | InstanceDef::ReifyShim(..)
             | InstanceDef::Virtual(..)
diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs
@@ -1583,17 +1583,25 @@ pub struct WithOptParam<T> {
     pub did: T,
     /// The `DefId` of the corresponding generic paramter in case `did` is
     /// a const argument.
+    ///
+    /// If `param_did` is `Some` it must be equal to `tcx.const_param_of`,
+    /// and may otherwise cause panics or problems.
     pub param_did: Option<DefId>,
 }
 
 impl<'tcx> TyCtxt<'tcx> {
     #[inline(always)]
     pub fn with_opt_param<T: IntoQueryParam<DefId> + Copy>(self, did: T) -> WithOptParam<T> {
-        WithOptParam { did, param_did: self.const_param_of(did) }
+        WithOptParam { did, param_did: None }
     }
 }
 
 impl<T: IntoQueryParam<DefId>> WithOptParam<T> {
+    /// Wraps the given `DefId` and sets `param_did` to none.
+    pub fn dummy(did: T) -> WithOptParam<T> {
+        WithOptParam { did, param_did: None }
+    }
+
     pub fn ty_def_id(self) -> DefId {
         self.param_did.unwrap_or(self.did.into_query_param())
     }
@@ -2790,7 +2798,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Returns the possibly-auto-generated MIR of a `(DefId, Subst)` pair.
     pub fn instance_mir(self, instance: ty::InstanceDef<'tcx>) -> &'tcx Body<'tcx> {
         match instance {
-            ty::InstanceDef::Item(_, _) => self.optimized_mir(instance.with_opt_param(self)),
+            ty::InstanceDef::Item(def) => self.optimized_mir(def),
             ty::InstanceDef::VtableShim(..)
             | ty::InstanceDef::ReifyShim(..)
             | ty::InstanceDef::Intrinsic(..)
diff --git a/src/librustc_middle/ty/structural_impls.rs b/src/librustc_middle/ty/structural_impls.rs
@@ -672,7 +672,7 @@ impl<'a, 'tcx> Lift<'tcx> for ty::InstanceDef<'a> {
     type Lifted = ty::InstanceDef<'tcx>;
     fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
         match *self {
-            ty::InstanceDef::Item(did, param_did) => Some(ty::InstanceDef::Item(did, param_did)),
+            ty::InstanceDef::Item(did) => Some(ty::InstanceDef::Item(did)),
             ty::InstanceDef::VtableShim(def_id) => Some(ty::InstanceDef::VtableShim(def_id)),
             ty::InstanceDef::ReifyShim(def_id) => Some(ty::InstanceDef::ReifyShim(def_id)),
             ty::InstanceDef::Intrinsic(def_id) => Some(ty::InstanceDef::Intrinsic(def_id)),
@@ -844,7 +844,7 @@ impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> {
         Self {
             substs: self.substs.fold_with(folder),
             def: match self.def {
-                Item(did, param_did) => Item(did.fold_with(folder), param_did.fold_with(folder)),
+                Item(def) => Item(def.fold_with(folder)),
                 VtableShim(did) => VtableShim(did.fold_with(folder)),
                 ReifyShim(did) => ReifyShim(did.fold_with(folder)),
                 Intrinsic(did) => Intrinsic(did.fold_with(folder)),
@@ -863,11 +863,10 @@ impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> {
         use crate::ty::InstanceDef::*;
         self.substs.visit_with(visitor)
             || match self.def {
-                Item(did, _)
-                | VtableShim(did)
-                | ReifyShim(did)
-                | Intrinsic(did)
-                | Virtual(did, _) => did.visit_with(visitor),
+                Item(def) => def.visit_with(visitor),
+                VtableShim(did) | ReifyShim(did) | Intrinsic(did) | Virtual(did, _) => {
+                    did.visit_with(visitor)
+                }
                 FnPtrShim(did, ty) | CloneShim(did, ty) => {
                     did.visit_with(visitor) || ty.visit_with(visitor)
                 }
diff --git a/src/librustc_mir/const_eval/eval_queries.rs b/src/librustc_mir/const_eval/eval_queries.rs
@@ -288,7 +288,7 @@ pub fn const_eval_raw_provider<'tcx>(
     }
 
     let cid = key.value;
-    let def = cid.instance.with_opt_param(tcx);
+    let def = cid.instance.def.with_opt_param();
 
     if let Some(def) = def.as_local() {
         if tcx.has_typeck_tables(def.did) {
diff --git a/src/librustc_mir/const_eval/machine.rs b/src/librustc_mir/const_eval/machine.rs
@@ -191,11 +191,11 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
         debug!("find_mir_or_eval_fn: {:?}", instance);
 
         // Only check non-glue functions
-        if let ty::InstanceDef::Item(def_id, _) = instance.def {
+        if let ty::InstanceDef::Item(def) = instance.def {
             // Execution might have wandered off into other crates, so we cannot do a stability-
             // sensitive check here.  But we can at least rule out functions that are not const
             // at all.
-            if ecx.tcx.is_const_fn_raw(def_id) {
+            if ecx.tcx.is_const_fn_raw(def.did) {
                 // If this function is a `const fn` then under certain circumstances we
                 // can evaluate call via the query system, thus memoizing all future calls.
                 if ecx.try_eval_const_fn_call(instance, ret, args)? {
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
@@ -400,7 +400,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         promoted: Option<mir::Promoted>,
     ) -> InterpResult<'tcx, &'tcx mir::Body<'tcx>> {
         // do not continue if typeck errors occurred (can only occur in local crate)
-        let def = instance.with_opt_param(*self.tcx);
+        let def = instance.with_opt_param();
         if let Some(def) = def.as_local() {
             if self.tcx.has_typeck_tables(def.did) {
                 if let Some(error_reported) = self.tcx.typeck_tables_of(def).tainted_by_errors {
@@ -413,7 +413,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             return Ok(&self.tcx.promoted_mir(def)[promoted]);
         }
         match instance {
-            ty::InstanceDef::Item(_, _) => {
+            ty::InstanceDef::Item(_) => {
                 if self.tcx.is_mir_available(def.did) {
                     Ok(self.tcx.optimized_mir(def))
                 } else {
diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs
@@ -257,7 +257,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             | ty::InstanceDef::FnPtrShim(..)
             | ty::InstanceDef::DropGlue(..)
             | ty::InstanceDef::CloneShim(..)
-            | ty::InstanceDef::Item(_, _) => {
+            | ty::InstanceDef::Item(_) => {
                 // We need MIR for this fn
                 let body = match M::find_mir_or_eval_fn(self, instance, args, ret, unwind)? {
                     Some(body) => body,
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
@@ -768,7 +768,8 @@ fn visit_instance_use<'tcx>(
 // need a mono item.
 fn should_monomorphize_locally<'tcx>(tcx: TyCtxt<'tcx>, instance: &Instance<'tcx>) -> bool {
     let def_id = match instance.def {
-        ty::InstanceDef::Item(def_id, _) | ty::InstanceDef::DropGlue(def_id, Some(_)) => def_id,
+        ty::InstanceDef::Item(def) => def.did,
+        ty::InstanceDef::DropGlue(def_id, Some(_)) => def_id,
 
         ty::InstanceDef::VtableShim(..)
         | ty::InstanceDef::ReifyShim(..)
diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs
@@ -314,7 +314,8 @@ fn mono_item_visibility(
     };
 
     let def_id = match instance.def {
-        InstanceDef::Item(def_id, _) | InstanceDef::DropGlue(def_id, Some(_)) => def_id,
+        InstanceDef::Item(def) => def.did,
+        InstanceDef::DropGlue(def_id, Some(_)) => def_id,
 
         // These are all compiler glue and such, never exported, always hidden.
         InstanceDef::VtableShim(..)
@@ -704,7 +705,7 @@ fn characteristic_def_id_of_mono_item<'tcx>(
     match mono_item {
         MonoItem::Fn(instance) => {
             let def_id = match instance.def {
-                ty::InstanceDef::Item(def_id, _) => def_id,
+                ty::InstanceDef::Item(def) => def.did,
                 ty::InstanceDef::VtableShim(..)
                 | ty::InstanceDef::ReifyShim(..)
                 | ty::InstanceDef::FnPtrShim(..)
diff --git a/src/librustc_mir/transform/check_consts/validation.rs b/src/librustc_mir/transform/check_consts/validation.rs
@@ -537,8 +537,8 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
                     let instance = Instance::resolve(self.tcx, self.param_env, def_id, substs);
                     debug!("Resolving ({:?}) -> {:?}", def_id, instance);
                     if let Ok(Some(func)) = instance {
-                        if let InstanceDef::Item(def_id, _) = func.def {
-                            if is_const_fn(self.tcx, def_id) {
+                        if let InstanceDef::Item(def) = func.def {
+                            if is_const_fn(self.tcx, def.did) {
                                 return;
                             }
                         }
diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs
@@ -116,17 +116,17 @@ pub struct MirSource<'tcx> {
 
 impl<'tcx> MirSource<'tcx> {
     pub fn item(def_id: DefId) -> Self {
-        MirSource { instance: InstanceDef::Item(def_id, None), promoted: None }
+        MirSource { instance: InstanceDef::Item(ty::WithOptParam::dummy(def_id)), promoted: None }
     }
 
     #[inline]
-    pub fn def_id(&self) -> DefId {
+    pub fn def_id(self) -> DefId {
         self.instance.def_id()
     }
 
     #[inline]
-    pub fn with_opt_param(&self, tcx: TyCtxt<'tcx>) -> ty::WithOptParam<DefId> {
-        self.instance.with_opt_param(tcx)
+    pub fn with_opt_param(self) -> ty::WithOptParam<DefId> {
+        self.instance.with_opt_param()
     }
 }
 
@@ -264,7 +264,7 @@ fn mir_const(tcx: TyCtxt<'_>, def: ty::WithOptParam<DefId>) -> Steal<Body<'_>> {
     run_passes(
         tcx,
         &mut body,
-        InstanceDef::Item(def.did.to_def_id(), def.param_did),
+        InstanceDef::Item(def.to_global()),
         None,
         MirPhase::Const,
         &[&[
@@ -299,7 +299,7 @@ fn mir_validated(
     run_passes(
         tcx,
         &mut body,
-        InstanceDef::Item(def.did.to_def_id(), def.param_did),
+        InstanceDef::Item(def.to_global()),
         None,
         MirPhase::Validated,
         &[&[
@@ -365,7 +365,7 @@ fn run_post_borrowck_cleanup_passes<'tcx>(
     run_passes(
         tcx,
         body,
-        InstanceDef::Item(def_id.to_def_id(), None),
+        InstanceDef::Item(ty::WithOptParam::dummy(def_id.to_def_id())),
         promoted,
         MirPhase::DropElab,
         &[post_borrowck_cleanup],
@@ -429,7 +429,7 @@ fn run_optimization_passes<'tcx>(
     run_passes(
         tcx,
         body,
-        InstanceDef::Item(def_id.to_def_id(), None),
+        InstanceDef::Item(ty::WithOptParam::dummy(def_id.to_def_id())),
         promoted,
         MirPhase::Optimized,
         &[
diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
@@ -60,7 +60,7 @@ impl<'tcx> MirPass<'tcx> for PromoteTemps<'tcx> {
             return;
         }
 
-        let def = src.with_opt_param(tcx);
+        let def = src.with_opt_param();
 
         let mut rpo = traversal::reverse_postorder(body);
         let ccx = ConstCx::new(tcx, def.did.expect_local(), body);
diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs
@@ -235,7 +235,8 @@ pub fn write_mir_pretty<'tcx>(
 
     let mut first = true;
     for def_id in dump_mir_def_ids(tcx, single) {
-        let body = &tcx.optimized_mir(tcx.with_opt_param(def_id));
+        let def = ty::WithOptParam::dummy(def_id);
+        let body = &tcx.optimized_mir(def);
 
         if first {
             first = false;
@@ -246,10 +247,9 @@ pub fn write_mir_pretty<'tcx>(
 
         write_mir_fn(tcx, MirSource::item(def_id), body, &mut |_, _| Ok(()), w)?;
 
-        for (i, body) in tcx.promoted_mir(tcx.with_opt_param(def_id)).iter_enumerated() {
+        for (i, body) in tcx.promoted_mir(def).iter_enumerated() {
             writeln!(w)?;
-            let src =
-                MirSource { instance: ty::InstanceDef::Item(def_id, None), promoted: Some(i) };
+            let src = MirSource { instance: ty::InstanceDef::Item(def), promoted: Some(i) };
             write_mir_fn(tcx, src, body, &mut |_, _| Ok(()), w)?;
         }
     }
diff --git a/src/librustc_mir_build/hair/pattern/mod.rs b/src/librustc_mir_build/hair/pattern/mod.rs
@@ -802,7 +802,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
         // defined, not where it is declared. The difference is significant for associated
         // constants.
         let mir_structural_match_violation =
-            self.tcx.mir_const_qualif(instance.with_opt_param(self.tcx)).custom_eq;
+            self.tcx.mir_const_qualif(instance.def.with_opt_param()).custom_eq;
         debug!("mir_structural_match_violation({:?}) -> {}", qpath, mir_structural_match_violation);
 
         match self.tcx.const_eval_instance(param_env_reveal_all, instance, Some(span)) {
diff --git a/src/librustc_ty/instance.rs b/src/librustc_ty/instance.rs

Original file line number	Diff line number	Diff line change
`@@ -249,9 +249,9 @@ fn exported_symbols_provider_local(`
`249`	`249`	`}`
`250`	`250`
`251`	`251`	`match *mono_item {`
`252`		`- MonoItem::Fn(Instance { def: InstanceDef::Item(def_id, _), substs }) => {`
	`252`	`+ MonoItem::Fn(Instance { def: InstanceDef::Item(def), substs }) => {`
`253`	`253`	`if substs.non_erasable_generics().next().is_some() {`
`254`		`- let symbol = ExportedSymbol::Generic(def_id, substs);`
	`254`	`+ let symbol = ExportedSymbol::Generic(def.did, substs);`
`255`	`255`	`symbols.push((symbol, SymbolExportLevel::Rust));`
`256`	`256`	`}`
`257`	`257`	`}`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ pub fn const_eval_raw_provider<'tcx>(`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`let cid = key.value;`
`291`		`- let def = cid.instance.with_opt_param(tcx);`
	`291`	`+ let def = cid.instance.def.with_opt_param();`
`292`	`292`
`293`	`293`	`if let Some(def) = def.as_local() {`
`294`	`294`	`if tcx.has_typeck_tables(def.did) {`