Auto merge of #130964 - matthiaskrgr:rollup-suriuub, r=matthiaskrgr

Rollup of 8 pull requests
Successful merges:
- #125404 (Fix `read_buf` uses in `std`)
- #130866 (Allow instantiating object trait binder when upcasting)
- #130922 (Reference UNSPECIFIED instead of INADDR_ANY in join_multicast_v4)
- #130924 (Make clashing_extern_declarations considering generic args for ADT field)
- #130939 (rustdoc: update `ProcMacro` docs section on helper attributes)
- #130940 (Revert space-saving operations)
- #130944 (Allow instantiating trait object binder in ptr-to-ptr casts)
- #130953 (Rename a few tests to make tidy happier)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2437,7 +2437,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
 debug!(?src_tty, ?dst_tty, ?src_obj, ?dst_obj);
 
-self.eq_types(
+self.sub_types(
  src_obj,
  dst_obj,
  location.to_locations(),

compiler/rustc_infer/src/infer/at.rs

@@ -92,12 +92,7 @@ impl<'tcx> InferCtxt<'tcx> {
 }
 
 pubtraitToTrace<'tcx>:Relate<TyCtxt<'tcx>> + Copy{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>;
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>;
 }
 
 impl<'a,'tcx>At<'a,'tcx>{
@@ -116,7 +111,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 {
 letmut fields = CombineFields::new(
 self.infcx,
-ToTrace::to_trace(self.cause,true,expected, actual),
+ToTrace::to_trace(self.cause, expected, actual),
 self.param_env,
  define_opaque_types,
 );
@@ -136,7 +131,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 {
 letmut fields = CombineFields::new(
 self.infcx,
-ToTrace::to_trace(self.cause,true,expected, actual),
+ToTrace::to_trace(self.cause, expected, actual),
 self.param_env,
  define_opaque_types,
 );
@@ -154,12 +149,26 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 where
 T:ToTrace<'tcx>,
 {
-letmut fields = CombineFields::new(
-self.infcx,
-ToTrace::to_trace(self.cause,true, expected, actual),
-self.param_env,
+self.eq_trace(
  define_opaque_types,
-);
+ToTrace::to_trace(self.cause, expected, actual),
+ expected,
+ actual,
+)
+}
+
+/// Makes `expected == actual`.
+pubfneq_trace<T>(
+self,
+define_opaque_types:DefineOpaqueTypes,
+trace:TypeTrace<'tcx>,
+expected:T,
+actual:T,
+) -> InferResult<'tcx,()>
+where
+T:Relate<TyCtxt<'tcx>>,
+{
+letmut fields = CombineFields::new(self.infcx, trace,self.param_env, define_opaque_types);
  fields.equate(StructurallyRelateAliases::No).relate(expected, actual)?;
 Ok(InferOk{
 value:(),
@@ -192,7 +201,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 assert!(self.infcx.next_trait_solver());
 letmut fields = CombineFields::new(
 self.infcx,
-ToTrace::to_trace(self.cause,true,expected, actual),
+ToTrace::to_trace(self.cause, expected, actual),
 self.param_env,
 DefineOpaqueTypes::Yes,
 );
@@ -284,7 +293,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 {
 letmut fields = CombineFields::new(
 self.infcx,
-ToTrace::to_trace(self.cause,true,expected, actual),
+ToTrace::to_trace(self.cause, expected, actual),
 self.param_env,
  define_opaque_types,
 );
@@ -306,7 +315,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 {
 letmut fields = CombineFields::new(
 self.infcx,
-ToTrace::to_trace(self.cause,true,expected, actual),
+ToTrace::to_trace(self.cause, expected, actual),
 self.param_env,
  define_opaque_types,
 );
@@ -316,18 +325,13 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 }
 
 impl<'tcx>ToTrace<'tcx>forImplSubject<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 match(a, b){
 (ImplSubject::Trait(trait_ref_a),ImplSubject::Trait(trait_ref_b)) => {
-ToTrace::to_trace(cause,a_is_expected,trait_ref_a, trait_ref_b)
+ToTrace::to_trace(cause, trait_ref_a, trait_ref_b)
 }
 (ImplSubject::Inherent(ty_a),ImplSubject::Inherent(ty_b)) => {
-ToTrace::to_trace(cause,a_is_expected,ty_a, ty_b)
+ToTrace::to_trace(cause, ty_a, ty_b)
 }
 (ImplSubject::Trait(_),ImplSubject::Inherent(_))
  | (ImplSubject::Inherent(_),ImplSubject::Trait(_)) => {
@@ -338,65 +342,45 @@ impl<'tcx> ToTrace<'tcx> for ImplSubject<'tcx> {
 }
 
 impl<'tcx>ToTrace<'tcx>forTy<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())),
+values:ValuePairs::Terms(ExpectedFound::new(true, a.into(), b.into())),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::Region<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::Regions(ExpectedFound::new(a_is_expected, a, b)),
+values:ValuePairs::Regions(ExpectedFound::new(true, a, b)),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>forConst<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())),
+values:ValuePairs::Terms(ExpectedFound::new(true, a.into(), b.into())),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::GenericArg<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
 values:match(a.unpack(), b.unpack()){
 (GenericArgKind::Lifetime(a),GenericArgKind::Lifetime(b)) => {
-ValuePairs::Regions(ExpectedFound::new(a_is_expected, a, b))
+ValuePairs::Regions(ExpectedFound::new(true, a, b))
 }
 (GenericArgKind::Type(a),GenericArgKind::Type(b)) => {
-ValuePairs::Terms(ExpectedFound::new(a_is_expected, a.into(), b.into()))
+ValuePairs::Terms(ExpectedFound::new(true, a.into(), b.into()))
 }
 (GenericArgKind::Const(a),GenericArgKind::Const(b)) => {
-ValuePairs::Terms(ExpectedFound::new(a_is_expected, a.into(), b.into()))
+ValuePairs::Terms(ExpectedFound::new(true, a.into(), b.into()))
 }
 
 (
@@ -419,72 +403,47 @@ impl<'tcx> ToTrace<'tcx> for ty::GenericArg<'tcx> {
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::Term<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::Terms(ExpectedFound::new(a_is_expected, a, b)),
+values:ValuePairs::Terms(ExpectedFound::new(true, a, b)),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::TraitRef<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::TraitRefs(ExpectedFound::new(a_is_expected, a, b)),
+values:ValuePairs::TraitRefs(ExpectedFound::new(true, a, b)),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::AliasTy<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::Aliases(ExpectedFound::new(a_is_expected, a.into(), b.into())),
+values:ValuePairs::Aliases(ExpectedFound::new(true, a.into(), b.into())),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::AliasTerm<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::Aliases(ExpectedFound::new(a_is_expected, a, b)),
+values:ValuePairs::Aliases(ExpectedFound::new(true, a, b)),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::FnSig<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
 values:ValuePairs::PolySigs(ExpectedFound::new(
-a_is_expected,
+true,
  ty::Binder::dummy(a),
  ty::Binder::dummy(b),
 )),
@@ -493,43 +452,28 @@ impl<'tcx> ToTrace<'tcx> for ty::FnSig<'tcx> {
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::PolyFnSig<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::PolySigs(ExpectedFound::new(a_is_expected, a, b)),
+values:ValuePairs::PolySigs(ExpectedFound::new(true, a, b)),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::PolyExistentialTraitRef<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::ExistentialTraitRef(ExpectedFound::new(a_is_expected, a, b)),
+values:ValuePairs::ExistentialTraitRef(ExpectedFound::new(true, a, b)),
 }
 }
 }
 
 impl<'tcx>ToTrace<'tcx>for ty::PolyExistentialProjection<'tcx>{
-fnto_trace(
-cause:&ObligationCause<'tcx>,
-a_is_expected:bool,
-a:Self,
-b:Self,
-) -> TypeTrace<'tcx>{
+fnto_trace(cause:&ObligationCause<'tcx>,a:Self,b:Self) -> TypeTrace<'tcx>{
 TypeTrace{
 cause: cause.clone(),
-values:ValuePairs::ExistentialProjection(ExpectedFound::new(a_is_expected, a, b)),
+values:ValuePairs::ExistentialProjection(ExpectedFound::new(true, a, b)),
 }
 }
 }

compiler/rustc_lint/src/foreign_modules.rs

@@ -280,7 +280,7 @@ fn structurally_same_type_impl<'tcx>(
 
 ensure_sufficient_stack(|| {
 match(a.kind(), b.kind()){
-(&Adt(a_def,_),&Adt(b_def,_)) => {
+(&Adt(a_def,a_gen_args),&Adt(b_def,b_gen_args)) => {
 // Only `repr(C)` types can be compared structurally.
 if !(a_def.repr().c() && b_def.repr().c()){
 returnfalse;
@@ -304,8 +304,8 @@ fn structurally_same_type_impl<'tcx>(
  seen_types,
  tcx,
  param_env,
- tcx.type_of(a_did).instantiate_identity(),
- tcx.type_of(b_did).instantiate_identity(),
+ tcx.type_of(a_did).instantiate(tcx, a_gen_args),
+ tcx.type_of(b_did).instantiate(tcx, b_gen_args),
  ckind,
 )
 },

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -448,10 +448,10 @@ where
 }
 }
 }else{
-self.delegate.enter_forall(kind, |kind| {
-let goal = goal.with(self.cx(), ty::Binder::dummy(kind));
-self.add_goal(GoalSource::InstantiateHigherRanked, goal);
-self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+self.enter_forall(kind, |ecx,kind| {
+let goal = goal.with(ecx.cx(), ty::Binder::dummy(kind));
+ecx.add_goal(GoalSource::InstantiateHigherRanked, goal);
+ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
 })
 }
 }
@@ -840,12 +840,14 @@ where
 self.delegate.instantiate_binder_with_infer(value)
 }
 
+/// `enter_forall`, but takes `&mut self` and passes it back through the
+/// callback since it can't be aliased during the call.
 pub(super)fnenter_forall<T:TypeFoldable<I> + Copy,U>(
-&self,
+&mutself,
 value: ty::Binder<I,T>,
-f:implFnOnce(T) -> U,
+f:implFnOnce(&mutSelf,T) -> U,
 ) -> U{
-self.delegate.enter_forall(value,f)
+self.delegate.enter_forall(value,|value| f(self, value))
 }
 
 pub(super)fnresolve_vars_if_possible<T>(&self,value:T) -> T