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

Auto merge of #125960 - jieyouxu:rollup-1s7f6lr, r=jieyouxu

Browse Source 
Rollup of 8 pull requests

Successful merges:

 - #124486 (Add tracking issue and unstable book page for `"vectorcall"` ABI)
 - #125504 (Change pedantically incorrect OnceCell/OnceLock wording)
 - #125608 (Avoid follow-up errors if the number of generic parameters already doesn't match)
 - #125690 (ARM Target Docs Update)
 - #125750 (Align `Term` methods with `GenericArg` methods, add `Term::expect_*`)
 - #125818 (Handle no values cfgs with `--print=check-cfg`)
 - #125909 (rustdoc: add a regression test for a former blanket impl synthesis ICE)
 - #125919 (Remove stray "this")

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-06-04 09:38:16 +00:00
commit 85f90a4612
57 changed files with 385 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
View File

@ -263,7 +263,7 @@ fn push_debuginfo_type_name<'tcx>(
let ExistentialProjection { def_id: item_def_id, term, .. } =
tcx.instantiate_bound_regions_with_erased(bound);
// FIXME(associated_const_equality): allow for consts here
(item_def_id, term.ty().unwrap())
(item_def_id, term.expect_type())
})
.collect();

18
compiler/rustc_driver_impl/src/lib.rs
View File

@ -814,13 +814,17 @@ fn print_crate_info(
match expected_values {
ExpectedValues::Any => check_cfgs.push(format!("{name}=any()")),
ExpectedValues::Some(values) => {
check_cfgs.extend(values.iter().map(|value| {
if let Some(value) = value {
format!("{name}=\"{value}\"")
} else {
name.to_string()
}
}))
if !values.is_empty() {
check_cfgs.extend(values.iter().map(|value| {
if let Some(value) = value {
format!("{name}=\"{value}\"")
} else {
name.to_string()
}
}))
} else {
check_cfgs.push(format!("{name}="))
}
}
}
}

4
compiler/rustc_feature/src/unstable.rs
View File

@ -177,8 +177,6 @@ declare_features! (
/// Allows using the `unadjusted` ABI; perma-unstable.
(internal, abi_unadjusted, "1.16.0", None),
/// Allows using the `vectorcall` ABI.
(unstable, abi_vectorcall, "1.7.0", None),
/// Allows using `#![needs_allocator]`, an implementation detail of `#[global_allocator]`.
(internal, allocator_internals, "1.20.0", None),
/// Allows using `#[allow_internal_unsafe]`. This is an
@ -243,6 +241,8 @@ declare_features! (
// feature-group-start: internal feature gates
// -------------------------------------------------------------------------
/// Allows using the `vectorcall` ABI.
(unstable, abi_vectorcall, "1.7.0", Some(124485)),
/// Allows features specific to auto traits.
/// Renamed from `optin_builtin_traits`.
(unstable, auto_traits, "1.50.0", Some(13231)),

2
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View File

@ -2281,7 +2281,7 @@ fn try_report_async_mismatch<'tcx>(
&& let Some(proj) = proj.no_bound_vars()
&& infcx.can_eq(
error.root_obligation.param_env,
proj.term.ty().unwrap(),
proj.term.expect_type(),
impl_sig.output(),
)
{

2
compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
View File

@ -267,7 +267,7 @@ fn report_mismatched_rpitit_signature<'tcx>(
.explicit_item_bounds(future_ty.def_id)
.iter_instantiated_copied(tcx, future_ty.args)
.find_map(|(clause, _)| match clause.kind().no_bound_vars()? {
ty::ClauseKind::Projection(proj) => proj.term.ty(),
ty::ClauseKind::Projection(proj) => proj.term.as_type(),
_ => None,
})
else {

4
compiler/rustc_hir_analysis/src/check/mod.rs
View File

@ -441,7 +441,9 @@ fn fn_sig_suggestion<'tcx>(
output = if let ty::Alias(_, alias_ty) = *output.kind() {
tcx.explicit_item_super_predicates(alias_ty.def_id)
.iter_instantiated_copied(tcx, alias_ty.args)
.find_map(|(bound, _)| bound.as_projection_clause()?.no_bound_vars()?.term.ty())
.find_map(|(bound, _)| {
bound.as_projection_clause()?.no_bound_vars()?.term.as_type()
})
.unwrap_or_else(|| {
span_bug!(
ident.span,

2
compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
View File

@ -702,7 +702,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
pub(crate) fn complain_about_missing_assoc_tys(
&self,
associated_types: FxIndexMap<Span, FxIndexSet<DefId>>,
potential_assoc_types: Vec<Span>,
potential_assoc_types: Vec<usize>,
trait_bounds: &[hir::PolyTraitRef<'_>],
) {
if associated_types.values().all(|v| v.is_empty()) {

28
compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
View File

@ -214,10 +214,11 @@ pub fn lower_generic_args<'tcx: 'a, 'a>(
if let Some(&param) = params.peek() {
if param.index == 0 {
if let GenericParamDefKind::Type { .. } = param.kind {
assert_eq!(&args[..], &[]);
args.push(
self_ty
.map(|ty| ty.into())
.unwrap_or_else(|| ctx.inferred_kind(None, param, true)),
.unwrap_or_else(|| ctx.inferred_kind(&args, param, true)),
);
params.next();
}
@ -267,7 +268,7 @@ pub fn lower_generic_args<'tcx: 'a, 'a>(
// Since this is a const impl, we need to insert a host arg at the end of
// `PartialEq`'s generics, but this errors since `Rhs` isn't specified.
// To work around this, we infer all arguments until we reach the host param.
args.push(ctx.inferred_kind(Some(&args), param, infer_args));
args.push(ctx.inferred_kind(&args, param, infer_args));
params.next();
}
(GenericArg::Lifetime(_), GenericParamDefKind::Lifetime, _)
@ -281,7 +282,7 @@ pub fn lower_generic_args<'tcx: 'a, 'a>(
GenericParamDefKind::Const { .. },
_,
) => {
args.push(ctx.provided_kind(param, arg));
args.push(ctx.provided_kind(&args, param, arg));
args_iter.next();
params.next();
}
@ -292,7 +293,7 @@ pub fn lower_generic_args<'tcx: 'a, 'a>(
) => {
// We expected a lifetime argument, but got a type or const
// argument. That means we're inferring the lifetimes.
args.push(ctx.inferred_kind(None, param, infer_args));
args.push(ctx.inferred_kind(&args, param, infer_args));
force_infer_lt = Some((arg, param));
params.next();
}
@ -388,7 +389,7 @@ pub fn lower_generic_args<'tcx: 'a, 'a>(
(None, Some(&param)) => {
// If there are fewer arguments than parameters, it means
// we're inferring the remaining arguments.
args.push(ctx.inferred_kind(Some(&args), param, infer_args));
args.push(ctx.inferred_kind(&args, param, infer_args));
params.next();
}
@ -474,16 +475,9 @@ pub(crate) fn check_generic_arg_count(
return Ok(());
}
if provided_args > max_expected_args {
invalid_args.extend(
gen_args.args[max_expected_args..provided_args].iter().map(|arg| arg.span()),
);
};
invalid_args.extend(min_expected_args..provided_args);
let gen_args_info = if provided_args > min_expected_args {
invalid_args.extend(
gen_args.args[min_expected_args..provided_args].iter().map(|arg| arg.span()),
);
let num_redundant_args = provided_args - min_expected_args;
GenericArgsInfo::ExcessLifetimes { num_redundant_args }
} else {
@ -538,11 +532,7 @@ pub(crate) fn check_generic_arg_count(
let num_default_params = expected_max - expected_min;
let gen_args_info = if provided > expected_max {
invalid_args.extend(
gen_args.args[args_offset + expected_max..args_offset + provided]
.iter()
.map(|arg| arg.span()),
);
invalid_args.extend((expected_max..provided).map(|i| i + args_offset));
let num_redundant_args = provided - expected_max;
// Provide extra note if synthetic arguments like `impl Trait` are specified.
@ -610,7 +600,7 @@ pub(crate) fn check_generic_arg_count(
explicit_late_bound,
correct: lifetimes_correct
.and(args_correct)
.map_err(|reported| GenericArgCountMismatch { reported: Some(reported), invalid_args }),
.map_err(|reported| GenericArgCountMismatch { reported, invalid_args }),
}
}

78
compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
View File

@ -215,12 +215,11 @@ pub(crate) enum GenericArgPosition {
/// A marker denoting that the generic arguments that were
/// provided did not match the respective generic parameters.
#[derive(Clone, Default, Debug)]
#[derive(Clone, Debug)]
pub struct GenericArgCountMismatch {
/// Indicates whether a fatal error was reported (`Some`), or just a lint (`None`).
pub reported: Option<ErrorGuaranteed>,
/// A list of spans of arguments provided that were not valid.
pub invalid_args: Vec<Span>,
pub reported: ErrorGuaranteed,
/// A list of indices of arguments provided that were not valid.
pub invalid_args: Vec<usize>,
}
/// Decorates the result of a generic argument count mismatch
@ -240,13 +239,14 @@ pub trait GenericArgsLowerer<'a, 'tcx> {
fn provided_kind(
&mut self,
preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx>;
fn inferred_kind(
&mut self,
args: Option<&[ty::GenericArg<'tcx>]>,
preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
infer_args: bool,
) -> ty::GenericArg<'tcx>;
@ -404,10 +404,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
self_ty.is_some(),
);
if let Err(err) = &arg_count.correct
&& let Some(reported) = err.reported
{
self.set_tainted_by_errors(reported);
if let Err(err) = &arg_count.correct {
self.set_tainted_by_errors(err.reported);
}
// Skip processing if type has no generic parameters.
@ -425,6 +423,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
span: Span,
inferred_params: Vec<Span>,
infer_args: bool,
incorrect_args: &'a Result<(), GenericArgCountMismatch>,
}
impl<'a, 'tcx> GenericArgsLowerer<'a, 'tcx> for GenericArgsCtxt<'a, 'tcx> {
@ -439,11 +438,18 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
fn provided_kind(
&mut self,
preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx> {
let tcx = self.lowerer.tcx();
if let Err(incorrect) = self.incorrect_args {
if incorrect.invalid_args.contains(&(param.index as usize)) {
return param.to_error(tcx, preceding_args);
}
}
let mut handle_ty_args = |has_default, ty: &hir::Ty<'tcx>| {
if has_default {
tcx.check_optional_stability(
@ -506,11 +512,17 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
fn inferred_kind(
&mut self,
args: Option<&[ty::GenericArg<'tcx>]>,
preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
infer_args: bool,
) -> ty::GenericArg<'tcx> {
let tcx = self.lowerer.tcx();
if let Err(incorrect) = self.incorrect_args {
if incorrect.invalid_args.contains(&(param.index as usize)) {
return param.to_error(tcx, preceding_args);
}
}
match param.kind {
GenericParamDefKind::Lifetime => self
.lowerer
@ -529,15 +541,19 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
GenericParamDefKind::Type { has_default, .. } => {
if !infer_args && has_default {
// No type parameter provided, but a default exists.
let args = args.unwrap();
if args.iter().any(|arg| match arg.unpack() {
GenericArgKind::Type(ty) => ty.references_error(),
_ => false,
}) {
if let Some(prev) =
preceding_args.iter().find_map(|arg| match arg.unpack() {
GenericArgKind::Type(ty) => ty.error_reported().err(),
_ => None,
})
{
// Avoid ICE #86756 when type error recovery goes awry.
return Ty::new_misc_error(tcx).into();
return Ty::new_error(tcx, prev).into();
}
tcx.at(self.span).type_of(param.def_id).instantiate(tcx, args).into()
tcx.at(self.span)
.type_of(param.def_id)
.instantiate(tcx, preceding_args)
.into()
} else if infer_args {
self.lowerer.ty_infer(Some(param), self.span).into()
} else {
@ -557,7 +573,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
// FIXME(effects) see if we should special case effect params here
if !infer_args && has_default {
tcx.const_param_default(param.def_id)
.instantiate(tcx, args.unwrap())
.instantiate(tcx, preceding_args)
.into()
} else {
if infer_args {
@ -571,6 +587,17 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
}
}
}
if let ty::BoundConstness::Const | ty::BoundConstness::ConstIfConst = constness
&& generics.has_self
&& !tcx.has_attr(def_id, sym::const_trait)
{
let reported = tcx.dcx().emit_err(crate::errors::ConstBoundForNonConstTrait {
span,
modifier: constness.as_str(),
});
self.set_tainted_by_errors(reported);
arg_count.correct = Err(GenericArgCountMismatch { reported, invalid_args: vec![] });
}
let mut args_ctx = GenericArgsCtxt {
lowerer: self,
@ -579,19 +606,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
generic_args: segment.args(),
inferred_params: vec![],
infer_args: segment.infer_args,
incorrect_args: &arg_count.correct,
};
if let ty::BoundConstness::Const | ty::BoundConstness::ConstIfConst = constness
&& generics.has_self
&& !tcx.has_attr(def_id, sym::const_trait)
{
let e = tcx.dcx().emit_err(crate::errors::ConstBoundForNonConstTrait {
span,
modifier: constness.as_str(),
});
self.set_tainted_by_errors(e);
arg_count.correct =
Err(GenericArgCountMismatch { reported: Some(e), invalid_args: vec![] });
}
let args = lower_generic_args(
tcx,
def_id,

2
compiler/rustc_hir_analysis/src/impl_wf_check.rs
View File

@ -86,6 +86,8 @@ fn enforce_impl_params_are_constrained(
let impl_predicates = tcx.predicates_of(impl_def_id);
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).map(ty::EarlyBinder::instantiate_identity);
impl_trait_ref.error_reported()?;
let mut input_parameters = cgp::parameters_for_impl(tcx, impl_self_ty, impl_trait_ref);
cgp::identify_constrained_generic_params(
tcx,

4
compiler/rustc_hir_typeck/src/closure.rs
View File

@ -485,7 +485,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
// Since this is a return parameter type it is safe to unwrap.
let ret_param_ty = projection.skip_binder().term.ty().unwrap();
let ret_param_ty = projection.skip_binder().term.expect_type();
let ret_param_ty = self.resolve_vars_if_possible(ret_param_ty);
debug!(?ret_param_ty);
@ -956,7 +956,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let output_ty = self.resolve_vars_if_possible(predicate.term);
debug!("deduce_future_output_from_projection: output_ty={:?}", output_ty);
// This is a projection on a Fn trait so will always be a type.
Some(output_ty.ty().unwrap())
Some(output_ty.expect_type())
}
/// Converts the types that the user supplied, in case that doing

32
compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
View File

@ -1118,7 +1118,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// to add defaults. If the user provided *too many* types, that's
// a problem.
let mut infer_args_for_err = FxHashSet::default();
let mut infer_args_for_err = None;
let mut explicit_late_bound = ExplicitLateBound::No;
for &GenericPathSegment(def_id, index) in &generic_segments {
@ -1136,9 +1136,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
explicit_late_bound = ExplicitLateBound::Yes;
}
if let Err(GenericArgCountMismatch { reported: Some(e), .. }) = arg_count.correct {
infer_args_for_err.insert(index);
self.set_tainted_by_errors(e); // See issue #53251.
if let Err(GenericArgCountMismatch { reported, .. }) = arg_count.correct {
infer_args_for_err
.get_or_insert_with(|| (reported, FxHashSet::default()))
.1
.insert(index);
self.set_tainted_by_errors(reported); // See issue #53251.
}
}
@ -1232,15 +1235,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
let def_id = res.def_id();
let arg_count = GenericArgCountResult {
explicit_late_bound,
correct: if infer_args_for_err.is_empty() {
Ok(())
} else {
Err(GenericArgCountMismatch::default())
},
let (correct, infer_args_for_err) = match infer_args_for_err {
Some((reported, args)) => {
(Err(GenericArgCountMismatch { reported, invalid_args: vec![] }), args)
}
None => (Ok(()), Default::default()),
};
let arg_count = GenericArgCountResult { explicit_late_bound, correct };
struct CtorGenericArgsCtxt<'a, 'tcx> {
fcx: &'a FnCtxt<'a, 'tcx>,
span: Span,
@ -1272,6 +1275,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn provided_kind(
&mut self,
_preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx> {
@ -1314,7 +1318,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn inferred_kind(
&mut self,
args: Option<&[ty::GenericArg<'tcx>]>,
preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
infer_args: bool,
) -> ty::GenericArg<'tcx> {
@ -1328,7 +1332,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// If we have a default, then it doesn't matter that we're not
// inferring the type arguments: we provide the default where any
// is missing.
tcx.type_of(param.def_id).instantiate(tcx, args.unwrap()).into()
tcx.type_of(param.def_id).instantiate(tcx, preceding_args).into()
} else {
// If no type arguments were provided, we have to infer them.
// This case also occurs as a result of some malformed input, e.g.
@ -1353,7 +1357,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} else if !infer_args {
return tcx
.const_param_default(param.def_id)
.instantiate(tcx, args.unwrap())
.instantiate(tcx, preceding_args)
.into();
}
}

3
compiler/rustc_hir_typeck/src/method/confirm.rs
View File

@ -383,6 +383,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
fn provided_kind(
&mut self,
_preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
arg: &GenericArg<'tcx>,
) -> ty::GenericArg<'tcx> {
@ -419,7 +420,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
fn inferred_kind(
&mut self,
_args: Option<&[ty::GenericArg<'tcx>]>,
_preceding_args: &[ty::GenericArg<'tcx>],
param: &ty::GenericParamDef,
_infer_args: bool,
) -> ty::GenericArg<'tcx> {

2
compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
View File

@ -160,7 +160,7 @@ impl<'tcx> TypeckRootCtxt<'tcx> {
{
// If the projection predicate (Foo::Bar == X) has X as a non-TyVid,
// we need to make it into one.
if let Some(vid) = predicate.term.ty().and_then(|ty| ty.ty_vid()) {
if let Some(vid) = predicate.term.as_type().and_then(|ty| ty.ty_vid()) {
debug!("infer_var_info: {:?}.output = true", vid);
infer_var_info.entry(vid).or_default().output = true;
}

2
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View File

@ -425,7 +425,7 @@ impl<'tcx> InferCtxt<'tcx> {
ty::ClauseKind::Projection(projection_predicate)
if projection_predicate.projection_term.def_id == item_def_id =>
{
projection_predicate.term.ty()
projection_predicate.term.as_type()
}
_ => None,
})

4
compiler/rustc_infer/src/infer/mod.rs
View File

@ -424,8 +424,8 @@ pub enum ValuePairs<'tcx> {
impl<'tcx> ValuePairs<'tcx> {
pub fn ty(&self) -> Option<(Ty<'tcx>, Ty<'tcx>)> {
if let ValuePairs::Terms(ExpectedFound { expected, found }) = self
&& let Some(expected) = expected.ty()
&& let Some(found) = found.ty()
&& let Some(expected) = expected.as_type()
&& let Some(found) = found.as_type()
{
Some((expected, found))
} else {

2
compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs
View File

@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound {
};
// Only check types, since those are the only things that may
// have opaques in them anyways.
let Some(proj_term) = proj.term.ty() else { return };
let Some(proj_term) = proj.term.as_type() else { return };
// HACK: `impl Trait<Assoc = impl Trait2>` from an RPIT is "ok"...
if let ty::Alias(ty::Opaque, opaque_ty) = *proj_term.kind()

12
compiler/rustc_middle/src/ty/mod.rs
View File

@ -624,14 +624,22 @@ impl<'tcx> Term<'tcx> {
}
}
pub fn ty(&self) -> Option<Ty<'tcx>> {
pub fn as_type(&self) -> Option<Ty<'tcx>> {
if let TermKind::Ty(ty) = self.unpack() { Some(ty) } else { None }
}
pub fn ct(&self) -> Option<Const<'tcx>> {
pub fn expect_type(&self) -> Ty<'tcx> {
self.as_type().expect("expected a type, but found a const")
}
pub fn as_const(&self) -> Option<Const<'tcx>> {
if let TermKind::Const(c) = self.unpack() { Some(c) } else { None }
}
pub fn expect_const(&self) -> Const<'tcx> {
self.as_const().expect("expected a const, but found a type")
}
pub fn into_arg(self) -> GenericArg<'tcx> {
match self.unpack() {
TermKind::Ty(ty) => ty.into(),

6
compiler/rustc_middle/src/ty/print/pretty.rs
View File

@ -1077,7 +1077,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
}
p!(")");
if let Some(ty) = return_ty.skip_binder().ty() {
if let Some(ty) = return_ty.skip_binder().as_type() {
if !ty.is_unit() {
p!(" -> ", print(return_ty));
}
@ -1144,7 +1144,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
for (assoc_item_def_id, term) in assoc_items {
// Skip printing `<{coroutine@} as Coroutine<_>>::Return` from async blocks,
// unless we can find out what coroutine return type it comes from.
let term = if let Some(ty) = term.skip_binder().ty()
let term = if let Some(ty) = term.skip_binder().as_type()
&& let ty::Alias(ty::Projection, proj) = ty.kind()
&& let Some(assoc) = tcx.opt_associated_item(proj.def_id)
&& assoc.trait_container(tcx) == tcx.lang_items().coroutine_trait()
@ -1322,7 +1322,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
p!(pretty_fn_sig(
tys,
false,
proj.skip_binder().term.ty().expect("Return type was a const")
proj.skip_binder().term.as_type().expect("Return type was a const")
));
resugared = true;
}

2
compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
View File

@ -726,7 +726,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReplaceProjectionWith<'_, 'tcx> {
)
.expect("expected to be able to unify goal projection with dyn's projection"),
);
proj.term.ty().unwrap()
proj.term.expect_type()
} else {
ty.super_fold_with(self)
}

2
compiler/rustc_trait_selection/src/solve/normalizes_to/opaque_types.rs
View File

@ -17,7 +17,7 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
) -> QueryResult<'tcx> {
let tcx = self.interner();
let opaque_ty = goal.predicate.alias;
let expected = goal.predicate.term.ty().expect("no such thing as an opaque const");
let expected = goal.predicate.term.as_type().expect("no such thing as an opaque const");
match (goal.param_env.reveal(), self.solver_mode()) {
(Reveal::UserFacing, SolverMode::Normal) => {

2
compiler/rustc_trait_selection/src/traits/auto_trait.rs
View File

@ -553,7 +553,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
}
fn is_self_referential_projection(&self, p: ty::PolyProjectionPredicate<'tcx>) -> bool {
if let Some(ty) = p.term().skip_binder().ty() {
if let Some(ty) = p.term().skip_binder().as_type() {
matches!(ty.kind(), ty::Alias(ty::Projection, proj) if proj == &p.skip_binder().projection_term.expect_ty(self.tcx))
} else {
false

8
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -1112,7 +1112,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
{
Some((
DefIdOrName::DefId(def_id),
pred.kind().rebind(proj.term.ty().unwrap()),
pred.kind().rebind(proj.term.expect_type()),
pred.kind().rebind(args.as_slice()),
))
} else {
@ -1129,7 +1129,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
{
Some((
DefIdOrName::Name("trait object"),
pred.rebind(proj.term.ty().unwrap()),
pred.rebind(proj.term.expect_type()),
pred.rebind(args.as_slice()),
))
} else {
@ -1157,7 +1157,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
{
Some((
name,
pred.kind().rebind(proj.term.ty().unwrap()),
pred.kind().rebind(proj.term.expect_type()),
pred.kind().rebind(args.as_slice()),
))
} else {
@ -3840,7 +3840,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
})
} else if let Some(where_pred) = where_pred.as_projection_clause()
&& let Some(failed_pred) = failed_pred.as_projection_clause()
&& let Some(found) = failed_pred.skip_binder().term.ty()
&& let Some(found) = failed_pred.skip_binder().term.as_type()
{
type_diffs = vec![Sorts(ty::error::ExpectedFound {
expected: where_pred

4
compiler/rustc_trait_selection/src/traits/normalize.rs
View File

@ -259,7 +259,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
obligations.len = ?self.obligations.len(),
"AssocTypeNormalizer: normalized type"
);
normalized_ty.ty().unwrap()
normalized_ty.expect_type()
}
ty::Projection => {
@ -289,7 +289,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
)
.ok()
.flatten()
.map(|term| term.ty().unwrap())
.map(|term| term.expect_type())
.map(|normalized_ty| {
PlaceholderReplacer::replace_placeholders(
infcx,

2
compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
View File

@ -946,7 +946,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// since we don't actually use them.
&mut vec![],
)
.ty()
.as_type()
.unwrap();
if let ty::Dynamic(data, ..) = ty.kind() { data.principal() } else { None }

2
compiler/rustc_trait_selection/src/traits/wf.rs
View File

@ -286,7 +286,7 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
// implemented, but rather from a "second order" obligation, where an associated
// type has a projection coming from another associated type.
// See `tests/ui/traits/assoc-type-in-superbad.rs` for an example.
if let Some(term_ty) = proj.term.ty()
if let Some(term_ty) = proj.term.as_type()
&& let Some(impl_item_span) = ty_to_impl_span(term_ty)
{
cause.span = impl_item_span;

2
compiler/rustc_traits/src/normalize_projection_ty.rs
View File

@ -58,7 +58,7 @@ fn normalize_canonicalized_projection_ty<'tcx>(
// FIXME(associated_const_equality): All users of normalize_canonicalized_projection_ty
// expected a type, but there is the possibility it could've been a const now.
// Maybe change it to a Term later?
Ok(NormalizationResult { normalized_ty: answer.ty().unwrap() })
Ok(NormalizationResult { normalized_ty: answer.expect_type() })
},
)
}

4
library/core/src/cell/once.rs
View File

@ -2,12 +2,12 @@ use crate::cell::UnsafeCell;
use crate::fmt;
use crate::mem;
/// A cell which can be written to only once.
/// A cell which can nominally be written to only once.
///
/// This allows obtaining a shared `&T` reference to its inner value without copying or replacing
/// it (unlike [`Cell`]), and without runtime borrow checks (unlike [`RefCell`]). However,
/// only immutable references can be obtained unless one has a mutable reference to the cell
/// itself.
/// itself. In the same vein, the cell can only be re-initialized with such a mutable reference.
///
/// For a thread-safe version of this struct, see [`std::sync::OnceLock`].
///

2
library/std/src/sync/once_lock.rs
View File

@ -5,7 +5,7 @@ use crate::mem::MaybeUninit;
use crate::panic::{RefUnwindSafe, UnwindSafe};
use crate::sync::Once;
/// A synchronization primitive which can be written to only once.
/// A synchronization primitive which can nominally be written to only once.
///
/// This type is a thread-safe [`OnceCell`], and can be used in statics.
///

3
library/std/src/sys/pal/unix/fs.rs
View File

@ -1910,8 +1910,7 @@ pub fn copy(from: &Path, to: &Path) -> io::Result<u64> {
// The code below ensures that `FreeOnDrop` is never a null pointer
unsafe {
// `copyfile_state_free` returns -1 if the `to` or `from` files
// cannot be closed. However, this is not considered this an
// error.
// cannot be closed. However, this is not considered an error.
libc::copyfile_state_free(self.0);
}
}

18
src/doc/rustc/src/SUMMARY.md
View File

@ -30,10 +30,15 @@
- [aarch64-nintendo-switch-freestanding](platform-support/aarch64-nintendo-switch-freestanding.md)
- [armeb-unknown-linux-gnueabi](platform-support/armeb-unknown-linux-gnueabi.md)
- [arm-none-eabi](platform-support/arm-none-eabi.md)
- [armv4t-none-eabi](platform-support/armv4t-none-eabi.md)
- [armv5te-none-eabi](platform-support/armv5te-none-eabi.md)
- [armv7r-none-eabi](platform-support/armv7r-none-eabi.md)
- [armv8r-none-eabihf](platform-support/armv8r-none-eabihf.md)
- [armv4t-none-eabi](platform-support/armv4t-none-eabi.md)
- [armv5te-none-eabi](platform-support/armv5te-none-eabi.md)
- [armv7r-none-eabi](platform-support/armv7r-none-eabi.md)
- [armv8r-none-eabihf](platform-support/armv8r-none-eabihf.md)
- [thumbv6m-none-eabi](./platform-support/thumbv6m-none-eabi.md)
- [thumbv7em-none-eabi\*](./platform-support/thumbv7em-none-eabi.md)
- [thumbv7m-none-eabi](./platform-support/thumbv7m-none-eabi.md)
- [thumbv8m.base-none-eabi](./platform-support/thumbv8m.base-none-eabi.md)
- [thumbv8m.main-none-eabi\*](./platform-support/thumbv8m.main-none-eabi.md)
- [armv6k-nintendo-3ds](platform-support/armv6k-nintendo-3ds.md)
- [armv7-sony-vita-newlibeabihf](platform-support/armv7-sony-vita-newlibeabihf.md)
- [armv7-unknown-linux-uclibceabi](platform-support/armv7-unknown-linux-uclibceabi.md)
@ -60,11 +65,6 @@
- [riscv32imac-unknown-xous-elf](platform-support/riscv32imac-unknown-xous-elf.md)
- [riscv32*-unknown-none-elf](platform-support/riscv32-unknown-none-elf.md)
- [sparc-unknown-none-elf](./platform-support/sparc-unknown-none-elf.md)
- [thumbv6m-none-eabi](./platform-support/thumbv6m-none-eabi.md)
- [thumbv7m-none-eabi](./platform-support/thumbv7m-none-eabi.md)
- [thumbv7em-none-eabi\*](./platform-support/thumbv7em-none-eabi.md)
- [thumbv8m.base-none-eabi](./platform-support/thumbv8m.base-none-eabi.md)
- [thumbv8m.main-none-eabi\*](./platform-support/thumbv8m.main-none-eabi.md)
- [*-pc-windows-gnullvm](platform-support/pc-windows-gnullvm.md)
- [\*-nto-qnx-\*](platform-support/nto-qnx.md)
- [*-unikraft-linux-musl](platform-support/unikraft-linux-musl.md)

28
src/doc/rustc/src/platform-support/arm-none-eabi.md
View File

@ -1,6 +1,15 @@
# `{arm,thumb}*-none-eabi(hf)?`
## Tier 2 Target List
## Common Target Details
This documentation covers details that apply to a range of bare-metal targets
for 32-bit Arm CPUs. The `arm-none-eabi` flavor of the GNU compiler toolchain is
often used to assist compilation to these targets.
Details that apply only to only a specific target in this group are covered in
their own document.
### Tier 2 Target List
- Arm A-Profile Architectures
- `armv7a-none-eabi`
@ -16,7 +25,7 @@
- *Legacy* Arm Architectures
- None
## Tier 3 Target List
### Tier 3 Target List
- Arm A-Profile Architectures
- `armv7a-none-eabihf`
@ -28,24 +37,21 @@
- [`armv4t-none-eabi` and `thumbv4t-none-eabi`](armv4t-none-eabi.md)
- [`armv5te-none-eabi` and `thumbv5te-none-eabi`](armv5te-none-eabi.md)
## Common Target Details
This documentation covers details that apply to a range of bare-metal targets
for 32-bit Arm CPUs. In addition, target specific details may be covered in
their own document.
## Instruction Sets
There are two 32-bit instruction set architectures (ISAs) defined by Arm:
- The [*A32 ISA*][a32-isa], with fixed-width 32-bit instructions. Previously
known as the *Arm* ISA, this originated with the original ARM1 of 1985 and has
known as the *Arm* ISA, this originated with the original Arm1 of 1985 and has
been updated by various revisions to the architecture specifications ever
since.
- The [*T32 ISA*][t32-isa], with a mix of 16-bit and 32-bit width instructions.
Note that this term includes both the original 16-bit width *Thumb* ISA
introduced with the Armv4T architecture in 1994, and the later 16/32-bit sized
*Thumb-2* ISA introduced with the Armv6T2 architecture in 2003. Again, these
ISAs have been revised by subsequent revisions to the relevant Arm
architecture specifications.
*Thumb-2* ISA introduced with the Armv6T2 architecture in 2003.
Again, these ISAs have been revised by subsequent revisions to the relevant Arm
architecture specifications.
There is also a 64-bit ISA with fixed-width 32-bit instructions called the *A64
ISA*, but targets which implement that instruction set generally start with

21
src/doc/rustc/src/platform-support/armv4t-none-eabi.md
View File

@ -1,16 +1,13 @@
# armv4t-none-eabi
# armv4t-none-eabi / thumbv4t-none-eabi
Tier 3
Bare-metal target for any cpu in the Armv4T architecture family, supporting
ARM/Thumb code interworking (aka `A32`/`T32`), with ARM code as the default code
generation.
These two targets are part of the [`arm-none-eabi`](arm-none-eabi.md) target
group, and all the information there applies.
In particular this supports the Game Boy Advance (GBA), but there's nothing
GBA-specific with this target, so any Armv4T device should work fine.
See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
`arm-none-eabi` targets.
Both of these targets can be used on the Game Boy Advance (GBA), among other
things. On the GBA, one should usually use the `thumb` target to get the best
overall performance.
## Target Maintainers
@ -23,6 +20,6 @@ This is a cross-compiled target that you will need to emulate during testing.
Because this is a device-agnostic target, and the exact emulator that you'll
need depends on the specific device you want to run your code on.
For example, when programming for the Gameboy Advance, the
[mgba-test-runner](https://github.com/agbrs/agb) program could be used to make a
normal set of rust tests be run within the `mgba` emulator.
* When building for the GBA, [mgba-test-runner](https://github.com/agbrs/agb)
can be used to make a normal set of rust tests be run within the `mgba`
emulator.

3
src/doc/unstable-book/src/compiler-flags/print-check-cfg.md
View File

@ -1,6 +1,6 @@
# `print=check-cfg`
The tracking issue for this feature is: [#XXXXXX](https://github.com/rust-lang/rust/issues/XXXXXX).
The tracking issue for this feature is: [#125704](https://github.com/rust-lang/rust/issues/125704).
------------------------
@ -15,6 +15,7 @@ This print option works similarly to `--print=cfg` (modulo check-cfg specifics):
- `cfg(feature, values("foo", "bar"))`: `feature="foo"` and `feature="bar"`
- `cfg(feature, values(none(), ""))`: `feature` and `feature=""`
- `cfg(feature, values(any()))`: `feature=any()`
- `cfg(feature, values())`: `feature=`
- `cfg(any())`: `any()`
- *nothing*: `any()=any()`

19
src/doc/unstable-book/src/language-features/abi-vectorcall.md Normal file
View File

@ -0,0 +1,19 @@
# `abi_vectorcall`
The tracking issue for this feature is: [#124485]
[#124485]: https://github.com/rust-lang/rust/issues/124485
------------------------
Adds support for the Windows `"vectorcall"` ABI, the equivalent of `__vectorcall` in MSVC.
```rust,ignore (only-windows-or-x86-or-x86-64)
extern "vectorcall" {
fn add_f64s(x: f64, y: f64) -> f64;
}
fn main() {
println!("{}", add_f64s(2.0, 4.0));
}
```

2
src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
View File

@ -42,7 +42,7 @@ fn is_arg_ty_unified_in_fn<'tcx>(
cx.tcx.predicates_of(fn_id).predicates.iter().any(|(clause, _)| {
clause
.as_projection_clause()
.and_then(|p| p.map_bound(|p| p.term.ty()).transpose())
.and_then(|p| p.map_bound(|p| p.term.as_type()).transpose())
.is_some_and(|ty| ty.skip_binder() == arg_ty_in_args)
}) || fn_sig
.inputs()

4
src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
View File

@ -311,7 +311,7 @@ fn is_mixed_projection_predicate<'tcx>(
) -> bool {
let generics = cx.tcx.generics_of(callee_def_id);
// The predicate requires the projected type to equal a type parameter from the parent context.
if let Some(term_ty) = projection_predicate.term.ty()
if let Some(term_ty) = projection_predicate.term.as_type()
&& let ty::Param(term_param_ty) = term_ty.kind()
&& (term_param_ty.index as usize) < generics.parent_count
{
@ -370,7 +370,7 @@ fn replace_types<'tcx>(
if replaced.insert(param_ty.index) {
for projection_predicate in projection_predicates {
if projection_predicate.projection_term.self_ty() == param_ty.to_ty(cx.tcx)
&& let Some(term_ty) = projection_predicate.term.ty()
&& let Some(term_ty) = projection_predicate.term.as_type()
&& let ty::Param(term_param_ty) = term_ty.kind()
{
let projection = projection_predicate

4
src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs
View File

@ -100,12 +100,12 @@ fn get_args_to_check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Ve
{
if ord_preds
.iter()
.any(|ord| Some(ord.self_ty()) == return_ty_pred.term.ty())
.any(|ord| Some(ord.self_ty()) == return_ty_pred.term.as_type())
{
args_to_check.push((i, "Ord".to_string()));
} else if partial_ord_preds
.iter()
.any(|pord| pord.self_ty() == return_ty_pred.term.ty().unwrap())
.any(|pord| pord.self_ty() == return_ty_pred.term.expect_type())
{
args_to_check.push((i, "PartialOrd".to_string()));
}

6
src/tools/clippy/clippy_utils/src/ty.rs
View File

@ -750,7 +750,7 @@ pub fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'t
let output = bounds
.projection_bounds()
.find(|p| lang_items.fn_once_output().map_or(false, |id| id == p.item_def_id()))
.map(|p| p.map_bound(|p| p.term.ty().unwrap()));
.map(|p| p.map_bound(|p| p.term.expect_type()));
Some(ExprFnSig::Trait(bound.map_bound(|b| b.args.type_at(0)), output, None))
},
_ => None,
@ -798,7 +798,7 @@ fn sig_from_bounds<'tcx>(
// Multiple different fn trait impls. Is this even allowed?
return None;
}
output = Some(pred.kind().rebind(p.term.ty().unwrap()));
output = Some(pred.kind().rebind(p.term.expect_type()));
},
_ => (),
}
@ -836,7 +836,7 @@ fn sig_for_projection<'tcx>(cx: &LateContext<'tcx>, ty: AliasTy<'tcx>) -> Option
// Multiple different fn trait impls. Is this even allowed?
return None;
}
output = pred.kind().rebind(p.term.ty()).transpose();
output = pred.kind().rebind(p.term.as_type()).transpose();
},
_ => (),
}

20
tests/crashes/121134.rs
View File

@ -1,20 +0,0 @@
//@ known-bug: #121134
trait Output<'a> {
type Type;
}
struct Wrapper;
impl Wrapper {
fn do_something_wrapper<O, F>(&mut self, do_something_wrapper: F)
where
FnOnce:,
F: for<'a> FnOnce(<F as Output<i32, _>>::Type),
{
}
}
fn main() {
let mut wrapper = Wrapper;
wrapper.do_something_wrapper::<i32, _>(|value| ());
}

41
tests/crashes/123917.rs
View File

@ -1,41 +0,0 @@
//@ known-bug: #123917
//@ compile-flags: -Zmir-opt-level=5 -Zpolymorphize=on
use std::marker::PhantomData;
pub struct Id<'id>();
pub struct Item<'life, T> {
data: T,
}
pub struct Token<'life, 'borrow, 'compact, 'reborrow, T>
where
'life: 'reborrow,
T: Tokenize,
{
ptr: *mut <T as Tokenize>::Tokenized,
ptr: core::ptr::NonNull<T::Tokenized>,
_phantom: PhantomData<Id<'life>>,
}
impl<'life> Arena<'life> {
pub fn tokenize<'before, 'compact, 'borrow, 'reborrow, T, U>(
item: Item<'life, &'before mut T>,
) -> Token<'life, 'borrow, 'compact, 'reborrow, U>
where
T: Tokenize<'life, 'borrow, 'compact, 'reborrow, Untokenized = U>,
T::Untokenized: Tokenize<'life, 'borrow, 'compact, 'reborrow>,
{
let dst = item.data as *mut T as *mut T::Tokenized;
Token {
ptr: core::ptr::NonNull::new(dst as *mut _).unwrap(),
_phantom: PhantomData,
}
}
}
pub trait Tokenize {
type Tokenized;
type Untokenized;
}

14
tests/run-make/print-check-cfg/rmake.rs
View File

@ -48,6 +48,20 @@ fn main() {
doesnt_contain: &["any()", "any()=any()", "feature=none()", "feature="],
},
});
check(CheckCfg {
args: &["--check-cfg=cfg(feature, values())"],
contains: Contains::Some {
contains: &["feature="],
doesnt_contain: &["any()", "any()=any()", "feature=none()", "feature"],
},
});
check(CheckCfg {
args: &["--check-cfg=cfg(feature, values())", "--check-cfg=cfg(feature, values(none()))"],
contains: Contains::Some {
contains: &["feature"],
doesnt_contain: &["any()", "any()=any()", "feature=none()", "feature="],
},
});
check(CheckCfg {
args: &[
r#"--check-cfg=cfg(feature, values(any()))"#,

19
tests/rustdoc-ui/ice-blanket-impl-119792.rs Normal file
View File

@ -0,0 +1,19 @@
//@ check-pass
// https://github.com/rust-lang/rust/issues/119792
struct Wrapper<T>(T);
trait Div<Rhs> {}
trait Mul<Rhs> {
type Output;
}
impl<T> Mul<T> for Wrapper<T> {
type Output = ();
}
impl<T> Div<Self> for Wrapper<T> {}
pub trait NumOps<Rhs> {}
impl<T, Rhs> NumOps<Rhs> for T where T: Mul<Rhs, Output = ()> + Div<Rhs> {}

1
tests/ui/const-generics/adt_const_params/transmutable-ice-110969.rs
View File

@ -24,7 +24,6 @@ fn via_associated_const() {
trait Trait {
const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
//~^ ERROR mismatched types
//~| ERROR `Src` cannot be safely transmuted into `Dst`
//~| ERROR mismatched types
}
}

19
tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr
View File

@ -12,28 +12,13 @@ error[E0308]: mismatched types
LL | const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
| ^^ expected `Assume`, found `()`
error[E0277]: `Src` cannot be safely transmuted into `Dst`
--> $DIR/transmutable-ice-110969.rs:25:60
|
LL | const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
| ^^^ `Dst` may carry safety invariants
|
note: required by a bound in `is_transmutable`
--> $DIR/transmutable-ice-110969.rs:11:14
|
LL | pub fn is_transmutable<Src, Dst, Context, const ASSUME: std::mem::Assume>()
| --------------- required by a bound in this function
LL | where
LL | Dst: BikeshedIntrinsicFrom<Src, Context, ASSUME>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0308]: mismatched types
--> $DIR/transmutable-ice-110969.rs:25:29
|
LL | const FALSE: bool = assert::is_transmutable::<Src, Dst, Context, {}>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
error: aborting due to 4 previous errors
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0107, E0277, E0308.
Some errors have detailed explanations: E0107, E0308.
For more information about an error, try `rustc --explain E0107`.

7
tests/ui/feature-gates/feature-gate-vectorcall.stderr
View File

@ -4,6 +4,7 @@ error[E0658]: vectorcall is experimental and subject to change
LL | extern "vectorcall" fn f() {}
| ^^^^^^^^^^^^
|
= note: see issue #124485 <https://github.com/rust-lang/rust/issues/124485> for more information
= help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@ -13,6 +14,7 @@ error[E0658]: vectorcall is experimental and subject to change
LL | extern "vectorcall" fn m();
| ^^^^^^^^^^^^
|
= note: see issue #124485 <https://github.com/rust-lang/rust/issues/124485> for more information
= help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@ -22,6 +24,7 @@ error[E0658]: vectorcall is experimental and subject to change
LL | extern "vectorcall" fn dm() {}
| ^^^^^^^^^^^^
|
= note: see issue #124485 <https://github.com/rust-lang/rust/issues/124485> for more information
= help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@ -31,6 +34,7 @@ error[E0658]: vectorcall is experimental and subject to change
LL | extern "vectorcall" fn m() {}
| ^^^^^^^^^^^^
|
= note: see issue #124485 <https://github.com/rust-lang/rust/issues/124485> for more information
= help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@ -40,6 +44,7 @@ error[E0658]: vectorcall is experimental and subject to change
LL | extern "vectorcall" fn im() {}
| ^^^^^^^^^^^^
|
= note: see issue #124485 <https://github.com/rust-lang/rust/issues/124485> for more information
= help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@ -49,6 +54,7 @@ error[E0658]: vectorcall is experimental and subject to change
LL | type TA = extern "vectorcall" fn();
| ^^^^^^^^^^^^
|
= note: see issue #124485 <https://github.com/rust-lang/rust/issues/124485> for more information
= help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@ -58,6 +64,7 @@ error[E0658]: vectorcall is experimental and subject to change
LL | extern "vectorcall" {}
| ^^^^^^^^^^^^
|
= note: see issue #124485 <https://github.com/rust-lang/rust/issues/124485> for more information
= help: add `#![feature(abi_vectorcall)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date

23
tests/ui/lifetimes/noisy-follow-up-erro.rs Normal file
View File

@ -0,0 +1,23 @@
struct Foo<'c, 'd>(&'c (), &'d ());
impl<'c, 'd> Foo<'c, 'd> {
fn acc(&mut self, _bar: &Bar) -> &'d () {
todo!()
}
}
struct Bar;
impl<'a> Bar {
fn boom(&self, foo: &mut Foo<'_, '_, 'a>) -> Result<(), &'a ()> {
//~^ ERROR: struct takes 2 lifetime arguments but 3 lifetime arguments were supplied
self.bar().map_err(|()| foo.acc(self))?;
//~^ ERROR: explicit lifetime required in the type of `foo`
Ok(())
}
fn bar(&self) -> Result<(), &'a ()> {
todo!()
}
}
fn main() {}

27
tests/ui/lifetimes/noisy-follow-up-erro.stderr Normal file
View File

@ -0,0 +1,27 @@
error[E0107]: struct takes 2 lifetime arguments but 3 lifetime arguments were supplied
--> $DIR/noisy-follow-up-erro.rs:12:30
|
LL | fn boom(&self, foo: &mut Foo<'_, '_, 'a>) -> Result<(), &'a ()> {
| ^^^ -- help: remove this lifetime argument
| |
| expected 2 lifetime arguments
|
note: struct defined here, with 2 lifetime parameters: `'c`, `'d`
--> $DIR/noisy-follow-up-erro.rs:1:8
|
LL | struct Foo<'c, 'd>(&'c (), &'d ());
| ^^^ -- --
error[E0621]: explicit lifetime required in the type of `foo`
--> $DIR/noisy-follow-up-erro.rs:14:9
|
LL | fn boom(&self, foo: &mut Foo<'_, '_, 'a>) -> Result<(), &'a ()> {
| -------------------- help: add explicit lifetime `'a` to the type of `foo`: `&mut Foo<'_, 'a>`
LL |
LL | self.bar().map_err(|()| foo.acc(self))?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetime `'a` required
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0107, E0621.
For more information about an error, try `rustc --explain E0107`.

20
tests/ui/polymorphization/abi_mismatch.rs Normal file
View File

@ -0,0 +1,20 @@
//! This test used to ICE: #123917
//! The reason was that while the AST knows about two fields
//! named `ptr`, only one exists at the layout level, so accessing
//! `_extra_field` would use an oob index
//@ compile-flags: -Zmir-opt-level=5 -Zpolymorphize=on
struct NonNull<T>(*mut T);
struct Token<T> {
ptr: *mut T,
ptr: NonNull<T>,
//~^ ERROR: `ptr` is already declared
_extra_field: (),
}
fn tokenize<T>(item: *mut T) -> Token<T> {
Token { ptr: NonNull(item), _extra_field: () }
}
fn main() {}

11
tests/ui/polymorphization/abi_mismatch.stderr Normal file
View File

@ -0,0 +1,11 @@
error[E0124]: field `ptr` is already declared
--> $DIR/abi_mismatch.rs:11:5
|
LL | ptr: *mut T,
| ----------- `ptr` first declared here
LL | ptr: NonNull<T>,
| ^^^^^^^^^^^^^^^ field already declared
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0124`.

2
tests/ui/traits/associated_type_bound/116464-invalid-assoc-type-suggestion-in-trait-impl.rs
View File

@ -14,14 +14,12 @@ impl<T, S> Trait<T> for i32 {
// Should not not trigger suggestion here...
impl<T, S> Trait<T, S> for () {}
//~^ ERROR trait takes 1 generic argument but 2 generic arguments were supplied
//~| ERROR `S` is not constrained
//... but should do so in all of the below cases except the last one
fn func<T: Trait<u32, String>>(t: T) -> impl Trait<(), i32> {
//~^ ERROR trait takes 1 generic argument but 2 generic arguments were supplied
//~| ERROR trait takes 1 generic argument but 2 generic arguments were supplied
//~| ERROR trait takes 1 generic argument but 2 generic arguments were supplied
//~| ERROR type annotations needed
3
}

32
tests/ui/traits/associated_type_bound/116464-invalid-assoc-type-suggestion-in-trait-impl.stderr
View File

@ -16,14 +16,8 @@ note: trait defined here, with 1 generic parameter: `T`
LL | pub trait Trait<T> {
| ^^^^^ -
error[E0207]: the type parameter `S` is not constrained by the impl trait, self type, or predicates
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:15:9
|
LL | impl<T, S> Trait<T, S> for () {}
| ^ unconstrained type parameter
error[E0107]: trait takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:20:12
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:19:12
|
LL | fn func<T: Trait<u32, String>>(t: T) -> impl Trait<(), i32> {
| ^^^^^ expected 1 generic argument
@ -39,7 +33,7 @@ LL | fn func<T: Trait<u32, Assoc = String>>(t: T) -> impl Trait<(), i32> {
| +++++++
error[E0107]: trait takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:20:46
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:19:46
|
LL | fn func<T: Trait<u32, String>>(t: T) -> impl Trait<(), i32> {
| ^^^^^ expected 1 generic argument
@ -55,7 +49,7 @@ LL | fn func<T: Trait<u32, String>>(t: T) -> impl Trait<(), Assoc = i32> {
| +++++++
error[E0107]: trait takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:20:46
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:19:46
|
LL | fn func<T: Trait<u32, String>>(t: T) -> impl Trait<(), i32> {
| ^^^^^ expected 1 generic argument
@ -71,14 +65,8 @@ help: replace the generic bound with the associated type
LL | fn func<T: Trait<u32, String>>(t: T) -> impl Trait<(), Assoc = i32> {
| +++++++
error[E0282]: type annotations needed
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:20:41
|
LL | fn func<T: Trait<u32, String>>(t: T) -> impl Trait<(), i32> {
| ^^^^^^^^^^^^^^^^^^^ cannot infer type
error[E0107]: trait takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:28:18
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:26:18
|
LL | struct Struct<T: Trait<u32, String>> {
| ^^^^^ expected 1 generic argument
@ -94,7 +82,7 @@ LL | struct Struct<T: Trait<u32, Assoc = String>> {
| +++++++
error[E0107]: trait takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:33:23
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:31:23
|
LL | trait AnotherTrait<T: Trait<T, i32>> {}
| ^^^^^ expected 1 generic argument
@ -110,7 +98,7 @@ LL | trait AnotherTrait<T: Trait<T, Assoc = i32>> {}
| +++++++
error[E0107]: trait takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:36:9
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:34:9
|
LL | impl<T: Trait<u32, String>> Struct<T> {}
| ^^^^^ expected 1 generic argument
@ -126,7 +114,7 @@ LL | impl<T: Trait<u32, Assoc = String>> Struct<T> {}
| +++++++
error[E0107]: struct takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:42:58
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:40:58
|
LL | impl<T: Trait<u32, Assoc=String>, U> YetAnotherTrait for Struct<T, U> {}
| ^^^^^^ - help: remove this generic argument
@ -134,12 +122,12 @@ LL | impl<T: Trait<u32, Assoc=String>, U> YetAnotherTrait for Struct<T, U> {}
| expected 1 generic argument
|
note: struct defined here, with 1 generic parameter: `T`
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:28:8
--> $DIR/116464-invalid-assoc-type-suggestion-in-trait-impl.rs:26:8
|
LL | struct Struct<T: Trait<u32, String>> {
| ^^^^^^ -
error: aborting due to 11 previous errors
error: aborting due to 9 previous errors
Some errors have detailed explanations: E0107, E0207, E0282.
Some errors have detailed explanations: E0107, E0207.
For more information about an error, try `rustc --explain E0107`.

27
tests/ui/traits/generic_param_mismatch_in_unsatisfied_projection.rs Normal file
View File

@ -0,0 +1,27 @@
//! This test used to ICE: #121134
//! The issue is that we're trying to prove a projection, but there's
//! no bound for the projection's trait, and the projection has the wrong
//! kind of generic parameter (lifetime vs type).
//! When actually calling the function with those broken bounds, trying to
//! instantiate the bounds with inference vars would ICE.
#![feature(unboxed_closures)]
trait Output<'a> {
type Type;
}
struct Wrapper;
impl Wrapper {
fn do_something_wrapper<O, F>(&mut self, _: F)
where
F: for<'a> FnOnce(<F as Output<i32>>::Type),
//~^ ERROR: trait takes 0 generic arguments but 1 generic argument was supplied
{
}
}
fn main() {
let mut wrapper = Wrapper;
wrapper.do_something_wrapper(|value| ());
}

19
tests/ui/traits/generic_param_mismatch_in_unsatisfied_projection.stderr Normal file
View File

@ -0,0 +1,19 @@
error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/generic_param_mismatch_in_unsatisfied_projection.rs:18:33
|
LL | F: for<'a> FnOnce(<F as Output<i32>>::Type),
| ^^^^^^ expected 0 generic arguments
|
note: trait defined here, with 0 generic parameters
--> $DIR/generic_param_mismatch_in_unsatisfied_projection.rs:9:7
|
LL | trait Output<'a> {
| ^^^^^^
help: replace the generic bound with the associated type
|
LL | F: for<'a> FnOnce(<F as Output<Type = i32>>::Type),
| ++++++
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0107`.

12
tests/ui/traits/issue-78372.stderr
View File

@ -55,12 +55,6 @@ LL | impl<T> DispatchFromDyn<Smaht<U, MISC>> for T {}
= help: add `#![feature(dispatch_from_dyn)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0378]: the trait `DispatchFromDyn` may only be implemented for a coercion between structures
--> $DIR/issue-78372.rs:3:1
|
LL | impl<T> DispatchFromDyn<Smaht<U, MISC>> for T {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0038]: the trait `Foo` cannot be made into an object
--> $DIR/issue-78372.rs:12:17
|
@ -88,6 +82,12 @@ LL | fn foo(self: Smaht<Self, T>);
= note: type of `self` must be `Self` or a type that dereferences to it
= help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
error[E0378]: the trait `DispatchFromDyn` may only be implemented for a coercion between structures
--> $DIR/issue-78372.rs:3:1
|
LL | impl<T> DispatchFromDyn<Smaht<U, MISC>> for T {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 8 previous errors
Some errors have detailed explanations: E0038, E0307, E0378, E0412, E0658.

1
tests/ui/transmutability/issue-101739-2.rs
View File

@ -15,7 +15,6 @@ mod assert {
>()
where
Dst: BikeshedIntrinsicFrom< //~ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
//~^ ERROR: the constant `ASSUME_ALIGNMENT` is not of type `Assume`
Src,
ASSUME_ALIGNMENT, //~ ERROR: mismatched types
ASSUME_LIFETIMES,

20
tests/ui/transmutability/issue-101739-2.stderr
View File

@ -9,29 +9,13 @@ LL | | ASSUME_VALIDITY,
LL | | ASSUME_VISIBILITY,
| |_____________________________- help: remove these generic arguments
error: the constant `ASSUME_ALIGNMENT` is not of type `Assume`
--> $DIR/issue-101739-2.rs:17:14
|
LL | Dst: BikeshedIntrinsicFrom<
| ______________^
LL | |
LL | | Src,
LL | | ASSUME_ALIGNMENT,
... |
LL | | ASSUME_VISIBILITY,
LL | | >,
| |_________^ expected `Assume`, found `bool`
|
note: required by a bound in `BikeshedIntrinsicFrom`
--> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
error[E0308]: mismatched types
--> $DIR/issue-101739-2.rs:20:13
--> $DIR/issue-101739-2.rs:19:13
|
LL | ASSUME_ALIGNMENT,
| ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
error: aborting due to 3 previous errors
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0107, E0308.
For more information about an error, try `rustc --explain E0107`.