compiler/rustc_hir_analysis/src/collect/type_of.rs

   1 use rustc_errors::{Applicability, StashKey};
   2 use rustc_hir as hir;
   3 use rustc_hir::def_id::{DefId, LocalDefId};
   4 use rustc_hir::intravisit;
   5 use rustc_hir::intravisit::Visitor;
   6 use rustc_hir::{HirId, Node};
   7 use rustc_middle::hir::nested_filter;
   8 use rustc_middle::ty::subst::InternalSubsts;
   9 use rustc_middle::ty::util::IntTypeExt;
  10 use rustc_middle::ty::{self, DefIdTree, Ty, TyCtxt, TypeFolder, TypeSuperFoldable, TypeVisitable};
  11 use rustc_span::symbol::Ident;
  12 use rustc_span::{Span, DUMMY_SP};
  13
  14 use super::ItemCtxt;
  15 use super::{bad_placeholder, is_suggestable_infer_ty};
  16 use crate::errors::UnconstrainedOpaqueType;
  17
  18 /// Computes the relevant generic parameter for a potential generic const argument.
  19 ///
  20 /// This should be called using the query `tcx.opt_const_param_of`.
  21 pub(super) fn opt_const_param_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<DefId> {
  22     use hir::*;
  23     let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
  24
  25     match tcx.hir().get(hir_id) {
  26         Node::AnonConst(_) => (),
  27         _ => return None,
  28     };
  29
  30     let parent_node_id = tcx.hir().get_parent_node(hir_id);
  31     let parent_node = tcx.hir().get(parent_node_id);
  32
  33     let (generics, arg_idx) = match parent_node {
  34         // This match arm is for when the def_id appears in a GAT whose
  35         // path can't be resolved without typechecking e.g.
  36         //
  37         // trait Foo {
  38         //   type Assoc<const N: usize>;
  39         //   fn foo() -> Self::Assoc<3>;
  40         // }
  41         //
  42         // In the above code we would call this query with the def_id of 3 and
  43         // the parent_node we match on would be the hir node for Self::Assoc<3>
  44         //
  45         // `Self::Assoc<3>` cant be resolved without typechecking here as we
  46         // didnt write <Self as Foo>::Assoc<3>. If we did then another match
  47         // arm would handle this.
  48         //
  49         // I believe this match arm is only needed for GAT but I am not 100% sure - BoxyUwU
  50         Node::Ty(hir_ty @ Ty { kind: TyKind::Path(QPath::TypeRelative(_, segment)), .. }) => {
  51             // Find the Item containing the associated type so we can create an ItemCtxt.
  52             // Using the ItemCtxt convert the HIR for the unresolved assoc type into a
  53             // ty which is a fully resolved projection.
  54             // For the code example above, this would mean converting Self::Assoc<3>
  55             // into a ty::Projection(<Self as Foo>::Assoc<3>)
  56             let item_hir_id = tcx
  57                 .hir()
  58                 .parent_iter(hir_id)
  59                 .filter(|(_, node)| matches!(node, Node::Item(_)))
  60                 .map(|(id, _)| id)
  61                 .next()
  62                 .unwrap();
  63             let item_did = tcx.hir().local_def_id(item_hir_id).to_def_id();
  64             let item_ctxt = &ItemCtxt::new(tcx, item_did) as &dyn crate::astconv::AstConv<'_>;
  65             let ty = item_ctxt.ast_ty_to_ty(hir_ty);
  66
  67             // Iterate through the generics of the projection to find the one that corresponds to
  68             // the def_id that this query was called with. We filter to only type and const args here
  69             // as a precaution for if it's ever allowed to elide lifetimes in GAT's. It currently isn't
  70             // but it can't hurt to be safe ^^
  71             if let ty::Projection(projection) = ty.kind() {
  72                 let generics = tcx.generics_of(projection.item_def_id);
  73
  74                 let arg_index = segment
  75                     .args
  76                     .and_then(|args| {
  77                         args.args
  78                             .iter()
  79                             .filter(|arg| arg.is_ty_or_const())
  80                             .position(|arg| arg.hir_id() == hir_id)
  81                     })
  82                     .unwrap_or_else(|| {
  83                         bug!("no arg matching AnonConst in segment");
  84                     });
  85
  86                 (generics, arg_index)
  87             } else {
  88                 // I dont think it's possible to reach this but I'm not 100% sure - BoxyUwU
  89                 tcx.sess.delay_span_bug(
  90                     tcx.def_span(def_id),
  91                     "unexpected non-GAT usage of an anon const",
  92                 );
  93                 return None;
  94             }
  95         }
  96         Node::Expr(&Expr {
  97             kind:
  98                 ExprKind::MethodCall(segment, ..) | ExprKind::Path(QPath::TypeRelative(_, segment)),
  99             ..
 100         }) => {
 101             let body_owner = tcx.hir().enclosing_body_owner(hir_id);
 102             let tables = tcx.typeck(body_owner);
 103             // This may fail in case the method/path does not actually exist.
 104             // As there is no relevant param for `def_id`, we simply return
 105             // `None` here.
 106             let type_dependent_def = tables.type_dependent_def_id(parent_node_id)?;
 107             let idx = segment
 108                 .args
 109                 .and_then(|args| {
 110                     args.args
 111                         .iter()
 112                         .filter(|arg| arg.is_ty_or_const())
 113                         .position(|arg| arg.hir_id() == hir_id)
 114                 })
 115                 .unwrap_or_else(|| {
 116                     bug!("no arg matching AnonConst in segment");
 117                 });
 118
 119             (tcx.generics_of(type_dependent_def), idx)
 120         }
 121
 122         Node::Ty(&Ty { kind: TyKind::Path(_), .. })
 123         | Node::Expr(&Expr { kind: ExprKind::Path(_) | ExprKind::Struct(..), .. })
 124         | Node::TraitRef(..)
 125         | Node::Pat(_) => {
 126             let path = match parent_node {
 127                 Node::Ty(&Ty { kind: TyKind::Path(QPath::Resolved(_, path)), .. })
 128                 | Node::TraitRef(&TraitRef { path, .. }) => &*path,
 129                 Node::Expr(&Expr {
 130                     kind:
 131                         ExprKind::Path(QPath::Resolved(_, path))
 132                         | ExprKind::Struct(&QPath::Resolved(_, path), ..),
 133                     ..
 134                 }) => {
 135                     let body_owner = tcx.hir().enclosing_body_owner(hir_id);
 136                     let _tables = tcx.typeck(body_owner);
 137                     &*path
 138                 }
 139                 Node::Pat(pat) => {
 140                     if let Some(path) = get_path_containing_arg_in_pat(pat, hir_id) {
 141                         path
 142                     } else {
 143                         tcx.sess.delay_span_bug(
 144                             tcx.def_span(def_id),
 145                             &format!("unable to find const parent for {} in pat {:?}", hir_id, pat),
 146                         );
 147                         return None;
 148                     }
 149                 }
 150                 _ => {
 151                     tcx.sess.delay_span_bug(
 152                         tcx.def_span(def_id),
 153                         &format!("unexpected const parent path {:?}", parent_node),
 154                     );
 155                     return None;
 156                 }
 157             };
 158
 159             // We've encountered an `AnonConst` in some path, so we need to
 160             // figure out which generic parameter it corresponds to and return
 161             // the relevant type.
 162             let Some((arg_index, segment)) = path.segments.iter().find_map(|seg| {
 163                 let args = seg.args?;
 164                 args.args
 165                 .iter()
 166                 .filter(|arg| arg.is_ty_or_const())
 167                 .position(|arg| arg.hir_id() == hir_id)
 168                 .map(|index| (index, seg)).or_else(|| args.bindings
 169                     .iter()
 170                     .filter_map(TypeBinding::opt_const)
 171                     .position(|ct| ct.hir_id == hir_id)
 172                     .map(|idx| (idx, seg)))
 173             }) else {
 174                 tcx.sess.delay_span_bug(
 175                     tcx.def_span(def_id),
 176                     "no arg matching AnonConst in path",
 177                 );
 178                 return None;
 179             };
 180
 181             let generics = match tcx.res_generics_def_id(segment.res) {
 182                 Some(def_id) => tcx.generics_of(def_id),
 183                 None => {
 184                     tcx.sess.delay_span_bug(
 185                         tcx.def_span(def_id),
 186                         &format!("unexpected anon const res {:?} in path: {:?}", segment.res, path),
 187                     );
 188                     return None;
 189                 }
 190             };
 191
 192             (generics, arg_index)
 193         }
 194         _ => return None,
 195     };
 196
 197     debug!(?parent_node);
 198     debug!(?generics, ?arg_idx);
 199     generics
 200         .params
 201         .iter()
 202         .filter(|param| param.kind.is_ty_or_const())
 203         .nth(match generics.has_self && generics.parent.is_none() {
 204             true => arg_idx + 1,
 205             false => arg_idx,
 206         })
 207         .and_then(|param| match param.kind {
 208             ty::GenericParamDefKind::Const { .. } => {
 209                 debug!(?param);
 210                 Some(param.def_id)
 211             }
 212             _ => None,
 213         })
 214 }
 215
 216 fn get_path_containing_arg_in_pat<'hir>(
 217     pat: &'hir hir::Pat<'hir>,
 218     arg_id: HirId,
 219 ) -> Option<&'hir hir::Path<'hir>> {
 220     use hir::*;
 221
 222     let is_arg_in_path = |p: &hir::Path<'_>| {
 223         p.segments
 224             .iter()
 225             .filter_map(|seg| seg.args)
 226             .flat_map(|args| args.args)
 227             .any(|arg| arg.hir_id() == arg_id)
 228     };
 229     let mut arg_path = None;
 230     pat.walk(|pat| match pat.kind {
 231         PatKind::Struct(QPath::Resolved(_, path), _, _)
 232         | PatKind::TupleStruct(QPath::Resolved(_, path), _, _)
 233         | PatKind::Path(QPath::Resolved(_, path))
 234             if is_arg_in_path(path) =>
 235         {
 236             arg_path = Some(path);
 237             false
 238         }
 239         _ => true,
 240     });
 241     arg_path
 242 }
 243
 244 pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
 245     let def_id = def_id.expect_local();
 246     use rustc_hir::*;
 247
 248     let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
 249
 250     let icx = ItemCtxt::new(tcx, def_id.to_def_id());
 251
 252     match tcx.hir().get(hir_id) {
 253         Node::TraitItem(item) => match item.kind {
 254             TraitItemKind::Fn(..) => {
 255                 let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
 256                 tcx.mk_fn_def(def_id.to_def_id(), substs)
 257             }
 258             TraitItemKind::Const(ty, body_id) => body_id
 259                 .and_then(|body_id| {
 260                     if is_suggestable_infer_ty(ty) {
 261                         Some(infer_placeholder_type(
 262                             tcx, def_id, body_id, ty.span, item.ident, "constant",
 263                         ))
 264                     } else {
 265                         None
 266                     }
 267                 })
 268                 .unwrap_or_else(|| icx.to_ty(ty)),
 269             TraitItemKind::Type(_, Some(ty)) => icx.to_ty(ty),
 270             TraitItemKind::Type(_, None) => {
 271                 span_bug!(item.span, "associated type missing default");
 272             }
 273         },
 274
 275         Node::ImplItem(item) => match item.kind {
 276             ImplItemKind::Fn(..) => {
 277                 let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
 278                 tcx.mk_fn_def(def_id.to_def_id(), substs)
 279             }
 280             ImplItemKind::Const(ty, body_id) => {
 281                 if is_suggestable_infer_ty(ty) {
 282                     infer_placeholder_type(tcx, def_id, body_id, ty.span, item.ident, "constant")
 283                 } else {
 284                     icx.to_ty(ty)
 285                 }
 286             }
 287             ImplItemKind::Type(ty) => {
 288                 if tcx.impl_trait_ref(tcx.hir().get_parent_item(hir_id)).is_none() {
 289                     check_feature_inherent_assoc_ty(tcx, item.span);
 290                 }
 291
 292                 icx.to_ty(ty)
 293             }
 294         },
 295
 296         Node::Item(item) => {
 297             match item.kind {
 298                 ItemKind::Static(ty, .., body_id) => {
 299                     if is_suggestable_infer_ty(ty) {
 300                         infer_placeholder_type(
 301                             tcx,
 302                             def_id,
 303                             body_id,
 304                             ty.span,
 305                             item.ident,
 306                             "static variable",
 307                         )
 308                     } else {
 309                         icx.to_ty(ty)
 310                     }
 311                 }
 312                 ItemKind::Const(ty, body_id) => {
 313                     if is_suggestable_infer_ty(ty) {
 314                         infer_placeholder_type(
 315                             tcx, def_id, body_id, ty.span, item.ident, "constant",
 316                         )
 317                     } else {
 318                         icx.to_ty(ty)
 319                     }
 320                 }
 321                 ItemKind::TyAlias(self_ty, _) => icx.to_ty(self_ty),
 322                 ItemKind::Impl(hir::Impl { self_ty, .. }) => {
 323                     match self_ty.find_self_aliases() {
 324                         spans if spans.len() > 0 => {
 325                             tcx.sess.emit_err(crate::errors::SelfInImplSelf { span: spans.into(), note: (), });
 326                             tcx.ty_error()
 327                         },
 328                         _ => icx.to_ty(*self_ty),
 329                     }
 330                 },
 331                 ItemKind::Fn(..) => {
 332                     let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
 333                     tcx.mk_fn_def(def_id.to_def_id(), substs)
 334                 }
 335                 ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) => {
 336                     let def = tcx.adt_def(def_id);
 337                     let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
 338                     tcx.mk_adt(def, substs)
 339                 }
 340                 ItemKind::OpaqueTy(OpaqueTy { origin: hir::OpaqueTyOrigin::TyAlias, .. }) => {
 341                     find_opaque_ty_constraints_for_tait(tcx, def_id)
 342                 }
 343                 // Opaque types desugared from `impl Trait`.
 344                 ItemKind::OpaqueTy(OpaqueTy {
 345                     origin:
 346                         hir::OpaqueTyOrigin::FnReturn(owner) | hir::OpaqueTyOrigin::AsyncFn(owner),
 347                     in_trait,
 348                     ..
 349                 }) => {
 350                     if in_trait {
 351                         assert!(tcx.impl_defaultness(owner).has_value());
 352                     }
 353                     find_opaque_ty_constraints_for_rpit(tcx, def_id, owner)
 354                 }
 355                 ItemKind::Trait(..)
 356                 | ItemKind::TraitAlias(..)
 357                 | ItemKind::Macro(..)
 358                 | ItemKind::Mod(..)
 359                 | ItemKind::ForeignMod { .. }
 360                 | ItemKind::GlobalAsm(..)
 361                 | ItemKind::ExternCrate(..)
 362                 | ItemKind::Use(..) => {
 363                     span_bug!(
 364                         item.span,
 365                         "compute_type_of_item: unexpected item type: {:?}",
 366                         item.kind
 367                     );
 368                 }
 369             }
 370         }
 371
 372         Node::ForeignItem(foreign_item) => match foreign_item.kind {
 373             ForeignItemKind::Fn(..) => {
 374                 let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
 375                 tcx.mk_fn_def(def_id.to_def_id(), substs)
 376             }
 377             ForeignItemKind::Static(t, _) => icx.to_ty(t),
 378             ForeignItemKind::Type => tcx.mk_foreign(def_id.to_def_id()),
 379         },
 380
 381         Node::Ctor(&ref def) | Node::Variant(Variant { data: ref def, .. }) => match *def {
 382             VariantData::Unit(..) | VariantData::Struct(..) => {
 383                 tcx.type_of(tcx.hir().get_parent_item(hir_id))
 384             }
 385             VariantData::Tuple(..) => {
 386                 let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
 387                 tcx.mk_fn_def(def_id.to_def_id(), substs)
 388             }
 389         },
 390
 391         Node::Field(field) => icx.to_ty(field.ty),
 392
 393         Node::Expr(&Expr { kind: ExprKind::Closure { .. }, .. }) => {
 394             tcx.typeck(def_id).node_type(hir_id)
 395         }
 396
 397         Node::AnonConst(_) if let Some(param) = tcx.opt_const_param_of(def_id) => {
 398             // We defer to `type_of` of the corresponding parameter
 399             // for generic arguments.
 400             tcx.type_of(param)
 401         }
 402
 403         Node::AnonConst(_) => {
 404             let parent_node = tcx.hir().get(tcx.hir().get_parent_node(hir_id));
 405             match parent_node {
 406                 Node::Ty(&Ty { kind: TyKind::Array(_, ref constant), .. })
 407                 | Node::Expr(&Expr { kind: ExprKind::Repeat(_, ref constant), .. })
 408                     if constant.hir_id() == hir_id =>
 409                 {
 410                     tcx.types.usize
 411                 }
 412                 Node::Ty(&Ty { kind: TyKind::Typeof(ref e), .. }) if e.hir_id == hir_id => {
 413                     tcx.typeck(def_id).node_type(e.hir_id)
 414                 }
 415
 416                 Node::Expr(&Expr { kind: ExprKind::ConstBlock(ref anon_const), .. })
 417                     if anon_const.hir_id == hir_id =>
 418                 {
 419                     let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
 420                     substs.as_inline_const().ty()
 421                 }
 422
 423                 Node::Expr(&Expr { kind: ExprKind::InlineAsm(asm), .. })
 424                 | Node::Item(&Item { kind: ItemKind::GlobalAsm(asm), .. })
 425                     if asm.operands.iter().any(|(op, _op_sp)| match op {
 426                         hir::InlineAsmOperand::Const { anon_const }
 427                         | hir::InlineAsmOperand::SymFn { anon_const } => {
 428                             anon_const.hir_id == hir_id
 429                         }
 430                         _ => false,
 431                     }) =>
 432                 {
 433                     tcx.typeck(def_id).node_type(hir_id)
 434                 }
 435
 436                 Node::Variant(Variant { disr_expr: Some(ref e), .. }) if e.hir_id == hir_id => {
 437                     tcx.adt_def(tcx.hir().get_parent_item(hir_id)).repr().discr_type().to_ty(tcx)
 438                 }
 439
 440                 Node::TypeBinding(
 441                     binding @ &TypeBinding {
 442                         hir_id: binding_id,
 443                         kind: TypeBindingKind::Equality { term: Term::Const(ref e) },
 444                         ..
 445                     },
 446                 ) if let Node::TraitRef(trait_ref) =
 447                     tcx.hir().get(tcx.hir().get_parent_node(binding_id))
 448                     && e.hir_id == hir_id =>
 449                 {
 450                     let Some(trait_def_id) = trait_ref.trait_def_id() else {
 451                         return tcx.ty_error_with_message(DUMMY_SP, "Could not find trait");
 452                     };
 453                     let assoc_items = tcx.associated_items(trait_def_id);
 454                     let assoc_item = assoc_items.find_by_name_and_kind(
 455                         tcx,
 456                         binding.ident,
 457                         ty::AssocKind::Const,
 458                         def_id.to_def_id(),
 459                     );
 460                     if let Some(assoc_item) = assoc_item {
 461                         tcx.type_of(assoc_item.def_id)
 462                     } else {
 463                         // FIXME(associated_const_equality): add a useful error message here.
 464                         tcx.ty_error_with_message(
 465                             DUMMY_SP,
 466                             "Could not find associated const on trait",
 467                         )
 468                     }
 469                 }
 470
 471                 Node::TypeBinding(
 472                     binding @ &TypeBinding { hir_id: binding_id, gen_args, ref kind, .. },
 473                 ) if let Node::TraitRef(trait_ref) =
 474                     tcx.hir().get(tcx.hir().get_parent_node(binding_id))
 475                     && let Some((idx, _)) =
 476                         gen_args.args.iter().enumerate().find(|(_, arg)| {
 477                             if let GenericArg::Const(ct) = arg {
 478                                 ct.value.hir_id == hir_id
 479                             } else {
 480                                 false
 481                             }
 482                         }) =>
 483                 {
 484                     let Some(trait_def_id) = trait_ref.trait_def_id() else {
 485                         return tcx.ty_error_with_message(DUMMY_SP, "Could not find trait");
 486                     };
 487                     let assoc_items = tcx.associated_items(trait_def_id);
 488                     let assoc_item = assoc_items.find_by_name_and_kind(
 489                         tcx,
 490                         binding.ident,
 491                         match kind {
 492                             // I think `<A: T>` type bindings requires that `A` is a type
 493                             TypeBindingKind::Constraint { .. }
 494                             | TypeBindingKind::Equality { term: Term::Ty(..) } => {
 495                                 ty::AssocKind::Type
 496                             }
 497                             TypeBindingKind::Equality { term: Term::Const(..) } => {
 498                                 ty::AssocKind::Const
 499                             }
 500                         },
 501                         def_id.to_def_id(),
 502                     );
 503                     if let Some(param)
 504                         = assoc_item.map(|item| &tcx.generics_of(item.def_id).params[idx]).filter(|param| param.kind.is_ty_or_const())
 505                     {
 506                         tcx.type_of(param.def_id)
 507                     } else {
 508                         // FIXME(associated_const_equality): add a useful error message here.
 509                         tcx.ty_error_with_message(
 510                             DUMMY_SP,
 511                             "Could not find associated const on trait",
 512                         )
 513                     }
 514                 }
 515
 516                 Node::GenericParam(&GenericParam {
 517                     def_id: param_def_id,
 518                     kind: GenericParamKind::Const { default: Some(ct), .. },
 519                     ..
 520                 }) if ct.hir_id == hir_id => tcx.type_of(param_def_id),
 521
 522                 x => tcx.ty_error_with_message(
 523                     DUMMY_SP,
 524                     &format!("unexpected const parent in type_of(): {x:?}"),
 525                 ),
 526             }
 527         }
 528
 529         Node::GenericParam(param) => match &param.kind {
 530             GenericParamKind::Type { default: Some(ty), .. }
 531             | GenericParamKind::Const { ty, .. } => icx.to_ty(ty),
 532             x => bug!("unexpected non-type Node::GenericParam: {:?}", x),
 533         },
 534
 535         x => {
 536             bug!("unexpected sort of node in type_of(): {:?}", x);
 537         }
 538     }
 539 }
 540
 541 #[instrument(skip(tcx), level = "debug")]
 542 /// Checks "defining uses" of opaque `impl Trait` types to ensure that they meet the restrictions
 543 /// laid for "higher-order pattern unification".
 544 /// This ensures that inference is tractable.
 545 /// In particular, definitions of opaque types can only use other generics as arguments,
 546 /// and they cannot repeat an argument. Example:
 547 ///
 548 /// ```ignore (illustrative)
 549 /// type Foo<A, B> = impl Bar<A, B>;
 550 ///
 551 /// // Okay -- `Foo` is applied to two distinct, generic types.
 552 /// fn a<T, U>() -> Foo<T, U> { .. }
 553 ///
 554 /// // Not okay -- `Foo` is applied to `T` twice.
 555 /// fn b<T>() -> Foo<T, T> { .. }
 556 ///
 557 /// // Not okay -- `Foo` is applied to a non-generic type.
 558 /// fn b<T>() -> Foo<T, u32> { .. }
 559 /// ```
 560 ///
 561 fn find_opaque_ty_constraints_for_tait(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> {
 562     use rustc_hir::{Expr, ImplItem, Item, TraitItem};
 563
 564     struct ConstraintLocator<'tcx> {
 565         tcx: TyCtxt<'tcx>,
 566
 567         /// def_id of the opaque type whose defining uses are being checked
 568         def_id: LocalDefId,
 569
 570         /// as we walk the defining uses, we are checking that all of them
 571         /// define the same hidden type. This variable is set to `Some`
 572         /// with the first type that we find, and then later types are
 573         /// checked against it (we also carry the span of that first
 574         /// type).
 575         found: Option<ty::OpaqueHiddenType<'tcx>>,
 576
 577         /// In the presence of dead code, typeck may figure out a hidden type
 578         /// while borrowck will now. We collect these cases here and check at
 579         /// the end that we actually found a type that matches (modulo regions).
 580         typeck_types: Vec<ty::OpaqueHiddenType<'tcx>>,
 581     }
 582
 583     impl ConstraintLocator<'_> {
 584         #[instrument(skip(self), level = "debug")]
 585         fn check(&mut self, item_def_id: LocalDefId) {
 586             // Don't try to check items that cannot possibly constrain the type.
 587             if !self.tcx.has_typeck_results(item_def_id) {
 588                 debug!("no constraint: no typeck results");
 589                 return;
 590             }
 591             // Calling `mir_borrowck` can lead to cycle errors through
 592             // const-checking, avoid calling it if we don't have to.
 593             // ```rust
 594             // type Foo = impl Fn() -> usize; // when computing type for this
 595             // const fn bar() -> Foo {
 596             //     || 0usize
 597             // }
 598             // const BAZR: Foo = bar(); // we would mir-borrowck this, causing cycles
 599             // // because we again need to reveal `Foo` so we can check whether the
 600             // // constant does not contain interior mutability.
 601             // ```
 602             let tables = self.tcx.typeck(item_def_id);
 603             if let Some(_) = tables.tainted_by_errors {
 604                 self.found = Some(ty::OpaqueHiddenType { span: DUMMY_SP, ty: self.tcx.ty_error() });
 605                 return;
 606             }
 607             let Some(&typeck_hidden_ty) = tables.concrete_opaque_types.get(&self.def_id) else {
 608                 debug!("no constraints in typeck results");
 609                 return;
 610             };
 611             if self.typeck_types.iter().all(|prev| prev.ty != typeck_hidden_ty.ty) {
 612                 self.typeck_types.push(typeck_hidden_ty);
 613             }
 614
 615             // Use borrowck to get the type with unerased regions.
 616             let concrete_opaque_types = &self.tcx.mir_borrowck(item_def_id).concrete_opaque_types;
 617             debug!(?concrete_opaque_types);
 618             if let Some(&concrete_type) = concrete_opaque_types.get(&self.def_id) {
 619                 debug!(?concrete_type, "found constraint");
 620                 if let Some(prev) = &mut self.found {
 621                     if concrete_type.ty != prev.ty && !(concrete_type, prev.ty).references_error() {
 622                         prev.report_mismatch(&concrete_type, self.tcx);
 623                         prev.ty = self.tcx.ty_error();
 624                     }
 625                 } else {
 626                     self.found = Some(concrete_type);
 627                 }
 628             }
 629         }
 630     }
 631
 632     impl<'tcx> intravisit::Visitor<'tcx> for ConstraintLocator<'tcx> {
 633         type NestedFilter = nested_filter::All;
 634
 635         fn nested_visit_map(&mut self) -> Self::Map {
 636             self.tcx.hir()
 637         }
 638         fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
 639             if let hir::ExprKind::Closure(closure) = ex.kind {
 640                 self.check(closure.def_id);
 641             }
 642             intravisit::walk_expr(self, ex);
 643         }
 644         fn visit_item(&mut self, it: &'tcx Item<'tcx>) {
 645             trace!(?it.owner_id);
 646             // The opaque type itself or its children are not within its reveal scope.
 647             if it.owner_id.def_id != self.def_id {
 648                 self.check(it.owner_id.def_id);
 649                 intravisit::walk_item(self, it);
 650             }
 651         }
 652         fn visit_impl_item(&mut self, it: &'tcx ImplItem<'tcx>) {
 653             trace!(?it.owner_id);
 654             // The opaque type itself or its children are not within its reveal scope.
 655             if it.owner_id.def_id != self.def_id {
 656                 self.check(it.owner_id.def_id);
 657                 intravisit::walk_impl_item(self, it);
 658             }
 659         }
 660         fn visit_trait_item(&mut self, it: &'tcx TraitItem<'tcx>) {
 661             trace!(?it.owner_id);
 662             self.check(it.owner_id.def_id);
 663             intravisit::walk_trait_item(self, it);
 664         }
 665     }
 666
 667     let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
 668     let scope = tcx.hir().get_defining_scope(hir_id);
 669     let mut locator = ConstraintLocator { def_id: def_id, tcx, found: None, typeck_types: vec![] };
 670
 671     debug!(?scope);
 672
 673     if scope == hir::CRATE_HIR_ID {
 674         tcx.hir().walk_toplevel_module(&mut locator);
 675     } else {
 676         trace!("scope={:#?}", tcx.hir().get(scope));
 677         match tcx.hir().get(scope) {
 678             // We explicitly call `visit_*` methods, instead of using `intravisit::walk_*` methods
 679             // This allows our visitor to process the defining item itself, causing
 680             // it to pick up any 'sibling' defining uses.
 681             //
 682             // For example, this code:
 683             // ```
 684             // fn foo() {
 685             //     type Blah = impl Debug;
 686             //     let my_closure = || -> Blah { true };
 687             // }
 688             // ```
 689             //
 690             // requires us to explicitly process `foo()` in order
 691             // to notice the defining usage of `Blah`.
 692             Node::Item(it) => locator.visit_item(it),
 693             Node::ImplItem(it) => locator.visit_impl_item(it),
 694             Node::TraitItem(it) => locator.visit_trait_item(it),
 695             other => bug!("{:?} is not a valid scope for an opaque type item", other),
 696         }
 697     }
 698
 699     let Some(hidden) = locator.found else {
 700         let reported = tcx.sess.emit_err(UnconstrainedOpaqueType {
 701             span: tcx.def_span(def_id),
 702             name: tcx.item_name(tcx.local_parent(def_id).to_def_id()),
 703             what: match tcx.hir().get(scope) {
 704                 _ if scope == hir::CRATE_HIR_ID => "module",
 705                 Node::Item(hir::Item { kind: hir::ItemKind::Mod(_), .. }) => "module",
 706                 Node::Item(hir::Item { kind: hir::ItemKind::Impl(_), .. }) => "impl",
 707                 _ => "item",
 708             },
 709         });
 710         return tcx.ty_error_with_guaranteed(reported);
 711     };
 712
 713     // Only check against typeck if we didn't already error
 714     if !hidden.ty.references_error() {
 715         for concrete_type in locator.typeck_types {
 716             if tcx.erase_regions(concrete_type.ty) != tcx.erase_regions(hidden.ty)
 717                 && !(concrete_type, hidden).references_error()
 718             {
 719                 hidden.report_mismatch(&concrete_type, tcx);
 720             }
 721         }
 722     }
 723
 724     hidden.ty
 725 }
 726
 727 fn find_opaque_ty_constraints_for_rpit(
 728     tcx: TyCtxt<'_>,
 729     def_id: LocalDefId,
 730     owner_def_id: LocalDefId,
 731 ) -> Ty<'_> {
 732     use rustc_hir::{Expr, ImplItem, Item, TraitItem};
 733
 734     struct ConstraintChecker<'tcx> {
 735         tcx: TyCtxt<'tcx>,
 736
 737         /// def_id of the opaque type whose defining uses are being checked
 738         def_id: LocalDefId,
 739
 740         found: ty::OpaqueHiddenType<'tcx>,
 741     }
 742
 743     impl ConstraintChecker<'_> {
 744         #[instrument(skip(self), level = "debug")]
 745         fn check(&self, def_id: LocalDefId) {
 746             // Use borrowck to get the type with unerased regions.
 747             let concrete_opaque_types = &self.tcx.mir_borrowck(def_id).concrete_opaque_types;
 748             debug!(?concrete_opaque_types);
 749             for &(def_id, concrete_type) in concrete_opaque_types {
 750                 if def_id != self.def_id {
 751                     // Ignore constraints for other opaque types.
 752                     continue;
 753                 }
 754
 755                 debug!(?concrete_type, "found constraint");
 756
 757                 if concrete_type.ty != self.found.ty
 758                     && !(concrete_type, self.found).references_error()
 759                 {
 760                     self.found.report_mismatch(&concrete_type, self.tcx);
 761                 }
 762             }
 763         }
 764     }
 765
 766     impl<'tcx> intravisit::Visitor<'tcx> for ConstraintChecker<'tcx> {
 767         type NestedFilter = nested_filter::OnlyBodies;
 768
 769         fn nested_visit_map(&mut self) -> Self::Map {
 770             self.tcx.hir()
 771         }
 772         fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
 773             if let hir::ExprKind::Closure(closure) = ex.kind {
 774                 self.check(closure.def_id);
 775             }
 776             intravisit::walk_expr(self, ex);
 777         }
 778         fn visit_item(&mut self, it: &'tcx Item<'tcx>) {
 779             trace!(?it.owner_id);
 780             // The opaque type itself or its children are not within its reveal scope.
 781             if it.owner_id.def_id != self.def_id {
 782                 self.check(it.owner_id.def_id);
 783                 intravisit::walk_item(self, it);
 784             }
 785         }
 786         fn visit_impl_item(&mut self, it: &'tcx ImplItem<'tcx>) {
 787             trace!(?it.owner_id);
 788             // The opaque type itself or its children are not within its reveal scope.
 789             if it.owner_id.def_id != self.def_id {
 790                 self.check(it.owner_id.def_id);
 791                 intravisit::walk_impl_item(self, it);
 792             }
 793         }
 794         fn visit_trait_item(&mut self, it: &'tcx TraitItem<'tcx>) {
 795             trace!(?it.owner_id);
 796             self.check(it.owner_id.def_id);
 797             intravisit::walk_trait_item(self, it);
 798         }
 799     }
 800
 801     let concrete = tcx.mir_borrowck(owner_def_id).concrete_opaque_types.get(&def_id).copied();
 802
 803     if let Some(concrete) = concrete {
 804         let scope = tcx.hir().local_def_id_to_hir_id(owner_def_id);
 805         debug!(?scope);
 806         let mut locator = ConstraintChecker { def_id: def_id, tcx, found: concrete };
 807
 808         match tcx.hir().get(scope) {
 809             Node::Item(it) => intravisit::walk_item(&mut locator, it),
 810             Node::ImplItem(it) => intravisit::walk_impl_item(&mut locator, it),
 811             Node::TraitItem(it) => intravisit::walk_trait_item(&mut locator, it),
 812             other => bug!("{:?} is not a valid scope for an opaque type item", other),
 813         }
 814     }
 815
 816     concrete.map(|concrete| concrete.ty).unwrap_or_else(|| {
 817         let table = tcx.typeck(owner_def_id);
 818         if let Some(_) = table.tainted_by_errors {
 819             // Some error in the
 820             // owner fn prevented us from populating
 821             // the `concrete_opaque_types` table.
 822             tcx.ty_error()
 823         } else {
 824             table.concrete_opaque_types.get(&def_id).map(|ty| ty.ty).unwrap_or_else(|| {
 825                 // We failed to resolve the opaque type or it
 826                 // resolves to itself. We interpret this as the
 827                 // no values of the hidden type ever being constructed,
 828                 // so we can just make the hidden type be `!`.
 829                 // For backwards compatibility reasons, we fall back to
 830                 // `()` until we the diverging default is changed.
 831                 tcx.mk_diverging_default()
 832             })
 833         }
 834     })
 835 }
 836
 837 fn infer_placeholder_type<'a>(
 838     tcx: TyCtxt<'a>,
 839     def_id: LocalDefId,
 840     body_id: hir::BodyId,
 841     span: Span,
 842     item_ident: Ident,
 843     kind: &'static str,
 844 ) -> Ty<'a> {
 845     // Attempts to make the type nameable by turning FnDefs into FnPtrs.
 846     struct MakeNameable<'tcx> {
 847         success: bool,
 848         tcx: TyCtxt<'tcx>,
 849     }
 850
 851     impl<'tcx> MakeNameable<'tcx> {
 852         fn new(tcx: TyCtxt<'tcx>) -> Self {
 853             MakeNameable { success: true, tcx }
 854         }
 855     }
 856
 857     impl<'tcx> TypeFolder<'tcx> for MakeNameable<'tcx> {
 858         fn tcx(&self) -> TyCtxt<'tcx> {
 859             self.tcx
 860         }
 861
 862         fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
 863             if !self.success {
 864                 return ty;
 865             }
 866
 867             match ty.kind() {
 868                 ty::FnDef(def_id, _) => self.tcx.mk_fn_ptr(self.tcx.fn_sig(*def_id)),
 869                 // FIXME: non-capturing closures should also suggest a function pointer
 870                 ty::Closure(..) | ty::Generator(..) => {
 871                     self.success = false;
 872                     ty
 873                 }
 874                 _ => ty.super_fold_with(self),
 875             }
 876         }
 877     }
 878
 879     let ty = tcx.diagnostic_only_typeck(def_id).node_type(body_id.hir_id);
 880
 881     // If this came from a free `const` or `static mut?` item,
 882     // then the user may have written e.g. `const A = 42;`.
 883     // In this case, the parser has stashed a diagnostic for
 884     // us to improve in typeck so we do that now.
 885     match tcx.sess.diagnostic().steal_diagnostic(span, StashKey::ItemNoType) {
 886         Some(mut err) => {
 887             if !ty.references_error() {
 888                 // Only suggest adding `:` if it was missing (and suggested by parsing diagnostic)
 889                 let colon = if span == item_ident.span.shrink_to_hi() { ":" } else { "" };
 890
 891                 // The parser provided a sub-optimal `HasPlaceholders` suggestion for the type.
 892                 // We are typeck and have the real type, so remove that and suggest the actual type.
 893                 // FIXME(eddyb) this looks like it should be functionality on `Diagnostic`.
 894                 if let Ok(suggestions) = &mut err.suggestions {
 895                     suggestions.clear();
 896                 }
 897
 898                 // Suggesting unnameable types won't help.
 899                 let mut mk_nameable = MakeNameable::new(tcx);
 900                 let ty = mk_nameable.fold_ty(ty);
 901                 let sugg_ty = if mk_nameable.success { Some(ty) } else { None };
 902                 if let Some(sugg_ty) = sugg_ty {
 903                     err.span_suggestion(
 904                         span,
 905                         &format!("provide a type for the {item}", item = kind),
 906                         format!("{colon} {sugg_ty}"),
 907                         Applicability::MachineApplicable,
 908                     );
 909                 } else {
 910                     err.span_note(
 911                         tcx.hir().body(body_id).value.span,
 912                         &format!("however, the inferred type `{}` cannot be named", ty),
 913                     );
 914                 }
 915             }
 916
 917             err.emit();
 918         }
 919         None => {
 920             let mut diag = bad_placeholder(tcx, vec![span], kind);
 921
 922             if !ty.references_error() {
 923                 let mut mk_nameable = MakeNameable::new(tcx);
 924                 let ty = mk_nameable.fold_ty(ty);
 925                 let sugg_ty = if mk_nameable.success { Some(ty) } else { None };
 926                 if let Some(sugg_ty) = sugg_ty {
 927                     diag.span_suggestion(
 928                         span,
 929                         "replace with the correct type",
 930                         sugg_ty,
 931                         Applicability::MaybeIncorrect,
 932                     );
 933                 } else {
 934                     diag.span_note(
 935                         tcx.hir().body(body_id).value.span,
 936                         &format!("however, the inferred type `{}` cannot be named", ty),
 937                     );
 938                 }
 939             }
 940
 941             diag.emit();
 942         }
 943     }
 944
 945     // Typeck doesn't expect erased regions to be returned from `type_of`.
 946     tcx.fold_regions(ty, |r, _| match *r {
 947         ty::ReErased => tcx.lifetimes.re_static,
 948         _ => r,
 949     })
 950 }
 951
 952 fn check_feature_inherent_assoc_ty(tcx: TyCtxt<'_>, span: Span) {
 953     if !tcx.features().inherent_associated_types {
 954         use rustc_session::parse::feature_err;
 955         use rustc_span::symbol::sym;
 956         feature_err(
 957             &tcx.sess.parse_sess,
 958             sym::inherent_associated_types,
 959             span,
 960             "inherent associated types are unstable",
 961         )
 962         .emit();
 963     }
 964 }