Remove bool from hir::OpaqueDef.

Author: cjgillot

compiler/rustc_ast_lowering/src/lib.rs

@@ -1768,7 +1768,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // Foo = impl Trait` is, internally, created as a child of the
         // async fn, so the *type parameters* are inherited. It's
         // only the lifetime parameters that we must supply.
-        hir::TyKind::OpaqueDef(opaque_ty_def, generic_args, in_trait)
+        hir::TyKind::OpaqueDef(opaque_ty_def, generic_args)
     }
 
     fn lower_precise_capturing_args(

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -829,7 +829,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, '_, 'tcx> {
     ///
     /// [`OpaqueDef`]: hir::TyKind::OpaqueDef
     fn get_future_inner_return_ty(&self, hir_ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
-        let hir::TyKind::OpaqueDef(opaque_ty, _, _) = hir_ty.kind else {
+        let hir::TyKind::OpaqueDef(opaque_ty, _) = hir_ty.kind else {
             span_bug!(
                 hir_ty.span,
                 "lowered return type of async fn is not OpaqueDef: {:?}",

compiler/rustc_hir/src/hir.rs

@@ -2610,7 +2610,7 @@ impl<'hir> Ty<'hir> {
             }
             TyKind::Tup(tys) => tys.iter().any(Self::is_suggestable_infer_ty),
             TyKind::Ptr(mut_ty) | TyKind::Ref(_, mut_ty) => mut_ty.ty.is_suggestable_infer_ty(),
-            TyKind::OpaqueDef(_, generic_args, _) => are_suggestable_generic_args(generic_args),
+            TyKind::OpaqueDef(_, generic_args) => are_suggestable_generic_args(generic_args),
             TyKind::Path(QPath::TypeRelative(ty, segment)) => {
                 ty.is_suggestable_infer_ty() || are_suggestable_generic_args(segment.args().args)
             }
@@ -2837,7 +2837,7 @@ pub enum TyKind<'hir> {
     /// possibly parameters) that are actually bound on the `impl Trait`.
     ///
     /// The last parameter specifies whether this opaque appears in a trait definition.
-    OpaqueDef(&'hir OpaqueTy<'hir>, &'hir [GenericArg<'hir>], bool),
+    OpaqueDef(&'hir OpaqueTy<'hir>, &'hir [GenericArg<'hir>]),
     /// A trait object type `Bound1 + Bound2 + Bound3`
     /// where `Bound` is a trait or a lifetime.
     TraitObject(

compiler/rustc_hir/src/intravisit.rs

@@ -896,7 +896,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) -> V::Resul
         TyKind::Path(ref qpath) => {
             try_visit!(visitor.visit_qpath(qpath, typ.hir_id, typ.span));
         }
-        TyKind::OpaqueDef(opaque, lifetimes, _in_trait) => {
+        TyKind::OpaqueDef(opaque, lifetimes) => {
             try_visit!(visitor.visit_opaque_ty(opaque));
             walk_list!(visitor, visit_generic_arg, lifetimes);
         }

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -317,7 +317,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
     // and the duplicated parameter, to ensure that they do not get out of sync.
     if let Node::OpaqueTy(..) = node {
         let opaque_ty_node = tcx.parent_hir_node(hir_id);
-        let Node::Ty(&hir::Ty { kind: TyKind::OpaqueDef(_, lifetimes, _), .. }) = opaque_ty_node
+        let Node::Ty(&hir::Ty { kind: TyKind::OpaqueDef(_, lifetimes), .. }) = opaque_ty_node
         else {
             bug!("unexpected {opaque_ty_node:?}")
         };

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -682,7 +682,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                 };
                 self.with(scope, |this| this.visit_ty(mt.ty));
             }
-            hir::TyKind::OpaqueDef(opaque_ty, lifetimes, _in_trait) => {
+            hir::TyKind::OpaqueDef(opaque_ty, lifetimes) => {
                 self.visit_opaque_ty(opaque_ty);
 
                 // Resolve the lifetimes in the bounds to the lifetime defs in the generics.

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2082,17 +2082,17 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.lower_ty(qself));
                 self.lower_path(opt_self_ty, path, hir_ty.hir_id, false)
             }
-            &hir::TyKind::OpaqueDef(opaque_ty, lifetimes, in_trait) => {
+            &hir::TyKind::OpaqueDef(opaque_ty, lifetimes) => {
                 let local_def_id = opaque_ty.def_id;
                 // If this is an RPITIT and we are using the new RPITIT lowering scheme, we
                 // generate the def_id of an associated type for the trait and return as
                 // type a projection.
-                let def_id = if in_trait {
+                let def_id = if opaque_ty.in_trait {
                     tcx.associated_type_for_impl_trait_in_trait(local_def_id).to_def_id()
                 } else {
                     local_def_id.to_def_id()
                 };
-                self.lower_opaque_ty(def_id, lifetimes, in_trait)
+                self.lower_opaque_ty(def_id, lifetimes, opaque_ty.in_trait)
             }
             hir::TyKind::Path(hir::QPath::TypeRelative(qself, segment)) => {
                 debug!(?qself, ?segment);

compiler/rustc_lint/src/non_local_def.rs

@@ -445,7 +445,7 @@ fn ty_has_local_parent(
         | TyKind::Path(_)
         | TyKind::Pat(..)
         | TyKind::AnonAdt(_)
-        | TyKind::OpaqueDef(_, _, _)
+        | TyKind::OpaqueDef(_, _)
         | TyKind::Typeof(_)
         | TyKind::Infer
         | TyKind::Err(_) => false,

compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs

@@ -69,7 +69,7 @@ declare_lint_pass!(OpaqueHiddenInferredBound => [OPAQUE_HIDDEN_INFERRED_BOUND]);
 
 impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound {
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx hir::Ty<'tcx>) {
-        let hir::TyKind::OpaqueDef(opaque, _, _) = &ty.kind else {
+        let hir::TyKind::OpaqueDef(opaque, _) = &ty.kind else {
             return;
         };
         let def_id = opaque.def_id.to_def_id();

compiler/rustc_middle/src/ty/diagnostics.rs

@@ -510,7 +510,7 @@ impl<'v> hir::intravisit::Visitor<'v> for TraitObjectVisitor<'v> {
             ) => {
                 self.0.push(ty);
             }
-            hir::TyKind::OpaqueDef(opaq, _, _) => {
+            hir::TyKind::OpaqueDef(opaq, _) => {
                 self.0.push(ty);
                 hir::intravisit::walk_opaque_ty(self, opaq);
             }

compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs

@@ -283,7 +283,7 @@ pub fn suggest_new_region_bound(
         }
         match fn_return.kind {
             // FIXME(precise_captures): Suggest adding to `use<...>` list instead.
-            TyKind::OpaqueDef(opaque, _, _) => {
+            TyKind::OpaqueDef(opaque, _) => {
                 // Get the identity type for this RPIT
                 let did = opaque.def_id.to_def_id();
                 let ty = Ty::new_opaque(tcx, did, ty::GenericArgs::identity_for_item(tcx, did));

compiler/rustc_trait_selection/src/error_reporting/infer/region.rs

@@ -838,7 +838,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             }
 
             fn visit_ty(&mut self, ty: &'hir hir::Ty<'hir>) {
-                let hir::TyKind::OpaqueDef(opaque_ty, _, _) = ty.kind else {
+                let hir::TyKind::OpaqueDef(opaque_ty, _) = ty.kind else {
                     return hir::intravisit::walk_ty(self, ty);
                 };
                 if let Some(&(_, b)) =

compiler/rustc_ty_utils/src/assoc.rs

@@ -322,7 +322,7 @@ fn associated_types_for_impl_traits_in_associated_fn(
 
             impl<'tcx> Visitor<'tcx> for RPITVisitor {
                 fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx>) {
-                    if let hir::TyKind::OpaqueDef(opaq, _, _) = ty.kind
+                    if let hir::TyKind::OpaqueDef(opaq, _) = ty.kind
                         && self.rpits.insert(opaq.def_id)
                     {
                         for bound in opaq.bounds {

src/librustdoc/clean/mod.rs

@@ -1841,7 +1841,7 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
             Array(Box::new(clean_ty(ty, cx)), length.into())
         }
         TyKind::Tup(tys) => Tuple(tys.iter().map(|ty| clean_ty(ty, cx)).collect()),
-        TyKind::OpaqueDef(ty, _, _) => {
+        TyKind::OpaqueDef(ty, _) => {
             ImplTrait(ty.bounds.iter().filter_map(|x| clean_generic_bound(x, cx)).collect())
         }
         TyKind::Path(_) => clean_qpath(ty, cx),