Make ty::util take SpanId.

cjgillot · cjgillot · commit 72495121c915 · 2020-05-12T18:54:38.000+02:00
diff --git a/src/librustc_codegen_ssa/traits/type_.rs b/src/librustc_codegen_ssa/traits/type_.rs
@@ -5,7 +5,7 @@ use crate::common::TypeKind;
 use crate::mir::place::PlaceRef;
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::DUMMY_SP;
+use rustc_span::DUMMY_SPID;
 use rustc_target::abi::call::{ArgAbi, CastTarget, FnAbi, Reg};
 use rustc_target::abi::Integer;
 
@@ -70,16 +70,16 @@ pub trait DerivedTypeMethods<'tcx>: BaseTypeMethods<'tcx> + MiscMethods<'tcx> {
     }
 
     fn type_is_sized(&self, ty: Ty<'tcx>) -> bool {
-        ty.is_sized(self.tcx().at(DUMMY_SP), ty::ParamEnv::reveal_all())
+        ty.is_sized(self.tcx().at(DUMMY_SPID), ty::ParamEnv::reveal_all())
     }
 
     fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool {
-        ty.is_freeze(self.tcx(), ty::ParamEnv::reveal_all(), DUMMY_SP)
+        ty.is_freeze(self.tcx(), ty::ParamEnv::reveal_all(), DUMMY_SPID)
     }
 
     fn type_has_metadata(&self, ty: Ty<'tcx>) -> bool {
         let param_env = ty::ParamEnv::reveal_all();
-        if ty.is_sized(self.tcx().at(DUMMY_SP), param_env) {
+        if ty.is_sized(self.tcx().at(DUMMY_SPID), param_env) {
             return false;
         }
 
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -562,7 +562,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingCopyImplementations {
             return;
         }
         let param_env = ty::ParamEnv::empty();
-        if ty.is_copy_modulo_regions(cx.tcx, param_env, item.span) {
+        if ty.is_copy_modulo_regions(cx.tcx, param_env, item.span.into()) {
             return;
         }
         if can_type_implement_copy(cx.tcx, param_env, ty).is_ok() {
diff --git a/src/librustc_middle/ty/layout.rs b/src/librustc_middle/ty/layout.rs
@@ -12,7 +12,7 @@ use rustc_index::bit_set::BitSet;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_session::{DataTypeKind, FieldInfo, SizeKind, VariantInfo};
 use rustc_span::symbol::{Ident, Symbol};
-use rustc_span::DUMMY_SP;
+use rustc_span::DUMMY_SPID;
 use rustc_target::abi::call::{
     ArgAbi, ArgAttribute, ArgAttributes, Conv, FnAbi, PassMode, Reg, RegKind,
 };
@@ -535,7 +535,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                 }
 
                 let pointee = tcx.normalize_erasing_regions(param_env, pointee);
-                if pointee.is_sized(tcx.at(DUMMY_SP), param_env) {
+                if pointee.is_sized(tcx.at(DUMMY_SPID), param_env) {
                     return Ok(tcx.intern_layout(Layout::scalar(self, data_ptr)));
                 }
 
@@ -798,7 +798,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                         let param_env = tcx.param_env(def.did);
                         let last_field = def.variants[v].fields.last().unwrap();
                         let always_sized =
-                            tcx.type_of(last_field.did).is_sized(tcx.at(DUMMY_SP), param_env);
+                            tcx.type_of(last_field.did).is_sized(tcx.at(DUMMY_SPID), param_env);
                         if !always_sized {
                             StructKind::MaybeUnsized
                         } else {
@@ -2160,7 +2160,7 @@ where
 
             ty::Ref(_, ty, mt) if offset.bytes() == 0 => {
                 let tcx = cx.tcx();
-                let is_freeze = ty.is_freeze(tcx, cx.param_env(), DUMMY_SP);
+                let is_freeze = ty.is_freeze(tcx, cx.param_env(), DUMMY_SPID);
                 let kind = match mt {
                     hir::Mutability::Not => {
                         if is_freeze {
diff --git a/src/librustc_middle/ty/util.rs b/src/librustc_middle/ty/util.rs
@@ -18,7 +18,7 @@ use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
-use rustc_span::Span;
+use rustc_span::{Span, SpanId};
 use rustc_target::abi::{Integer, Size, TargetDataLayout};
 use smallvec::SmallVec;
 use std::{cmp, fmt};
@@ -683,7 +683,7 @@ impl<'tcx> ty::TyS<'tcx> {
         &'tcx self,
         tcx: TyCtxt<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
-        span: Span,
+        span: SpanId,
     ) -> bool {
         tcx.at(span).is_copy_raw(param_env.and(self))
     }
@@ -709,7 +709,7 @@ impl<'tcx> ty::TyS<'tcx> {
         &'tcx self,
         tcx: TyCtxt<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
-        span: Span,
+        span: SpanId,
     ) -> bool {
         self.is_trivially_freeze() || tcx.at(span).is_freeze_raw(param_env.and(self))
     }
diff --git a/src/librustc_mir/dataflow/impls/borrowed_locals.rs b/src/librustc_mir/dataflow/impls/borrowed_locals.rs
@@ -4,7 +4,7 @@ use crate::dataflow::{AnalysisDomain, GenKill, GenKillAnalysis};
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{ParamEnv, TyCtxt};
-use rustc_span::DUMMY_SP;
+use rustc_span::DUMMY_SPID;
 
 pub type MaybeMutBorrowedLocals<'mir, 'tcx> = MaybeBorrowedLocals<MutBorrow<'mir, 'tcx>>;
 
@@ -231,7 +231,7 @@ impl MutBorrow<'mir, 'tcx> {
     ///
     /// [rust-lang/unsafe-code-guidelines#134]: https://github.com/rust-lang/unsafe-code-guidelines/issues/134
     fn shared_borrow_allows_mutation(&self, place: Place<'tcx>) -> bool {
-        !place.ty(self.body, self.tcx).ty.is_freeze(self.tcx, self.param_env, DUMMY_SP)
+        !place.ty(self.body, self.tcx).ty.is_freeze(self.tcx, self.param_env, DUMMY_SPID)
     }
 }
 
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
@@ -17,7 +17,7 @@ use rustc_middle::ty::layout::{self, TyAndLayout};
 use rustc_middle::ty::{
     self, fold::BottomUpFolder, query::TyCtxtAt, subst::SubstsRef, Ty, TyCtxt, TypeFoldable,
 };
-use rustc_span::{source_map::DUMMY_SP, SpanId};
+use rustc_span::{SpanId, DUMMY_SP, DUMMY_SPID};
 use rustc_target::abi::{Align, HasDataLayout, LayoutOf, Size, TargetDataLayout};
 
 use super::{
@@ -392,7 +392,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
     #[inline]
     pub fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool {
-        ty.is_freeze(*self.tcx, self.param_env, DUMMY_SP)
+        ty.is_freeze(*self.tcx, self.param_env, DUMMY_SPID)
     }
 
     pub fn load_mir(
@@ -948,7 +948,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     mir::ClearCrossCrate::Clear => None,
                 }
             });
-            let span = source_info.map_or(DUMMY_SP, |source_info| source_info.span);
+            let span = source_info.map_or(DUMMY_SP, |source_info| source_info.span).into();
 
             frames.push(FrameInfo { span, instance: frame.instance, lint_root });
         }
diff --git a/src/librustc_mir/interpret/intern.rs b/src/librustc_mir/interpret/intern.rs
@@ -109,9 +109,7 @@ fn intern_shallow<'rt, 'mir, 'tcx, M: CompileTimeMachine<'mir, 'tcx>>(
     // access this one.
     if mode == InternMode::Static {
         // When `ty` is `None`, we assume no interior mutability.
-        let frozen = ty.map_or(true, |ty| {
-            ty.is_freeze(ecx.tcx.tcx, ecx.param_env, ecx.tcx.reify_span(ecx.tcx.span))
-        });
+        let frozen = ty.map_or(true, |ty| ty.is_freeze(ecx.tcx.tcx, ecx.param_env, ecx.tcx.span));
         // For statics, allocation mutability is the combination of the place mutability and
         // the type mutability.
         // The entire allocation needs to be mutable if it contains an `UnsafeCell` anywhere.
diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs
@@ -306,7 +306,7 @@ fn build_clone_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'tcx>) -
     let param_env = tcx.param_env(def_id);
 
     let mut builder = CloneShimBuilder::new(tcx, def_id, self_ty);
-    let is_copy = self_ty.is_copy_modulo_regions(tcx, param_env, builder.span);
+    let is_copy = self_ty.is_copy_modulo_regions(tcx, param_env, builder.span.into());
 
     let dest = Place::return_place();
     let src = tcx.mk_place_deref(Place::from(Local::new(1 + 0)));
diff --git a/src/librustc_mir/transform/check_consts/qualifs.rs b/src/librustc_mir/transform/check_consts/qualifs.rs
@@ -5,7 +5,7 @@
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, subst::SubstsRef, AdtDef, Ty};
-use rustc_span::DUMMY_SP;
+use rustc_span::DUMMY_SPID;
 use rustc_trait_selection::traits;
 
 use super::ConstCx;
@@ -78,7 +78,7 @@ impl Qualif for HasMutInterior {
     }
 
     fn in_any_value_of_ty(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
-        !ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SP)
+        !ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SPID)
     }
 
     fn in_adt_inherently(cx: &ConstCx<'_, 'tcx>, adt: &'tcx AdtDef, _: SubstsRef<'tcx>) -> bool {
diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs
@@ -271,7 +271,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
                             if !elem_ty.is_copy_modulo_regions(
                                 self.tcx,
                                 self.param_env,
-                                self.source_info.span,
+                                self.source_info.span.into(),
                             ) {
                                 self.require_unsafe(
                                     "assignment to non-`Copy` union field",
@@ -419,7 +419,7 @@ impl<'a, 'tcx> UnsafetyChecker<'a, 'tcx> {
                             } else if !place.ty(self.body, self.tcx).ty.is_freeze(
                                 self.tcx,
                                 self.param_env,
-                                self.source_info.span,
+                                self.source_info.span.into(),
                             ) {
                                 (
                                     "borrow of layout constrained field with interior \
diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
@@ -22,7 +22,7 @@ use rustc_middle::ty::cast::CastTy;
 use rustc_middle::ty::subst::InternalSubsts;
 use rustc_middle::ty::{self, List, TyCtxt, TypeFoldable};
 use rustc_span::symbol::sym;
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::{Span, DUMMY_SPID};
 
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_target::spec::abi::Abi;
@@ -330,7 +330,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                                     Place::ty_from(place.local, proj_base, self.body, self.tcx)
                                         .projection_ty(self.tcx, elem)
                                         .ty;
-                                if ty.is_freeze(self.tcx, self.param_env, DUMMY_SP) {
+                                if ty.is_freeze(self.tcx, self.param_env, DUMMY_SPID) {
                                     has_mut_interior = false;
                                     break;
                                 }
@@ -653,7 +653,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                         let ty = Place::ty_from(place.local, proj_base, self.body, self.tcx)
                             .projection_ty(self.tcx, elem)
                             .ty;
-                        if ty.is_freeze(self.tcx, self.param_env, DUMMY_SP) {
+                        if ty.is_freeze(self.tcx, self.param_env, DUMMY_SPID) {
                             has_mut_interior = false;
                             break;
                         }
diff --git a/src/librustc_mir_build/build/expr/as_operand.rs b/src/librustc_mir_build/build/expr/as_operand.rs
@@ -172,7 +172,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
             if !ty.is_sized(tcx.at(span), param_env) {
                 // !sized means !copy, so this is an unsized move
-                assert!(!ty.is_copy_modulo_regions(tcx, param_env, span));
+                assert!(!ty.is_copy_modulo_regions(tcx, param_env, span.into()));
 
                 // As described above, detect the case where we are passing a value of unsized
                 // type, and that value is coming from the deref of a box.
diff --git a/src/librustc_mir_build/hair/pattern/check_match.rs b/src/librustc_mir_build/hair/pattern/check_match.rs
@@ -579,7 +579,7 @@ fn maybe_point_at_variant(ty: Ty<'_>, patterns: &[super::Pat<'_>]) -> Vec<Span>
 
 /// Check if a by-value binding is by-value. That is, check if the binding's type is not `Copy`.
 fn is_binding_by_move(cx: &MatchVisitor<'_, '_>, hir_id: HirId, span: Span) -> bool {
-    !cx.tables.node_type(hir_id).is_copy_modulo_regions(cx.tcx, cx.param_env, span)
+    !cx.tables.node_type(hir_id).is_copy_modulo_regions(cx.tcx, cx.param_env, span.into())
 }
 
 /// Check the legality of legality of by-move bindings.
diff --git a/src/librustc_trait_selection/infer.rs b/src/librustc_trait_selection/infer.rs
@@ -44,7 +44,7 @@ impl<'cx, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'cx, 'tcx> {
         let ty = self.resolve_vars_if_possible(&ty);
 
         if !(param_env, ty).needs_infer() {
-            return ty.is_copy_modulo_regions(self.tcx, param_env, span);
+            return ty.is_copy_modulo_regions(self.tcx, param_env, span.into());
         }
 
         let copy_def_id = self.tcx.require_lang_item(lang_items::CopyTraitLangItem, None);
diff --git a/src/librustc_trait_selection/traits/misc.rs b/src/librustc_trait_selection/traits/misc.rs
@@ -52,7 +52,7 @@ pub fn can_type_implement_copy(
                 let ctx = traits::FulfillmentContext::new();
                 match traits::fully_normalize(&infcx, ctx, cause, param_env, &ty) {
                     Ok(ty) => {
-                        if !infcx.type_is_copy_modulo_regions(param_env, ty, span) {
+                        if !infcx.type_is_copy_modulo_regions(param_env, ty, span.into()) {
                             infringing.push(field);
                         }
                     }
diff --git a/src/librustc_ty/needs_drop.rs b/src/librustc_ty/needs_drop.rs
@@ -5,7 +5,7 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::util::{needs_drop_components, AlwaysRequiresDrop};
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_span::DUMMY_SP;
+use rustc_span::DUMMY_SPID;
 
 type NeedsDropResult<T> = Result<T, AlwaysRequiresDrop>;
 
@@ -71,7 +71,7 @@ where
                 // Not having a `Span` isn't great. But there's hopefully some other
                 // recursion limit error as well.
                 tcx.sess.span_err(
-                    DUMMY_SP,
+                    DUMMY_SPID,
                     &format!("overflow while checking whether `{}` requires drop", self.query_ty),
                 );
                 return Some(Err(AlwaysRequiresDrop));
@@ -91,7 +91,7 @@ where
 
             for component in components {
                 match component.kind {
-                    _ if component.is_copy_modulo_regions(tcx, self.param_env, DUMMY_SP) => (),
+                    _ if component.is_copy_modulo_regions(tcx, self.param_env, DUMMY_SPID) => (),
 
                     ty::Closure(_, substs) => {
                         for upvar_ty in substs.as_closure().upvar_tys() {
diff --git a/src/tools/clippy/clippy_lints/src/functions.rs b/src/tools/clippy/clippy_lints/src/functions.rs
@@ -507,7 +507,7 @@ fn is_mutable_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>, span: Span,
         // primitive types are never mutable
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
         ty::Adt(ref adt, ref substs) => {
-            tys.insert(adt.did) && !ty.is_freeze(cx.tcx, cx.param_env, span)
+            tys.insert(adt.did) && !ty.is_freeze(cx.tcx, cx.param_env, span.into())
                 || KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did, path))
                     && substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
         },
diff --git a/src/tools/clippy/clippy_lints/src/let_if_seq.rs b/src/tools/clippy/clippy_lints/src/let_if_seq.rs
@@ -76,7 +76,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {
                     let has_interior_mutability = !cx.tables.node_type(canonical_id).is_freeze(
                         cx.tcx,
                         cx.param_env,
-                        span
+                        span.into()
                     );
                     if has_interior_mutability { return; }
 
diff --git a/src/tools/clippy/clippy_lints/src/mut_key.rs b/src/tools/clippy/clippy_lints/src/mut_key.rs
@@ -118,7 +118,7 @@ fn is_mutable_type<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>, span: Spa
             size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0) && is_mutable_type(cx, inner_ty, span)
         },
         Tuple(..) => ty.tuple_fields().any(|ty| is_mutable_type(cx, ty, span)),
-        Adt(..) => cx.tcx.layout_of(cx.param_env.and(ty)).is_ok() && !ty.is_freeze(cx.tcx, cx.param_env, span),
+        Adt(..) => cx.tcx.layout_of(cx.param_env.and(ty)).is_ok() && !ty.is_freeze(cx.tcx, cx.param_env, span.into()),
         _ => false,
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
@@ -10,7 +10,7 @@ use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{Ty, TypeFlags};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{InnerSpan, Span, DUMMY_SP};
+use rustc_span::{InnerSpan, Span, DUMMY_SPID};
 use rustc_typeck::hir_ty_to_ty;
 
 use crate::utils::{in_constant, is_copy, qpath_res, span_lint_and_then};
@@ -110,7 +110,7 @@ impl Source {
 }
 
 fn verify_ty_bound<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>, source: Source) {
-    if ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SP) || is_copy(cx, ty) {
+    if ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SPID) || is_copy(cx, ty) {
         // An `UnsafeCell` is `!Copy`, and an `UnsafeCell` is also the only type which
         // is `!Freeze`, thus if our type is `Copy` we can be sure it must be `Freeze`
         // as well.
diff --git a/src/tools/clippy/clippy_lints/src/question_mark.rs b/src/tools/clippy/clippy_lints/src/question_mark.rs
@@ -137,7 +137,7 @@ impl QuestionMark {
     fn moves_by_default(cx: &LateContext<'_, '_>, expression: &Expr<'_>) -> bool {
         let expr_ty = cx.tables.expr_ty(expression);
 
-        !expr_ty.is_copy_modulo_regions(cx.tcx, cx.param_env, expression.span)
+        !expr_ty.is_copy_modulo_regions(cx.tcx, cx.param_env, expression.span.into())
     }
 
     fn is_option(cx: &LateContext<'_, '_>, expression: &Expr<'_>) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/utils/mod.rs b/src/tools/clippy/clippy_lints/src/utils/mod.rs
@@ -45,7 +45,7 @@ use rustc_middle::ty::{self, layout::IntegerExt, subst::GenericArg, Binder, Ty,
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::symbol::{self, kw, Symbol};
-use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
+use rustc_span::{BytePos, Pos, Span, DUMMY_SP, DUMMY_SPID};
 use rustc_target::abi::Integer;
 use rustc_trait_selection::traits::predicate_for_trait_def;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
@@ -914,7 +914,7 @@ pub fn type_is_unsafe_function<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx
 }
 
 pub fn is_copy<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.is_copy_modulo_regions(cx.tcx, cx.param_env, DUMMY_SP)
+    ty.is_copy_modulo_regions(cx.tcx, cx.param_env, DUMMY_SPID)
 }
 
 /// Checks if an expression is constructing a tuple-like enum variant or struct

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ use crate::common::TypeKind;`
`5`	`5`	`use crate::mir::place::PlaceRef;`
`6`	`6`	`use rustc_middle::ty::layout::TyAndLayout;`
`7`	`7`	`use rustc_middle::ty::{self, Ty};`
`8`		`-use rustc_span::DUMMY_SP;`
	`8`	`+use rustc_span::DUMMY_SPID;`
`9`	`9`	`use rustc_target::abi::call::{ArgAbi, CastTarget, FnAbi, Reg};`
`10`	`10`	`use rustc_target::abi::Integer;`
`11`	`11`
`@@ -70,16 +70,16 @@ pub trait DerivedTypeMethods<'tcx>: BaseTypeMethods<'tcx> + MiscMethods<'tcx> {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`fn type_is_sized(&self, ty: Ty<'tcx>) -> bool {`
`73`		`- ty.is_sized(self.tcx().at(DUMMY_SP), ty::ParamEnv::reveal_all())`
	`73`	`+ ty.is_sized(self.tcx().at(DUMMY_SPID), ty::ParamEnv::reveal_all())`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool {`
`77`		`- ty.is_freeze(self.tcx(), ty::ParamEnv::reveal_all(), DUMMY_SP)`
	`77`	`+ ty.is_freeze(self.tcx(), ty::ParamEnv::reveal_all(), DUMMY_SPID)`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`fn type_has_metadata(&self, ty: Ty<'tcx>) -> bool {`
`81`	`81`	`let param_env = ty::ParamEnv::reveal_all();`
`82`		`- if ty.is_sized(self.tcx().at(DUMMY_SP), param_env) {`
	`82`	`+ if ty.is_sized(self.tcx().at(DUMMY_SPID), param_env) {`
`83`	`83`	`return false;`
`84`	`84`	`}`
`85`	`85`
Original file line number	Diff line number	Diff line change
`@@ -562,7 +562,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingCopyImplementations {`
`562`	`562`	`return;`
`563`	`563`	`}`
`564`	`564`	`let param_env = ty::ParamEnv::empty();`
`565`		`- if ty.is_copy_modulo_regions(cx.tcx, param_env, item.span) {`
	`565`	`+ if ty.is_copy_modulo_regions(cx.tcx, param_env, item.span.into()) {`
`566`	`566`	`return;`
`567`	`567`	`}`
`568`	`568`	`if can_type_implement_copy(cx.tcx, param_env, ty).is_ok() {`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ use crate::dataflow::{AnalysisDomain, GenKill, GenKillAnalysis};`
`4`	`4`	`use rustc_middle::mir::visit::Visitor;`
`5`	`5`	`use rustc_middle::mir::*;`
`6`	`6`	`use rustc_middle::ty::{ParamEnv, TyCtxt};`
`7`		`-use rustc_span::DUMMY_SP;`
	`7`	`+use rustc_span::DUMMY_SPID;`
`8`	`8`
`9`	`9`	`pub type MaybeMutBorrowedLocals<'mir, 'tcx> = MaybeBorrowedLocals<MutBorrow<'mir, 'tcx>>;`
`10`	`10`
`@@ -231,7 +231,7 @@ impl MutBorrow<'mir, 'tcx> {`
`231`	`231`	`///`
`232`	`232`	`/// [rust-lang/unsafe-code-guidelines#134]: https://github.com/rust-lang/unsafe-code-guidelines/issues/134`
`233`	`233`	`fn shared_borrow_allows_mutation(&self, place: Place<'tcx>) -> bool {`
`234`		`- !place.ty(self.body, self.tcx).ty.is_freeze(self.tcx, self.param_env, DUMMY_SP)`
	`234`	`+ !place.ty(self.body, self.tcx).ty.is_freeze(self.tcx, self.param_env, DUMMY_SPID)`
`235`	`235`	`}`
`236`	`236`	`}`
`237`	`237`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`use rustc_infer::infer::TyCtxtInferExt;`
`6`	`6`	`use rustc_middle::mir::*;`
`7`	`7`	`use rustc_middle::ty::{self, subst::SubstsRef, AdtDef, Ty};`
`8`		`-use rustc_span::DUMMY_SP;`
	`8`	`+use rustc_span::DUMMY_SPID;`
`9`	`9`	`use rustc_trait_selection::traits;`
`10`	`10`
`11`	`11`	`use super::ConstCx;`
`@@ -78,7 +78,7 @@ impl Qualif for HasMutInterior {`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`fn in_any_value_of_ty(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {`
`81`		`- !ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SP)`
	`81`	`+ !ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SPID)`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`fn in_adt_inherently(cx: &ConstCx<'_, 'tcx>, adt: &'tcx AdtDef, _: SubstsRef<'tcx>) -> bool {`