Remove subst_spanned

rust-lang · May 9, 2022 · e14eae6 · e14eae6
1 parent f9b2e3c
commit e14eae6
Show file tree

Hide file tree

Showing 3 changed files with 14 additions and 53 deletions.
diff --git a/compiler/rustc_middle/src/ty/subst.rs b/compiler/rustc_middle/src/ty/subst.rs
@@ -10,7 +10,7 @@ use rustc_data_structures::intern::{Interned, WithStableHash};
 use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
 use rustc_serialize::{self, Decodable, Encodable};
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::DUMMY_SP;
 use smallvec::SmallVec;
 
 use core::intrinsics;
@@ -498,34 +498,14 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::List<Ty<'tcx>> {
  }
 }
 
-///////////////////////////////////////////////////////////////////////////
-// Public trait `Subst`
-//
-// Just call `foo.subst(tcx, substs)` to perform a substitution across
-// `foo`. Or use `foo.subst_spanned(tcx, substs, Some(span))` when
-// there is more information available (for better errors).
-
+// Just call `foo.subst(tcx, substs)` to perform a substitution across `foo`.
 pub trait Subst<'tcx>: Sized {
- fn subst(self, tcx: TyCtxt<'tcx>, substs: &[GenericArg<'tcx>]) -> Self {
- self.subst_spanned(tcx, substs, None)
- }
-
- fn subst_spanned(
- self,
- tcx: TyCtxt<'tcx>,
- substs: &[GenericArg<'tcx>],
- span: Option<Span>,
- ) -> Self;
+ fn subst(self, tcx: TyCtxt<'tcx>, substs: &[GenericArg<'tcx>]) -> Self;
 }
 
 impl<'tcx, T: TypeFoldable<'tcx>> Subst<'tcx> for T {
- fn subst_spanned(
- self,
- tcx: TyCtxt<'tcx>,
- substs: &[GenericArg<'tcx>],
- span: Option<Span>,
- ) -> T {
- let mut folder = SubstFolder { tcx, substs, span, binders_passed: 0 };
+ fn subst(self, tcx: TyCtxt<'tcx>, substs: &[GenericArg<'tcx>]) -> T {
+ let mut folder = SubstFolder { tcx, substs, binders_passed: 0 };
  self.fold_with(&mut folder)
  }
 }
@@ -537,9 +517,6 @@ struct SubstFolder<'a, 'tcx> {
  tcx: TyCtxt<'tcx>,
  substs: &'a [GenericArg<'tcx>],
 
- /// The location for which the substitution is performed, if available.
- span: Option<Span>,
-
  /// Number of region binders we have passed through while doing the substitution
  binders_passed: u32,
 }
@@ -571,13 +548,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
  match rk {
  Some(GenericArgKind::Lifetime(lt)) => self.shift_region_through_binders(lt),
  _ => {
- let span = self.span.unwrap_or(DUMMY_SP);
  let msg = format!(
  "Region parameter out of range \
  when substituting in region {} (index={})",
  data.name, data.index
  );
- span_bug!(span, "{}", msg);
+ span_bug!(DUMMY_SP, "{}", msg);
  }
  }
  }
@@ -617,9 +593,8 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
  let ty = match opt_ty {
  Some(GenericArgKind::Type(ty)) => ty,
  Some(kind) => {
- let span = self.span.unwrap_or(DUMMY_SP);
  span_bug!(
- span,
+ DUMMY_SP,
  "expected type for `{:?}` ({:?}/{}) but found {:?} \
  when substituting, substs={:?}",
  p,
@@ -630,9 +605,8 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
  );
  }
  None => {
- let span = self.span.unwrap_or(DUMMY_SP);
  span_bug!(
- span,
+ DUMMY_SP,
  "type parameter `{:?}` ({:?}/{}) out of range \
  when substituting, substs={:?}",
  p,
@@ -652,9 +626,8 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
  let ct = match opt_ct {
  Some(GenericArgKind::Const(ct)) => ct,
  Some(kind) => {
- let span = self.span.unwrap_or(DUMMY_SP);
  span_bug!(
- span,
+ DUMMY_SP,
  "expected const for `{:?}` ({:?}/{}) but found {:?} \
  when substituting substs={:?}",
  p,
@@ -665,9 +638,8 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
  );
  }
  None => {
- let span = self.span.unwrap_or(DUMMY_SP);
  span_bug!(
- span,
+ DUMMY_SP,
  "const parameter `{:?}` ({:?}/{}) out of range \
  when substituting substs={:?}",
  p,

diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -523,11 +523,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  self.astconv
  .normalize_ty(
  self.span,
- tcx.at(self.span).type_of(param.def_id).subst_spanned(
- tcx,
- substs,
- Some(self.span),
- ),
+ tcx.at(self.span).type_of(param.def_id).subst(tcx, substs),
  )
  .into()
  }
@@ -547,9 +543,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  GenericParamDefKind::Const { has_default } => {
  let ty = tcx.at(self.span).type_of(param.def_id);
  if !infer_args && has_default {
- tcx.const_param_default(param.def_id)
- .subst_spanned(tcx, substs.unwrap(), Some(self.span))
- .into()
+ tcx.const_param_default(param.def_id).subst(tcx, substs.unwrap()).into()
  } else {
  if infer_args {
  self.astconv.ct_infer(ty, Some(param), self.span).into()

diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
@@ -1403,10 +1403,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // is missing.
  let default = tcx.type_of(param.def_id);
  self.fcx
- .normalize_ty(
- self.span,
- default.subst_spanned(tcx, substs.unwrap(), Some(self.span)),
- )
+ .normalize_ty(self.span, default.subst(tcx, substs.unwrap()))
  .into()
  } else {
  // If no type arguments were provided, we have to infer them.
@@ -1418,9 +1415,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
  GenericParamDefKind::Const { has_default } => {
  if !infer_args && has_default {
- tcx.const_param_default(param.def_id)
- .subst_spanned(tcx, substs.unwrap(), Some(self.span))
- .into()
+ tcx.const_param_default(param.def_id).subst(tcx, substs.unwrap()).into()
  } else {
  self.fcx.var_for_def(self.span, param)
  }