Rollup merge of rust-lang#120619 - compiler-errors:param, r=lcnr

Assert that params with the same *index* have the same *name*

Found this bug when trying to build libcore with the new solver, since it will canonicalize two params with the same index into *different* placeholders if those params differ by name.

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -12,7 +12,7 @@ use rustc_errors::{codes::*, struct_span_code_err, DiagnosticMessage};
 use rustc_hir as hir;
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_span::symbol::{kw, sym, Symbol};
+use rustc_span::symbol::{kw, sym};
 use rustc_target::spec::abi::Abi;
 
 fn equate_intrinsic_type<'tcx>(
@@ -132,7 +132,17 @@ pub fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: DefId) -> hir
 /// Remember to add all intrinsics here, in `compiler/rustc_codegen_llvm/src/intrinsic.rs`,
 /// and in `library/core/src/intrinsics.rs`.
 pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
- let param = |n| Ty::new_param(tcx, n, Symbol::intern(&format!("P{n}")));
+ let generics = tcx.generics_of(it.owner_id);
+ let param = |n| {
+ if let Some(&ty::GenericParamDef {
+ name, kind: ty::GenericParamDefKind::Type { .. }, ..
+ }) = generics.opt_param_at(n as usize, tcx)
+ {
+ Ty::new_param(tcx, n, name)
+ } else {
+ Ty::new_error_with_message(tcx, tcx.def_span(it.owner_id), "expected param")
+ }
+ };
  let intrinsic_id = it.owner_id.to_def_id();
  let intrinsic_name = tcx.item_name(intrinsic_id);
  let name_str = intrinsic_name.as_str();
@@ -475,9 +485,16 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
 
 /// Type-check `extern "platform-intrinsic" { ... }` functions.
 pub fn check_platform_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
+ let generics = tcx.generics_of(it.owner_id);
  let param = |n| {
- let name = Symbol::intern(&format!("P{n}"));
- Ty::new_param(tcx, n, name)
+ if let Some(&ty::GenericParamDef {
+ name, kind: ty::GenericParamDefKind::Type { .. }, ..
+ }) = generics.opt_param_at(n as usize, tcx)
+ {
+ Ty::new_param(tcx, n, name)
+ } else {
+ Ty::new_error_with_message(tcx, tcx.def_span(it.owner_id), "expected param")
+ }
  };
 
  let name = it.ident.name;

compiler/rustc_middle/src/ty/relate.rs

@@ -435,7 +435,10 @@ pub fn structurally_relate_tys<'tcx, R: TypeRelation<'tcx>>(
  Ok(a)
  }
 
- (ty::Param(a_p), ty::Param(b_p)) if a_p.index == b_p.index => Ok(a),
+ (ty::Param(a_p), ty::Param(b_p)) if a_p.index == b_p.index => {
+ debug_assert_eq!(a_p.name, b_p.name, "param types with same index differ in name");
+ Ok(a)
+ }
 
  (ty::Placeholder(p1), ty::Placeholder(p2)) if p1 == p2 => Ok(a),
 
@@ -586,7 +589,10 @@ pub fn structurally_relate_consts<'tcx, R: TypeRelation<'tcx>>(
  (ty::ConstKind::Error(_), _) => return Ok(a),
  (_, ty::ConstKind::Error(_)) => return Ok(b),
 
- (ty::ConstKind::Param(a_p), ty::ConstKind::Param(b_p)) => a_p.index == b_p.index,
+ (ty::ConstKind::Param(a_p), ty::ConstKind::Param(b_p)) if a_p.index == b_p.index => {
+ debug_assert_eq!(a_p.name, b_p.name, "param types with same index differ in name");
+ true
+ }
  (ty::ConstKind::Placeholder(p1), ty::ConstKind::Placeholder(p2)) => p1 == p2,
  (ty::ConstKind::Value(a_val), ty::ConstKind::Value(b_val)) => a_val == b_val,