Align Term methods with GenericArg methods

compiler-errors · compiler-errors · commit 129b63365b8b · 2024-05-29T22:18:54.000-04:00
diff --git 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
@@ -2250,7 +2250,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
@@ -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
@@ -436,7 +436,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
@@ -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
@@ -158,7 +158,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
@@ -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
@@ -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
@@ -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
@@ -626,14 +626,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
@@ -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
@@ -743,7 +743,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
@@ -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
@@ -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
@@ -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 {
@@ -3844,7 +3844,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
@@ -253,7 +253,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 => {
@@ -283,7 +283,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
@@ -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
@@ -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
@@ -60,7 +60,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/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs
@@ -100,7 +100,7 @@ pub(crate) fn merge_bounds(
                 Some(o) => assert_eq!(&clean::Term::Type(o.as_ref().clone()), rhs),
                 None => {
                     if *rhs != clean::Term::Type(clean::Type::Tuple(Vec::new())) {
-                        *output = Some(Box::new(rhs.ty().unwrap().clone()));
+                        *output = Some(Box::new(rhs.expect_ty().clone()));
                     }
                 }
             },
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
@@ -105,7 +105,7 @@ fn get_args_to_check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Ve
                             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_ty())
                         {
                             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
@@ -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_ty()));
                     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_ty()));
             },
             _ => (),
         }
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast.rs b/src/tools/rust-analyzer/crates/syntax/src/ast.rs
@@ -383,7 +383,7 @@ where
 
     assert!(pred.for_token().is_none());
     assert!(pred.generic_param_list().is_none());
-    assert_eq!("T", pred.ty().unwrap().syntax().text().to_string());
+    assert_eq!("T", pred.expect_ty().syntax().text().to_string());
     assert_bound("Clone", bounds.next());
     assert_bound("Copy", bounds.next());
     assert_bound("Debug", bounds.next());
@@ -400,20 +400,20 @@ where
     let pred = predicates.next().unwrap();
     let mut bounds = pred.type_bound_list().unwrap().bounds();
 
-    assert_eq!("Iterator::Item", pred.ty().unwrap().syntax().text().to_string());
+    assert_eq!("Iterator::Item", pred.expect_ty().syntax().text().to_string());
     assert_bound("'a", bounds.next());
 
     let pred = predicates.next().unwrap();
     let mut bounds = pred.type_bound_list().unwrap().bounds();
 
-    assert_eq!("Iterator::Item", pred.ty().unwrap().syntax().text().to_string());
+    assert_eq!("Iterator::Item", pred.expect_ty().syntax().text().to_string());
     assert_bound("Debug", bounds.next());
     assert_bound("'a", bounds.next());
 
     let pred = predicates.next().unwrap();
     let mut bounds = pred.type_bound_list().unwrap().bounds();
 
-    assert_eq!("<T as Iterator>::Item", pred.ty().unwrap().syntax().text().to_string());
+    assert_eq!("<T as Iterator>::Item", pred.expect_ty().syntax().text().to_string());
     assert_bound("Debug", bounds.next());
     assert_bound("'a", bounds.next());
 
@@ -422,6 +422,6 @@ where
 
     assert!(pred.for_token().is_some());
     assert_eq!("<'a>", pred.generic_param_list().unwrap().syntax().text().to_string());
-    assert_eq!("F", pred.ty().unwrap().syntax().text().to_string());
+    assert_eq!("F", pred.expect_ty().syntax().text().to_string());
     assert_bound("Fn(&'a str)", bounds.next());
 }

Original file line number	Diff line number	Diff line change
`@@ -2250,7 +2250,7 @@ fn try_report_async_mismatch<'tcx>(`
`2250`	`2250`	`&& let Some(proj) = proj.no_bound_vars()`
`2251`	`2251`	`&& infcx.can_eq(`
`2252`	`2252`	`error.root_obligation.param_env,`
`2253`		`- proj.term.ty().unwrap(),`
	`2253`	`+ proj.term.expect_type(),`
`2254`	`2254`	`impl_sig.output(),`
`2255`	`2255`	`)`
`2256`	`2256`	`{`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ impl<'tcx> TypeckRootCtxt<'tcx> {`
`158`	`158`	`{`
`159`	`159`	`// If the projection predicate (Foo::Bar == X) has X as a non-TyVid,`
`160`	`160`	`// we need to make it into one.`
`161`		`- if let Some(vid) = predicate.term.ty().and_then(\|ty\| ty.ty_vid()) {`
	`161`	`+ if let Some(vid) = predicate.term.as_type().and_then(\|ty\| ty.ty_vid()) {`
`162`	`162`	`debug!("infer_var_info: {:?}.output = true", vid);`
`163`	`163`	`infer_var_info.entry(vid).or_default().output = true;`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -425,7 +425,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`425`	`425`	`ty::ClauseKind::Projection(projection_predicate)`
`426`	`426`	`if projection_predicate.projection_term.def_id == item_def_id =>`
`427`	`427`	`{`
`428`		`- projection_predicate.term.ty()`
	`428`	`+ projection_predicate.term.as_type()`
`429`	`429`	`}`
`430`	`430`	`_ => None,`
`431`	`431`	`})`
Original file line number	Diff line number	Diff line change
`@@ -626,14 +626,22 @@ impl<'tcx> Term<'tcx> {`
`626`	`626`	`}`
`627`	`627`	`}`
`628`	`628`
`629`		`- pub fn ty(&self) -> Option<Ty<'tcx>> {`
	`629`	`+ pub fn as_type(&self) -> Option<Ty<'tcx>> {`
`630`	`630`	`if let TermKind::Ty(ty) = self.unpack() { Some(ty) } else { None }`
`631`	`631`	`}`
`632`	`632`
`633`		`- pub fn ct(&self) -> Option<Const<'tcx>> {`
	`633`	`+ pub fn expect_type(&self) -> Ty<'tcx> {`
	`634`	`+ self.as_type().expect("expected a type, but found a const")`
	`635`	`+ }`
	`636`	`+`
	`637`	`+ pub fn as_const(&self) -> Option<Const<'tcx>> {`
`634`	`638`	`if let TermKind::Const(c) = self.unpack() { Some(c) } else { None }`
`635`	`639`	`}`
`636`	`640`
	`641`	`+ pub fn expect_const(&self) -> Const<'tcx> {`
	`642`	`+ self.as_const().expect("expected a const, but found a type")`
	`643`	`+ }`
	`644`	`+`
`637`	`645`	`pub fn into_arg(self) -> GenericArg<'tcx> {`
`638`	`646`	`match self.unpack() {`
`639`	`647`	`TermKind::Ty(ty) => ty.into(),`
Original file line number	Diff line number	Diff line change
`@@ -743,7 +743,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReplaceProjectionWith<'_, 'tcx> {`
`743`	`743`	`)`
`744`	`744`	`.expect("expected to be able to unify goal projection with dyn's projection"),`
`745`	`745`	`);`
`746`		`- proj.term.ty().unwrap()`
	`746`	`+ proj.term.expect_type()`
`747`	`747`	`} else {`
`748`	`748`	`ty.super_fold_with(self)`
`749`	`749`	`}`
Original file line number	Diff line number	Diff line change
`@@ -553,7 +553,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {`
`553`	`553`	`}`
`554`	`554`
`555`	`555`	`fn is_self_referential_projection(&self, p: ty::PolyProjectionPredicate<'tcx>) -> bool {`
`556`		`- if let Some(ty) = p.term().skip_binder().ty() {`
	`556`	`+ if let Some(ty) = p.term().skip_binder().as_type() {`
`557`	`557`	`matches!(ty.kind(), ty::Alias(ty::Projection, proj) if proj == &p.skip_binder().projection_term.expect_ty(self.tcx))`
`558`	`558`	`} else {`
`559`	`559`	`false`
Original file line number	Diff line number	Diff line change
`@@ -946,7 +946,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`946`	`946`	`// since we don't actually use them.`
`947`	`947`	`&mut vec![],`
`948`	`948`	`)`
`949`		`- .ty()`
	`949`	`+ .as_type()`
`950`	`950`	`.unwrap();`
`951`	`951`
`952`	`952`	`if let ty::Dynamic(data, ..) = ty.kind() { data.principal() } else { None }`
Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,7 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(`
`286`	`286`	`// implemented, but rather from a "second order" obligation, where an associated`
`287`	`287`	`// type has a projection coming from another associated type.`
`288`	`288`	// See `tests/ui/traits/assoc-type-in-superbad.rs` for an example.
`289`		`- if let Some(term_ty) = proj.term.ty()`
	`289`	`+ if let Some(term_ty) = proj.term.as_type()`
`290`	`290`	`&& let Some(impl_item_span) = ty_to_impl_span(term_ty)`
`291`	`291`	`{`
`292`	`292`	`cause.span = impl_item_span;`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ fn normalize_canonicalized_projection_ty<'tcx>(`
`60`	`60`	`// FIXME(associated_const_equality): All users of normalize_canonicalized_projection_ty`
`61`	`61`	`// expected a type, but there is the possibility it could've been a const now.`
`62`	`62`	`// Maybe change it to a Term later?`
`63`		`- Ok(NormalizationResult { normalized_ty: answer.ty().unwrap() })`
	`63`	`+ Ok(NormalizationResult { normalized_ty: answer.expect_type() })`
`64`	`64`	`},`
`65`	`65`	`)`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ pub(crate) fn merge_bounds(`
`100`	`100`	`Some(o) => assert_eq!(&clean::Term::Type(o.as_ref().clone()), rhs),`
`101`	`101`	`None => {`
`102`	`102`	`if *rhs != clean::Term::Type(clean::Type::Tuple(Vec::new())) {`
`103`		`- *output = Some(Box::new(rhs.ty().unwrap().clone()));`
	`103`	`+ *output = Some(Box::new(rhs.expect_ty().clone()));`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`	`},`