mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make it clear that args default to being related invariantly

Browse Source
This commit is contained in:
Michael Goulet 2023-09-28 06:37:35 +00:00
parent cdef3b12de
commit be29d22eab
3 changed files with 12 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_infer/src/infer/equate.rs
View File

@ -56,7 +56,7 @@ fn relate_item_args(
// performing trait matching (which then performs equality // performing trait matching (which then performs equality
// unification). // unification).
relate::relate_args(self, a_arg, b_arg) relate::relate_args_invariantly(self, a_arg, b_arg)
} }
fn relate_with_variance<T: Relate<'tcx>>( fn relate_with_variance<T: Relate<'tcx>>(

2
compiler/rustc_infer/src/infer/generalize.rs
View File

@ -183,7 +183,7 @@ fn relate_item_args(
// Avoid fetching the variance if we are in an invariant // Avoid fetching the variance if we are in an invariant
// context; no need, and it can induce dependency cycles // context; no need, and it can induce dependency cycles
// (e.g., #41849). // (e.g., #41849).
relate::relate_args(self, a_subst, b_subst) relate::relate_args_invariantly(self, a_subst, b_subst)
} else { } else {
let tcx = self.tcx(); let tcx = self.tcx();
let opt_variances = tcx.variances_of(item_def_id); let opt_variances = tcx.variances_of(item_def_id);

20
compiler/rustc_middle/src/ty/relate.rs
View File

@ -135,7 +135,7 @@ pub fn relate_type_and_mut<'tcx, R: TypeRelation<'tcx>>(
} }
#[inline] #[inline]
pub fn relate_args<'tcx, R: TypeRelation<'tcx>>( pub fn relate_args_invariantly<'tcx, R: TypeRelation<'tcx>>(
relation: &mut R, relation: &mut R,
a_arg: GenericArgsRef<'tcx>, a_arg: GenericArgsRef<'tcx>,
b_arg: GenericArgsRef<'tcx>, b_arg: GenericArgsRef<'tcx>,
@ -284,7 +284,7 @@ fn relate<R: TypeRelation<'tcx>>(
false, // do not fetch `type_of(a_def_id)`, as it will cause a cycle false, // do not fetch `type_of(a_def_id)`, as it will cause a cycle
)?, )?,
DefKind::AssocTy | DefKind::AssocConst | DefKind::TyAlias => { DefKind::AssocTy | DefKind::AssocConst | DefKind::TyAlias => {
relation.relate(a.args, b.args)? relate_args_invariantly(relation, a.args, b.args)?
} }
def => bug!("unknown alias DefKind: {def:?}"), def => bug!("unknown alias DefKind: {def:?}"),
}; };
@ -329,7 +329,7 @@ fn relate<R: TypeRelation<'tcx>>(
if a.def_id != b.def_id { if a.def_id != b.def_id {
Err(TypeError::Traits(expected_found(relation, a.def_id, b.def_id))) Err(TypeError::Traits(expected_found(relation, a.def_id, b.def_id)))
} else { } else {
let args = relate_args(relation, a.args, b.args)?; let args = relate_args_invariantly(relation, a.args, b.args)?;
Ok(ty::TraitRef::new(relation.tcx(), a.def_id, args)) Ok(ty::TraitRef::new(relation.tcx(), a.def_id, args))
} }
} }
@ -345,7 +345,7 @@ fn relate<R: TypeRelation<'tcx>>(
if a.def_id != b.def_id { if a.def_id != b.def_id {
Err(TypeError::Traits(expected_found(relation, a.def_id, b.def_id))) Err(TypeError::Traits(expected_found(relation, a.def_id, b.def_id)))
} else { } else {
let args = relate_args(relation, a.args, b.args)?; let args = relate_args_invariantly(relation, a.args, b.args)?;
Ok(ty::ExistentialTraitRef { def_id: a.def_id, args }) Ok(ty::ExistentialTraitRef { def_id: a.def_id, args })
} }
} }
@ -463,7 +463,7 @@ pub fn structurally_relate_tys<'tcx, R: TypeRelation<'tcx>>(
// All Generator types with the same id represent // All Generator types with the same id represent
// the (anonymous) type of the same generator expression. So // the (anonymous) type of the same generator expression. So
// all of their regions should be equated. // all of their regions should be equated.
let args = relation.relate(a_args, b_args)?; let args = relate_args_invariantly(relation, a_args, b_args)?;
Ok(Ty::new_generator(tcx, a_id, args, movability)) Ok(Ty::new_generator(tcx, a_id, args, movability))
} }
@ -473,7 +473,7 @@ pub fn structurally_relate_tys<'tcx, R: TypeRelation<'tcx>>(
// All GeneratorWitness types with the same id represent // All GeneratorWitness types with the same id represent
// the (anonymous) type of the same generator expression. So // the (anonymous) type of the same generator expression. So
// all of their regions should be equated. // all of their regions should be equated.
let args = relation.relate(a_args, b_args)?; let args = relate_args_invariantly(relation, a_args, b_args)?;
Ok(Ty::new_generator_witness(tcx, a_id, args)) Ok(Ty::new_generator_witness(tcx, a_id, args))
} }
@ -481,7 +481,7 @@ pub fn structurally_relate_tys<'tcx, R: TypeRelation<'tcx>>(
// All Closure types with the same id represent // All Closure types with the same id represent
// the (anonymous) type of the same closure expression. So // the (anonymous) type of the same closure expression. So
// all of their regions should be equated. // all of their regions should be equated.
let args = relation.relate(a_args, b_args)?; let args = relate_args_invariantly(relation, a_args, b_args)?;
Ok(Ty::new_closure(tcx, a_id, &args)) Ok(Ty::new_closure(tcx, a_id, &args))
} }
@ -705,7 +705,7 @@ fn relate<R: TypeRelation<'tcx>>(
a: ty::ClosureArgs<'tcx>, a: ty::ClosureArgs<'tcx>,
b: ty::ClosureArgs<'tcx>, b: ty::ClosureArgs<'tcx>,
) -> RelateResult<'tcx, ty::ClosureArgs<'tcx>> { ) -> RelateResult<'tcx, ty::ClosureArgs<'tcx>> {
let args = relate_args(relation, a.args, b.args)?; let args = relate_args_invariantly(relation, a.args, b.args)?;
Ok(ty::ClosureArgs { args }) Ok(ty::ClosureArgs { args })
} }
} }
@ -716,7 +716,7 @@ fn relate<R: TypeRelation<'tcx>>(
a: ty::GeneratorArgs<'tcx>, a: ty::GeneratorArgs<'tcx>,
b: ty::GeneratorArgs<'tcx>, b: ty::GeneratorArgs<'tcx>,
) -> RelateResult<'tcx, ty::GeneratorArgs<'tcx>> { ) -> RelateResult<'tcx, ty::GeneratorArgs<'tcx>> {
let args = relate_args(relation, a.args, b.args)?; let args = relate_args_invariantly(relation, a.args, b.args)?;
Ok(ty::GeneratorArgs { args }) Ok(ty::GeneratorArgs { args })
} }
} }
@ -727,7 +727,7 @@ fn relate<R: TypeRelation<'tcx>>(
a: GenericArgsRef<'tcx>, a: GenericArgsRef<'tcx>,
b: GenericArgsRef<'tcx>, b: GenericArgsRef<'tcx>,
) -> RelateResult<'tcx, GenericArgsRef<'tcx>> { ) -> RelateResult<'tcx, GenericArgsRef<'tcx>> {
relate_args(relation, a, b) relate_args_invariantly(relation, a, b)
} }
} }