From 273b990554fa2a7efdd975ccf2ef490c6c90cbaf Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 29 May 2024 22:23:49 -0400
Subject: [PATCH] Align Term methods with GenericArg methods
---
.../rustc_codegen_ssa/src/debuginfo/type_names.rs | 2 +-
.../src/check/compare_impl_item.rs | 2 +-
.../src/check/compare_impl_item/refine.rs | 2 +-
compiler/rustc_hir_analysis/src/check/mod.rs | 4 +++-
compiler/rustc_hir_typeck/src/closure.rs | 4 ++--
compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs | 2 +-
.../rustc_infer/src/infer/error_reporting/mod.rs | 2 +-
compiler/rustc_infer/src/infer/mod.rs | 4 ++--
.../rustc_lint/src/opaque_hidden_inferred_bound.rs | 2 +-
compiler/rustc_middle/src/ty/mod.rs | 12 ++++++++++--
compiler/rustc_middle/src/ty/print/pretty.rs | 6 +++---
.../src/solve/assembly/structural_traits.rs | 2 +-
.../src/solve/normalizes_to/opaque_types.rs | 2 +-
.../rustc_trait_selection/src/traits/auto_trait.rs | 2 +-
.../src/traits/error_reporting/suggestions.rs | 8 ++++----
.../rustc_trait_selection/src/traits/normalize.rs | 4 ++--
.../src/traits/select/candidate_assembly.rs | 2 +-
compiler/rustc_trait_selection/src/traits/wf.rs | 2 +-
compiler/rustc_traits/src/normalize_projection_ty.rs | 2 +-
.../methods/iter_on_single_or_empty_collections.rs | 2 +-
.../src/needless_borrows_for_generic_args.rs | 4 ++--
.../clippy_lints/src/unit_return_expecting_ord.rs | 4 ++--
src/tools/clippy/clippy_utils/src/ty.rs | 6 +++---
23 files changed, 46 insertions(+), 36 deletions(-)
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
index 07473ee476baf..2360cce55a991 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -263,7 +263,7 @@ fn push_debuginfo_type_name<'tcx>(
let ExistentialProjection { def_id: item_def_id, term, .. } =
tcx.instantiate_bound_regions_with_erased(bound);
// FIXME(associated_const_equality): allow for consts here
- (item_def_id, term.ty().unwrap())
+ (item_def_id, term.expect_type())
})
.collect();
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index f7bebc2697d7b..74dcd672578e6 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -2281,7 +2281,7 @@ fn try_report_async_mismatch<'tcx>(
&& let Some(proj) = proj.no_bound_vars()
&& infcx.can_eq(
error.root_obligation.param_env,
- proj.term.ty().unwrap(),
+ proj.term.expect_type(),
impl_sig.output(),
)
{
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
index ca08eeea22750..10b097a1060f3 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
@@ -267,7 +267,7 @@ fn report_mismatched_rpitit_signature<'tcx>(
.explicit_item_bounds(future_ty.def_id)
.iter_instantiated_copied(tcx, future_ty.args)
.find_map(|(clause, _)| match clause.kind().no_bound_vars()? {
- ty::ClauseKind::Projection(proj) => proj.term.ty(),
+ ty::ClauseKind::Projection(proj) => proj.term.as_type(),
_ => None,
})
else {
diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index da66e1f34fd97..4d1b96d9c1bac 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -441,7 +441,9 @@ fn fn_sig_suggestion<'tcx>(
output = if let ty::Alias(_, alias_ty) = *output.kind() {
tcx.explicit_item_super_predicates(alias_ty.def_id)
.iter_instantiated_copied(tcx, alias_ty.args)
- .find_map(|(bound, _)| bound.as_projection_clause()?.no_bound_vars()?.term.ty())
+ .find_map(|(bound, _)| {
+ bound.as_projection_clause()?.no_bound_vars()?.term.as_type()
+ })
.unwrap_or_else(|| {
span_bug!(
ident.span,
diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
index 14a6177141c95..ac7ed3e26f976 100644
--- a/compiler/rustc_hir_typeck/src/closure.rs
+++ b/compiler/rustc_hir_typeck/src/closure.rs
@@ -485,7 +485,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
// Since this is a return parameter type it is safe to unwrap.
- let ret_param_ty = projection.skip_binder().term.ty().unwrap();
+ let ret_param_ty = projection.skip_binder().term.expect_type();
let ret_param_ty = self.resolve_vars_if_possible(ret_param_ty);
debug!(?ret_param_ty);
@@ -956,7 +956,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let output_ty = self.resolve_vars_if_possible(predicate.term);
debug!("deduce_future_output_from_projection: output_ty={:?}", output_ty);
// This is a projection on a Fn trait so will always be a type.
- Some(output_ty.ty().unwrap())
+ Some(output_ty.expect_type())
}
/// Converts the types that the user supplied, in case that doing
diff --git a/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs b/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
index 0dfc5408f3060..28745af3a5309 100644
--- a/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
+++ b/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
@@ -160,7 +160,7 @@ impl<'tcx> TypeckRootCtxt<'tcx> {
{
// If the projection predicate (Foo::Bar == X) has X as a non-TyVid,
// we need to make it into one.
- if let Some(vid) = predicate.term.ty().and_then(|ty| ty.ty_vid()) {
+ if let Some(vid) = predicate.term.as_type().and_then(|ty| ty.ty_vid()) {
debug!("infer_var_info: {:?}.output = true", vid);
infer_var_info.entry(vid).or_default().output = true;
}
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
index 95fbc1e66cea5..fe0a246abbc6c 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -425,7 +425,7 @@ impl<'tcx> InferCtxt<'tcx> {
ty::ClauseKind::Projection(projection_predicate)
if projection_predicate.projection_term.def_id == item_def_id =>
{
- projection_predicate.term.ty()
+ projection_predicate.term.as_type()
}
_ => None,
})
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 72c4e1b511e64..f46c596425be8 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -424,8 +424,8 @@ pub enum ValuePairs<'tcx> {
impl<'tcx> ValuePairs<'tcx> {
pub fn ty(&self) -> Option<(Ty<'tcx>, Ty<'tcx>)> {
if let ValuePairs::Terms(ExpectedFound { expected, found }) = self
- && let Some(expected) = expected.ty()
- && let Some(found) = found.ty()
+ && let Some(expected) = expected.as_type()
+ && let Some(found) = found.as_type()
{
Some((expected, found))
} else {
diff --git a/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs b/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs
index eda40e4a011a6..6098da990c043 100644
--- a/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs
+++ b/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs
@@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound {
};
// Only check types, since those are the only things that may
// have opaques in them anyways.
- let Some(proj_term) = proj.term.ty() else { return };
+ let Some(proj_term) = proj.term.as_type() else { return };
// HACK: `impl Trait<Assoc = impl Trait2>` from an RPIT is "ok"...
if let ty::Alias(ty::Opaque, opaque_ty) = *proj_term.kind()
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 2643ce976ded1..3fdcb96696022 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -624,14 +624,22 @@ impl<'tcx> Term<'tcx> {
}
}
- pub fn ty(&self) -> Option<Ty<'tcx>> {
+ pub fn as_type(&self) -> Option<Ty<'tcx>> {
if let TermKind::Ty(ty) = self.unpack() { Some(ty) } else { None }
}
- pub fn ct(&self) -> Option<Const<'tcx>> {
+ pub fn expect_type(&self) -> Ty<'tcx> {
+ self.as_type().expect("expected a type, but found a const")
+ }
+
+ pub fn as_const(&self) -> Option<Const<'tcx>> {
if let TermKind::Const(c) = self.unpack() { Some(c) } else { None }
}
+ pub fn expect_const(&self) -> Const<'tcx> {
+ self.as_const().expect("expected a const, but found a type")
+ }
+
pub fn into_arg(self) -> GenericArg<'tcx> {
match self.unpack() {
TermKind::Ty(ty) => ty.into(),
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 8fb4367d3b586..af7784d6b8ed9 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1077,7 +1077,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
}
p!(")");
- if let Some(ty) = return_ty.skip_binder().ty() {
+ if let Some(ty) = return_ty.skip_binder().as_type() {
if !ty.is_unit() {
p!(" -> ", print(return_ty));
}
@@ -1144,7 +1144,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
for (assoc_item_def_id, term) in assoc_items {
// Skip printing `<{coroutine@} as Coroutine<_>>::Return` from async blocks,
// unless we can find out what coroutine return type it comes from.
- let term = if let Some(ty) = term.skip_binder().ty()
+ let term = if let Some(ty) = term.skip_binder().as_type()
&& let ty::Alias(ty::Projection, proj) = ty.kind()
&& let Some(assoc) = tcx.opt_associated_item(proj.def_id)
&& assoc.trait_container(tcx) == tcx.lang_items().coroutine_trait()
@@ -1322,7 +1322,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
p!(pretty_fn_sig(
tys,
false,
- proj.skip_binder().term.ty().expect("Return type was a const")
+ proj.skip_binder().term.as_type().expect("Return type was a const")
));
resugared = true;
}
diff --git a/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs b/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
index 48acf2a4e996e..98f98d9992d30 100644
--- a/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
@@ -726,7 +726,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReplaceProjectionWith<'_, 'tcx> {
)
.expect("expected to be able to unify goal projection with dyn's projection"),
);
- proj.term.ty().unwrap()
+ proj.term.expect_type()
} else {
ty.super_fold_with(self)
}
diff --git a/compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs b/compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs
index 67ec2f3be4814..82464470b2a29 100644
--- a/compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs
+++ b/compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs
@@ -17,7 +17,7 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
) -> QueryResult<'tcx> {
let tcx = self.interner();
let opaque_ty = goal.predicate.alias;
- let expected = goal.predicate.term.ty().expect("no such thing as an opaque const");
+ let expected = goal.predicate.term.as_type().expect("no such thing as an opaque const");
match (goal.param_env.reveal(), self.solver_mode()) {
(Reveal::UserFacing, SolverMode::Normal) => {
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
index 1ea207cc375fb..6623a86e69fff 100644
--- a/compiler/rustc_trait_selection/src/traits/auto_trait.rs
+++ b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -553,7 +553,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
}
fn is_self_referential_projection(&self, p: ty::PolyProjectionPredicate<'tcx>) -> bool {
- if let Some(ty) = p.term().skip_binder().ty() {
+ if let Some(ty) = p.term().skip_binder().as_type() {
matches!(ty.kind(), ty::Alias(ty::Projection, proj) if proj == &p.skip_binder().projection_term.expect_ty(self.tcx))
} else {
false
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
index 3ee3329517617..6a96a03e047f7 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -1112,7 +1112,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
{
Some((
DefIdOrName::DefId(def_id),
- pred.kind().rebind(proj.term.ty().unwrap()),
+ pred.kind().rebind(proj.term.expect_type()),
pred.kind().rebind(args.as_slice()),
))
} else {
@@ -1129,7 +1129,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
{
Some((
DefIdOrName::Name("trait object"),
- pred.rebind(proj.term.ty().unwrap()),
+ pred.rebind(proj.term.expect_type()),
pred.rebind(args.as_slice()),
))
} else {
@@ -1157,7 +1157,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
{
Some((
name,
- pred.kind().rebind(proj.term.ty().unwrap()),
+ pred.kind().rebind(proj.term.expect_type()),
pred.kind().rebind(args.as_slice()),
))
} else {
@@ -3840,7 +3840,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
})
} else if let Some(where_pred) = where_pred.as_projection_clause()
&& let Some(failed_pred) = failed_pred.as_projection_clause()
- && let Some(found) = failed_pred.skip_binder().term.ty()
+ && let Some(found) = failed_pred.skip_binder().term.as_type()
{
type_diffs = vec![Sorts(ty::error::ExpectedFound {
expected: where_pred
diff --git a/compiler/rustc_trait_selection/src/traits/normalize.rs b/compiler/rustc_trait_selection/src/traits/normalize.rs
index db30521d776a1..e7ab0b7791c43 100644
--- a/compiler/rustc_trait_selection/src/traits/normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/normalize.rs
@@ -259,7 +259,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
obligations.len = ?self.obligations.len(),
"AssocTypeNormalizer: normalized type"
);
- normalized_ty.ty().unwrap()
+ normalized_ty.expect_type()
}
ty::Projection => {
@@ -289,7 +289,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
)
.ok()
.flatten()
- .map(|term| term.ty().unwrap())
+ .map(|term| term.expect_type())
.map(|normalized_ty| {
PlaceholderReplacer::replace_placeholders(
infcx,
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index d513a5d2996c6..2b9c577e98949 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -946,7 +946,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// since we don't actually use them.
&mut vec![],
)
- .ty()
+ .as_type()
.unwrap();
if let ty::Dynamic(data, ..) = ty.kind() { data.principal() } else { None }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index f4189ff090204..066755f7b3e7c 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -286,7 +286,7 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
// implemented, but rather from a "second order" obligation, where an associated
// type has a projection coming from another associated type.
// See `tests/ui/traits/assoc-type-in-superbad.rs` for an example.
- if let Some(term_ty) = proj.term.ty()
+ if let Some(term_ty) = proj.term.as_type()
&& let Some(impl_item_span) = ty_to_impl_span(term_ty)
{
cause.span = impl_item_span;
diff --git a/compiler/rustc_traits/src/normalize_projection_ty.rs b/compiler/rustc_traits/src/normalize_projection_ty.rs
index b0a93b62dbf3c..0430e0bb70eb3 100644
--- a/compiler/rustc_traits/src/normalize_projection_ty.rs
+++ b/compiler/rustc_traits/src/normalize_projection_ty.rs
@@ -58,7 +58,7 @@ fn normalize_canonicalized_projection_ty<'tcx>(
// FIXME(associated_const_equality): All users of normalize_canonicalized_projection_ty
// expected a type, but there is the possibility it could've been a const now.
// Maybe change it to a Term later?
- Ok(NormalizationResult { normalized_ty: answer.ty().unwrap() })
+ Ok(NormalizationResult { normalized_ty: answer.expect_type() })
},
)
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs b/src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
index f4397212cf660..7f6b666e434e9 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
@@ -42,7 +42,7 @@ fn is_arg_ty_unified_in_fn<'tcx>(
cx.tcx.predicates_of(fn_id).predicates.iter().any(|(clause, _)| {
clause
.as_projection_clause()
- .and_then(|p| p.map_bound(|p| p.term.ty()).transpose())
+ .and_then(|p| p.map_bound(|p| p.term.as_type()).transpose())
.is_some_and(|ty| ty.skip_binder() == arg_ty_in_args)
}) || fn_sig
.inputs()
diff --git a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
index 5b5e1c2342455..4f99eaa40c29b 100644
--- a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -311,7 +311,7 @@ fn is_mixed_projection_predicate<'tcx>(
) -> bool {
let generics = cx.tcx.generics_of(callee_def_id);
// The predicate requires the projected type to equal a type parameter from the parent context.
- if let Some(term_ty) = projection_predicate.term.ty()
+ if let Some(term_ty) = projection_predicate.term.as_type()
&& let ty::Param(term_param_ty) = term_ty.kind()
&& (term_param_ty.index as usize) < generics.parent_count
{
@@ -370,7 +370,7 @@ fn replace_types<'tcx>(
if replaced.insert(param_ty.index) {
for projection_predicate in projection_predicates {
if projection_predicate.projection_term.self_ty() == param_ty.to_ty(cx.tcx)
- && let Some(term_ty) = projection_predicate.term.ty()
+ && let Some(term_ty) = projection_predicate.term.as_type()
&& let ty::Param(term_param_ty) = term_ty.kind()
{
let projection = projection_predicate
diff --git a/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs b/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs
index f0d1458a59b25..a8cc2f9796339 100644
--- a/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs
@@ -100,12 +100,12 @@ fn get_args_to_check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Ve
{
if ord_preds
.iter()
- .any(|ord| Some(ord.self_ty()) == return_ty_pred.term.ty())
+ .any(|ord| Some(ord.self_ty()) == return_ty_pred.term.as_type())
{
args_to_check.push((i, "Ord".to_string()));
} else if partial_ord_preds
.iter()
- .any(|pord| pord.self_ty() == return_ty_pred.term.ty().unwrap())
+ .any(|pord| pord.self_ty() == return_ty_pred.term.expect_type())
{
args_to_check.push((i, "PartialOrd".to_string()));
}
diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs
index 3414b5ef680c0..f0dac6f5d9c46 100644
--- a/src/tools/clippy/clippy_utils/src/ty.rs
+++ b/src/tools/clippy/clippy_utils/src/ty.rs
@@ -750,7 +750,7 @@ pub fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'t
let output = bounds
.projection_bounds()
.find(|p| lang_items.fn_once_output().map_or(false, |id| id == p.item_def_id()))
- .map(|p| p.map_bound(|p| p.term.ty().unwrap()));
+ .map(|p| p.map_bound(|p| p.term.expect_type()));
Some(ExprFnSig::Trait(bound.map_bound(|b| b.args.type_at(0)), output, None))
},
_ => None,
@@ -798,7 +798,7 @@ fn sig_from_bounds<'tcx>(
// Multiple different fn trait impls. Is this even allowed?
return None;
}
- output = Some(pred.kind().rebind(p.term.ty().unwrap()));
+ output = Some(pred.kind().rebind(p.term.expect_type()));
},
_ => (),
}
@@ -836,7 +836,7 @@ fn sig_for_projection<'tcx>(cx: &LateContext<'tcx>, ty: AliasTy<'tcx>) -> Option
// Multiple different fn trait impls. Is this even allowed?
return None;
}
- output = pred.kind().rebind(p.term.ty()).transpose();
+ output = pred.kind().rebind(p.term.as_type()).transpose();
},
_ => (),
}