user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #152412 - JonathanBrouwer:rollup-hShycIY, r=JonathanBrouwer

Browse source 
Rollup of 7 pull requests

Successful merges:

 - rust-lang/rust#151960 (rustc_parse: improve the error diagnostic for "missing let")
 - rust-lang/rust#152157 (Fix error spans for `asm!()` args that are macros)
 - rust-lang/rust#152317 (fix: sup_trace to sub_trace)
 - rust-lang/rust#150897 (rustc_parse_format: improve diagnostics for unsupported debug = syntax)
 - rust-lang/rust#151154 (Add `s390x-unknown-none-softfloat` with `RustcAbi::Softfloat`)
 - rust-lang/rust#152013 (Update to Xcode 26.2)
 - rust-lang/rust#152326 (Remove the compiler adhoc group)
This commit is contained in:
bors 2026-02-10 02:25:24 +00:00
commit f21b4c0888
44 changed files with 600 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

33
compiler/rustc_builtin_macros/src/asm.rs
View file

@ -288,6 +288,18 @@ fn expand_preparsed_asm(
let msg = "asm template must be a string literal";
let template_sp = template_expr.span;
let template_is_mac_call = matches!(template_expr.kind, ast::ExprKind::MacCall(_));
// Gets the span inside `template_sp` corresponding to the given range
let span_in_template = |range: std::ops::Range<usize>| -> Span {
if template_is_mac_call {
// When the template is a macro call we can't reliably get inner spans
// so just use the entire template span (see ICEs #129503, #131292)
template_sp
} else {
template_sp.from_inner(InnerSpan::new(range.start, range.end))
}
};
let ExprToSpannedString {
symbol: template_str,
style: template_style,
@ -382,13 +394,8 @@ fn expand_preparsed_asm(
if !parser.errors.is_empty() {
let err = parser.errors.remove(0);
let err_sp = if template_is_mac_call {
// If the template is a macro call we can't reliably point to the error's
// span so just use the template's span as the error span (fixes #129503)
template_span
} else {
template_span.from_inner(InnerSpan::new(err.span.start, err.span.end))
};
let err_sp = span_in_template(err.span);
let msg = format!("invalid asm template string: {}", err.description);
let mut e = ecx.dcx().struct_span_err(err_sp, msg);
@ -397,8 +404,7 @@ fn expand_preparsed_asm(
e.note(note);
}
if let Some((label, span)) = err.secondary_label {
let err_sp = template_span.from_inner(InnerSpan::new(span.start, span.end));
e.span_label(err_sp, label);
e.span_label(span_in_template(span), label);
}
let guar = e.emit();
return ExpandResult::Ready(Err(guar));
@ -477,8 +483,7 @@ fn expand_preparsed_asm(
ecx.dcx()
.create_err(errors::AsmNoMatchedArgumentName {
name: name.to_owned(),
span: template_span
.from_inner(InnerSpan::new(span.start, span.end)),
span: span_in_template(span),
})
.emit();
None
@ -490,11 +495,7 @@ fn expand_preparsed_asm(
let mut chars = arg.format.ty.chars();
let mut modifier = chars.next();
if chars.next().is_some() {
let span = arg
.format
.ty_span
.map(|sp| template_sp.from_inner(InnerSpan::new(sp.start, sp.end)))
.unwrap_or(template_sp);
let span = arg.format.ty_span.map(span_in_template).unwrap_or(template_sp);
ecx.dcx().emit_err(errors::AsmModifierInvalid { span });
modifier = None;
}

12
compiler/rustc_builtin_macros/src/errors.rs
View file

@ -678,6 +678,18 @@ pub(crate) enum InvalidFormatStringSuggestion {
#[primary_span]
span: Span,
},
#[suggestion(
"use rust debug printing macro",
code = "{replacement}",
style = "verbose",
applicability = "machine-applicable"
)]
UseRustDebugPrintingMacro {
#[primary_span]
macro_span: Span,
replacement: String,
},
}
#[derive(Diagnostic)]

20
compiler/rustc_builtin_macros/src/format.rs
View file

@ -160,6 +160,7 @@ fn make_format_args(
ecx: &mut ExtCtxt<'_>,
input: MacroInput,
append_newline: bool,
macro_span: Span,
) -> ExpandResult<Result<FormatArgs, ErrorGuaranteed>, ()> {
let msg = "format argument must be a string literal";
let unexpanded_fmt_span = input.fmtstr.span;
@ -333,6 +334,23 @@ fn make_format_args(
let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
e.sugg_ = Some(errors::InvalidFormatStringSuggestion::AddMissingColon { span });
}
parse::Suggestion::UseRustDebugPrintingMacro => {
// This targets `println!("{=}", x);` and `println!("{0=}", x);`
if let [arg] = args.all_args() {
let expr_span = arg.expr.span;
if let Ok(expr_snippet) = ecx.source_map().span_to_snippet(expr_span) {
let replacement = format!("{}!({})", "dbg", expr_snippet);
let call_span = macro_span.source_callsite();
e.sugg_ = Some(
errors::InvalidFormatStringSuggestion::UseRustDebugPrintingMacro {
macro_span: call_span,
replacement,
},
);
}
}
}
}
let guar = ecx.dcx().emit_err(e);
return ExpandResult::Ready(Err(guar));
@ -1048,7 +1066,7 @@ fn expand_format_args_impl<'cx>(
sp = ecx.with_def_site_ctxt(sp);
ExpandResult::Ready(match parse_args(ecx, sp, tts) {
Ok(input) => {
let ExpandResult::Ready(mac) = make_format_args(ecx, input, nl) else {
let ExpandResult::Ready(mac) = make_format_args(ecx, input, nl, sp) else {
return ExpandResult::Retry(());
};
match mac {

18
compiler/rustc_parse/src/errors.rs
View file

@ -573,6 +573,24 @@ pub(crate) struct ExpectedExpressionFoundLet {
pub comparison: Option<MaybeComparison>,
}
#[derive(Diagnostic)]
#[diag("let-chain with missing `let`")]
pub(crate) struct LetChainMissingLet {
#[primary_span]
pub span: Span,
#[label("expected `let` expression, found assignment")]
pub label_span: Span,
#[label("let expression later in the condition")]
pub rhs_span: Span,
#[suggestion(
"add `let` before the expression",
applicability = "maybe-incorrect",
code = "let ",
style = "verbose"
)]
pub sug_span: Span,
}
#[derive(Diagnostic)]
#[diag("`||` operators are not supported in let chain conditions")]
pub(crate) struct OrInLetChain {

47
compiler/rustc_parse/src/parser/expr.rs
View file

@ -4282,7 +4282,52 @@ impl MutVisitor for CondChecker<'_> {
mut_visit::walk_expr(self, e);
self.forbid_let_reason = forbid_let_reason;
}
ExprKind::Assign(ref lhs, _, span) => {
ExprKind::Assign(ref lhs, ref rhs, span) => {
if let ExprKind::Call(_, _) = &lhs.kind {
fn get_path_from_rhs(e: &Expr) -> Option<(u32, &Path)> {
fn inner(e: &Expr, depth: u32) -> Option<(u32, &Path)> {
match &e.kind {
ExprKind::Binary(_, lhs, _) => inner(lhs, depth + 1),
ExprKind::Path(_, path) => Some((depth, path)),
_ => None,
}
}
inner(e, 0)
}
if let Some((depth, path)) = get_path_from_rhs(rhs) {
// For cases like if Some(_) = x && let Some(_) = y && let Some(_) = z
// This return let Some(_) = y expression
fn find_let_some(expr: &Expr) -> Option<&Expr> {
match &expr.kind {
ExprKind::Let(..) => Some(expr),
ExprKind::Binary(op, lhs, rhs) if op.node == BinOpKind::And => {
find_let_some(lhs).or_else(|| find_let_some(rhs))
}
_ => None,
}
}
let expr_span = lhs.span.to(path.span);
if let Some(later_rhs) = find_let_some(rhs)
&& depth > 0
{
let guar = self.parser.dcx().emit_err(errors::LetChainMissingLet {
span: lhs.span,
label_span: expr_span,
rhs_span: later_rhs.span,
sug_span: lhs.span.shrink_to_lo(),
});
self.found_incorrect_let_chain = Some(guar);
}
}
}
let forbid_let_reason = self.forbid_let_reason;
self.forbid_let_reason = Some(errors::ForbiddenLetReason::OtherForbidden);
let missing_let = self.missing_let;

25
compiler/rustc_parse_format/src/lib.rs
View file

@ -187,6 +187,9 @@ pub enum Suggestion {
/// Add missing colon:
/// `format!("{foo?}")` -> `format!("{foo:?}")`
AddMissingColon(Range<usize>),
/// Use Rust format string:
/// `format!("{x=}")` -> `dbg!(x)`
UseRustDebugPrintingMacro,
}
/// The parser structure for interpreting the input format string. This is
@ -462,6 +465,7 @@ impl<'input> Parser<'input> {
('?', _) => self.suggest_format_debug(),
('<' | '^' | '>', _) => self.suggest_format_align(c),
(',', _) => self.suggest_unsupported_python_numeric_grouping(),
('=', '}') => self.suggest_rust_debug_printing_macro(),
_ => self.suggest_positional_arg_instead_of_captured_arg(arg),
}
}
@ -871,6 +875,27 @@ impl<'input> Parser<'input> {
}
}
fn suggest_rust_debug_printing_macro(&mut self) {
if let Some((range, _)) = self.consume_pos('=') {
self.errors.insert(
0,
ParseError {
description:
"python's f-string debug `=` is not supported in rust, use `dbg(x)` instead"
.to_owned(),
note: Some(format!("to print `{{`, you can escape it using `{{{{`",)),
label: "expected `}`".to_owned(),
span: range,
secondary_label: self
.last_open_brace
.clone()
.map(|sp| ("because of this opening brace".to_owned(), sp)),
suggestion: Suggestion::UseRustDebugPrintingMacro,
},
);
}
}
fn suggest_format_align(&mut self, alignment: char) {
if let Some((range, _)) = self.consume_pos(alignment) {
self.errors.insert(

2
compiler/rustc_target/src/callconv/x86_win64.rs
View file

@ -28,7 +28,7 @@ where
BackendRepr::ScalableVector { .. } => panic!("scalable vectors are unsupported"),
BackendRepr::Scalar(scalar) => {
if is_ret && matches!(scalar.primitive(), Primitive::Int(Integer::I128, _)) {
if cx.target_spec().rustc_abi == Some(RustcAbi::X86Softfloat) {
if cx.target_spec().rustc_abi == Some(RustcAbi::Softfloat) {
// Use the native `i128` LLVM type for the softfloat ABI -- in other words, adjust nothing.
} else {
// `i128` is returned in xmm0 by Clang and GCC

16
compiler/rustc_target/src/lib.rs
View file

@ -76,7 +76,7 @@ macro_rules! target_spec_enum {
pub enum $Name:ident {
$(
$( #[$variant_attr:meta] )*
$Variant:ident = $string:literal,
$Variant:ident = $string:literal $(,$alias:literal)* ,
)*
}
parse_error_type = $parse_error_type:literal;
@ -88,6 +88,7 @@ macro_rules! target_spec_enum {
$(
$( #[$variant_attr] )*
#[serde(rename = $string)] // for JSON schema generation only
$( #[serde(alias = $alias)] )*
$Variant,
)*
}
@ -97,7 +98,10 @@ macro_rules! target_spec_enum {
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(match s {
$( $string => Self::$Variant, )*
$(
$string => Self::$Variant,
$($alias => Self::$Variant,)*
)*
_ => {
let all = [$( concat!("'", $string, "'") ),*].join(", ");
return Err(format!("invalid {}: '{s}'. allowed values: {all}", $parse_error_type));
@ -123,7 +127,7 @@ macro_rules! target_spec_enum {
pub enum $Name:ident {
$(
$( #[$variant_attr:meta] )*
$Variant:ident = $string:literal,
$Variant:ident = $string:literal $(,$alias:literal)* ,
)*
}
$( #[$other_variant_attr:meta] )*
@ -134,6 +138,7 @@ macro_rules! target_spec_enum {
pub enum $Name {
$(
$( #[$variant_attr:meta] )*
$( #[serde(alias = $alias)] )*
$Variant,
)*
/// The vast majority of the time, the compiler deals with a fixed
@ -165,7 +170,10 @@ macro_rules! target_spec_enum {
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(match s {
$( $string => Self::$Variant, )*
$(
$string => Self::$Variant,
$($alias => Self::$Variant,)*
)*
_ => Self::$OtherVariant(s.to_owned().into()),
})
}

11
compiler/rustc_target/src/spec/mod.rs
View file

@ -1005,8 +1005,8 @@ crate::target_spec_enum! {
pub enum RustcAbi {
/// On x86-32 only: make use of SSE and SSE2 for ABI purposes.
X86Sse2 = "x86-sse2",
/// On x86-32/64 only: do not use any FPU or SIMD registers for the ABI.
X86Softfloat = "x86-softfloat",
/// On x86-32/64 and S390x: do not use any FPU or SIMD registers for the ABI.
Softfloat = "softfloat", "x86-softfloat",
}
parse_error_type = "rustc abi";
@ -1460,6 +1460,7 @@ supported_targets! {
("powerpc64le-unknown-linux-gnu", powerpc64le_unknown_linux_gnu),
("powerpc64le-unknown-linux-musl", powerpc64le_unknown_linux_musl),
("s390x-unknown-linux-gnu", s390x_unknown_linux_gnu),
("s390x-unknown-none-softfloat", s390x_unknown_none_softfloat),
("s390x-unknown-linux-musl", s390x_unknown_linux_musl),
("sparc-unknown-linux-gnu", sparc_unknown_linux_gnu),
("sparc64-unknown-linux-gnu", sparc64_unknown_linux_gnu),
@ -3204,10 +3205,10 @@ impl Target {
Arch::X86,
"`x86-sse2` ABI is only valid for x86-32 targets"
),
RustcAbi::X86Softfloat => check_matches!(
RustcAbi::Softfloat => check_matches!(
self.arch,
Arch::X86 | Arch::X86_64,
"`x86-softfloat` ABI is only valid for x86 targets"
Arch::X86 | Arch::X86_64 | Arch::S390x,
"`softfloat` ABI is only valid for x86 and s390x targets"
),
}
}

2
compiler/rustc_target/src/spec/targets/i686_unknown_uefi.rs
View file

@ -22,7 +22,7 @@ pub(crate) fn target() -> Target {
// If you initialize FP units yourself, you can override these flags with custom linker
// arguments, thus giving you access to full MMX/SSE acceleration.
base.features = "-mmx,-sse,+soft-float".into();
base.rustc_abi = Some(RustcAbi::X86Softfloat);
base.rustc_abi = Some(RustcAbi::Softfloat);
// Turn off DWARF. This fixes an lld warning, "section name .debug_frame is longer than 8
// characters and will use a non-standard string table". That section will not be created if

39
compiler/rustc_target/src/spec/targets/s390x_unknown_none_softfloat.rs Normal file
View file

@ -0,0 +1,39 @@
use rustc_abi::{Align, Endian};
use crate::spec::{
Abi, Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, RustcAbi, SanitizerSet,
StackProbeType, Target, TargetMetadata, TargetOptions,
};
pub(crate) fn target() -> Target {
let opts = TargetOptions {
abi: Abi::SoftFloat,
cpu: "z10".into(),
endian: Endian::Big,
features: "+soft-float,-vector".into(),
linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
linker: Some("rust-lld".into()),
max_atomic_width: Some(128),
min_global_align: Some(Align::from_bits(16).unwrap()),
panic_strategy: PanicStrategy::Abort,
relocation_model: RelocModel::Static,
rustc_abi: Some(RustcAbi::Softfloat),
stack_probes: StackProbeType::Inline,
supported_sanitizers: SanitizerSet::KERNELADDRESS,
..Default::default()
};
Target {
llvm_target: "s390x-unknown-linux-gnu".into(),
metadata: TargetMetadata {
description: Some("S390x Linux".into()),
host_tools: Some(false),
std: Some(false),
tier: Some(2),
},
arch: Arch::S390x,
data_layout: "E-S64-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64".into(),
options: opts,
pointer_width: 64,
}
}

2
compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs
View file

@ -20,7 +20,7 @@ pub(crate) fn target() -> Target {
relro_level: RelroLevel::Full,
linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
linker: Some("rust-lld".into()),
rustc_abi: Some(RustcAbi::X86Softfloat),
rustc_abi: Some(RustcAbi::Softfloat),
features: "-mmx,-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-avx,-avx2,+soft-float".into(),
supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS,
disable_redzone: true,

2
compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs
View file

@ -27,7 +27,7 @@ pub(crate) fn target() -> Target {
// If you initialize FP units yourself, you can override these flags with custom linker
// arguments, thus giving you access to full MMX/SSE acceleration.
base.features = "-mmx,-sse,+soft-float".into();
base.rustc_abi = Some(RustcAbi::X86Softfloat);
base.rustc_abi = Some(RustcAbi::Softfloat);
Target {
llvm_target: "x86_64-unknown-windows".into(),

32
compiler/rustc_target/src/target_features.rs
View file

@ -863,7 +863,7 @@ const IBMZ_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
("miscellaneous-extensions-3", Stable, &[]),
("miscellaneous-extensions-4", Stable, &[]),
("nnp-assist", Stable, &["vector"]),
("soft-float", Forbidden { reason: "currently unsupported ABI-configuration feature" }, &[]),
("soft-float", Forbidden { reason: "unsupported ABI-configuration feature" }, &[]),
("transactional-execution", Unstable(sym::s390x_target_feature), &[]),
("vector", Stable, &[]),
("vector-enhancements-1", Stable, &["vector"]),
@ -1117,7 +1117,7 @@ impl Target {
incompatible: &["soft-float"],
}
}
Some(RustcAbi::X86Softfloat) => {
Some(RustcAbi::Softfloat) => {
// Softfloat ABI, requires corresponding target feature. That feature trumps
// `x87` and all other FPU features so those do not matter.
// Note that this one requirement is the entire implementation of the ABI!
@ -1137,7 +1137,7 @@ impl Target {
incompatible: &["soft-float"],
}
}
Some(RustcAbi::X86Softfloat) => {
Some(RustcAbi::Softfloat) => {
// Softfloat ABI, requires corresponding target feature. That feature trumps
// `x87` and all other FPU features so those do not matter.
// Note that this one requirement is the entire implementation of the ABI!
@ -1237,11 +1237,27 @@ impl Target {
}
}
Arch::S390x => {
// We don't currently support a softfloat target on this architecture.
// As usual, we have to reject swapping the `soft-float` target feature.
// The "vector" target feature does not affect the ABI for floats
// because the vector and float registers overlap.
FeatureConstraints { required: &[], incompatible: &["soft-float"] }
// Same as x86, We use our own ABI indicator here;
// LLVM does not have anything native and will switch ABI based
// on the soft-float target feature.
// Every case should require or forbid `soft-float`!
// The "vector" target feature may only be used without soft-float
// because the float and vector registers overlap and the
// standard s390x C ABI may pass vectors via these registers.
match self.rustc_abi {
None => {
// Default hardfloat ABI.
FeatureConstraints { required: &[], incompatible: &["soft-float"] }
}
Some(RustcAbi::Softfloat) => {
// Softfloat ABI, requires corresponding target feature.
// llvm will switch to soft-float ABI just based on this feature.
FeatureConstraints { required: &["soft-float"], incompatible: &["vector"] }
}
Some(r) => {
panic!("invalid Rust ABI for s390x: {r:?}");
}
}
}
Arch::Avr => {
// SRAM is minimum requirement for C/C++ in both avr-gcc and Clang,

2
compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
View file

@ -1020,7 +1020,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
&& let Some((sup_expected, sup_found)) =
self.values_str(sup_trace.values, &sup_trace.cause, err.long_ty_path())
&& let Some((sub_expected, sub_found)) =
self.values_str(sub_trace.values, &sup_trace.cause, err.long_ty_path())
self.values_str(sub_trace.values, &sub_trace.cause, err.long_ty_path())
&& sub_expected == sup_expected
&& sub_found == sup_found
{

1
src/bootstrap/src/core/sanity.rs
View file

@ -48,6 +48,7 @@ const STAGE0_MISSING_TARGETS: &[&str] = &[
"thumbv6-none-eabi",
"aarch64v8r-unknown-none",
"aarch64v8r-unknown-none-softfloat",
"s390x-unknown-none-softfloat",
];
/// Minimum version threshold for libstdc++ required when using prebuilt LLVM

2
src/ci/citool/tests/jobs.rs
View file

@ -6,7 +6,7 @@ const TEST_JOBS_YML_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/tes
fn auto_jobs() {
let stdout = get_matrix("push", "commit", "refs/heads/automation/bors/auto");
insta::assert_snapshot!(stdout, @r#"
jobs=[{"name":"aarch64-gnu","full_name":"auto - aarch64-gnu","os":"ubuntu-22.04-arm","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"x86_64-gnu-llvm-18-1","full_name":"auto - x86_64-gnu-llvm-18-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DOCKER_SCRIPT":"stage_2_test_set1.sh","IMAGE":"x86_64-gnu-llvm-18","READ_ONLY_SRC":"0","RUST_BACKTRACE":1,"TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"aarch64-apple","full_name":"auto - aarch64-apple","os":"macos-14","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DEVELOPER_DIR":"/Applications/Xcode_15.4.app/Contents/Developer","MACOSX_DEPLOYMENT_TARGET":11.0,"MACOSX_STD_DEPLOYMENT_TARGET":11.0,"NO_DEBUG_ASSERTIONS":1,"NO_LLVM_ASSERTIONS":1,"NO_OVERFLOW_CHECKS":1,"RUSTC_RETRY_LINKER_ON_SEGFAULT":1,"RUST_CONFIGURE_ARGS":"--enable-sanitizers --enable-profiler --set rust.jemalloc","SCRIPT":"./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin","TOOLSTATE_PUBLISH":1}},{"name":"dist-i686-msvc","full_name":"auto - dist-i686-msvc","os":"windows-2022","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","CODEGEN_BACKENDS":"llvm,cranelift","DEPLOY_BUCKET":"rust-lang-ci2","DIST_REQUIRE_ALL_TOOLS":1,"RUST_CONFIGURE_ARGS":"--build=i686-pc-windows-msvc --host=i686-pc-windows-msvc --target=i686-pc-windows-msvc,i586-pc-windows-msvc --enable-full-tools --enable-profiler","SCRIPT":"python x.py dist bootstrap --include-default-paths","TOOLSTATE_PUBLISH":1}},{"name":"pr-check-1","full_name":"auto - pr-check-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true},{"name":"pr-check-2","full_name":"auto - pr-check-2","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true},{"name":"tidy","full_name":"auto - tidy","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true,"doc_url":"https://foo.bar"}]
jobs=[{"name":"aarch64-gnu","full_name":"auto - aarch64-gnu","os":"ubuntu-22.04-arm","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"x86_64-gnu-llvm-18-1","full_name":"auto - x86_64-gnu-llvm-18-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DOCKER_SCRIPT":"stage_2_test_set1.sh","IMAGE":"x86_64-gnu-llvm-18","READ_ONLY_SRC":"0","RUST_BACKTRACE":1,"TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"aarch64-apple","full_name":"auto - aarch64-apple","os":"macos-15","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DEVELOPER_DIR":"/Applications/Xcode_26.2.app/Contents/Developer","MACOSX_DEPLOYMENT_TARGET":11.0,"MACOSX_STD_DEPLOYMENT_TARGET":11.0,"NO_DEBUG_ASSERTIONS":1,"NO_LLVM_ASSERTIONS":1,"NO_OVERFLOW_CHECKS":1,"RUSTC_RETRY_LINKER_ON_SEGFAULT":1,"RUST_CONFIGURE_ARGS":"--enable-sanitizers --enable-profiler --set rust.jemalloc","SCRIPT":"./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin","TOOLSTATE_PUBLISH":1}},{"name":"dist-i686-msvc","full_name":"auto - dist-i686-msvc","os":"windows-2022","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","CODEGEN_BACKENDS":"llvm,cranelift","DEPLOY_BUCKET":"rust-lang-ci2","DIST_REQUIRE_ALL_TOOLS":1,"RUST_CONFIGURE_ARGS":"--build=i686-pc-windows-msvc --host=i686-pc-windows-msvc --target=i686-pc-windows-msvc,i586-pc-windows-msvc --enable-full-tools --enable-profiler","SCRIPT":"python x.py dist bootstrap --include-default-paths","TOOLSTATE_PUBLISH":1}},{"name":"pr-check-1","full_name":"auto - pr-check-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true},{"name":"pr-check-2","full_name":"auto - pr-check-2","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true},{"name":"tidy","full_name":"auto - tidy","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true,"doc_url":"https://foo.bar"}]
run_type=auto
"#);
}

6
src/ci/citool/tests/test-jobs.yml
View file

@ -13,7 +13,7 @@ runners:
<<: *base-job
- &job-macos-m1
os: macos-14
os: macos-15
<<: *base-job
- &job-windows
@ -33,7 +33,7 @@ envs:
# Ensure that host tooling is tested on our minimum supported macOS version.
MACOSX_DEPLOYMENT_TARGET: 10.12
MACOSX_STD_DEPLOYMENT_TARGET: 10.12
DEVELOPER_DIR: /Applications/Xcode_15.2.app/Contents/Developer
DEVELOPER_DIR: /Applications/Xcode_26.2.app/Contents/Developer
NO_LLVM_ASSERTIONS: 1
NO_DEBUG_ASSERTIONS: 1
NO_OVERFLOW_CHECKS: 1
@ -112,7 +112,7 @@ auto:
--enable-profiler
--set rust.jemalloc
RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
DEVELOPER_DIR: /Applications/Xcode_26.2.app/Contents/Developer
# Aarch64 tooling only needs to support macOS 11.0 and up as nothing else
# supports the hardware, so only need to test it there.
MACOSX_DEPLOYMENT_TARGET: 11.0

10
src/ci/github-actions/jobs.yml
View file

@ -23,7 +23,7 @@ runners:
<<: *base-job
- &job-macos
os: macos-14
os: macos-15 # macOS 15 Arm64
<<: *base-job
- &job-windows
@ -459,7 +459,7 @@ auto:
# Ensure that host tooling is built to support our minimum support macOS version.
MACOSX_DEPLOYMENT_TARGET: 10.12
MACOSX_STD_DEPLOYMENT_TARGET: 10.12
DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
DEVELOPER_DIR: /Applications/Xcode_26.2.app/Contents/Developer
DIST_REQUIRE_ALL_TOOLS: 1
CODEGEN_BACKENDS: llvm,cranelift
<<: *job-macos
@ -474,7 +474,7 @@ auto:
# FIXME(madsmtm): This might be redundant, as we're not building host tooling here (?)
MACOSX_DEPLOYMENT_TARGET: 10.12
MACOSX_STD_DEPLOYMENT_TARGET: 10.12
DEVELOPER_DIR: /Applications/Xcode_15.2.app/Contents/Developer
DEVELOPER_DIR: /Applications/Xcode_26.2.app/Contents/Developer
<<: *job-macos
- name: dist-aarch64-apple
@ -495,7 +495,7 @@ auto:
# supports the hardware.
MACOSX_DEPLOYMENT_TARGET: 11.0
MACOSX_STD_DEPLOYMENT_TARGET: 11.0
DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
DEVELOPER_DIR: /Applications/Xcode_26.2.app/Contents/Developer
DIST_REQUIRE_ALL_TOOLS: 1
CODEGEN_BACKENDS: llvm,cranelift
<<: *job-macos
@ -509,7 +509,7 @@ auto:
--enable-sanitizers
--enable-profiler
--set rust.jemalloc
DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
DEVELOPER_DIR: /Applications/Xcode_26.2.app/Contents/Developer
# Aarch64 tooling only needs to support macOS 11.0 and up as nothing else
# supports the hardware, so only need to test it there.
MACOSX_DEPLOYMENT_TARGET: 11.0

1
src/doc/rustc/src/SUMMARY.md
View file

@ -120,6 +120,7 @@
- [riscv64a23-unknown-linux-gnu](platform-support/riscv64a23-unknown-linux-gnu.md)
- [s390x-unknown-linux-gnu](platform-support/s390x-unknown-linux-gnu.md)
- [s390x-unknown-linux-musl](platform-support/s390x-unknown-linux-musl.md)
- [s390x-unknown-none-softfloat](platform-support/s390x-unknown-none-softfloat.md)
- [sparc-unknown-none-elf](./platform-support/sparc-unknown-none-elf.md)
- [solaris](platform-support/solaris.md)
- [\*-nto-qnx-\*](platform-support/nto-qnx.md)

1
src/doc/rustc/src/platform-support.md
View file

@ -188,6 +188,7 @@ target | std | notes
[`riscv64im-unknown-none-elf`](platform-support/riscv64im-unknown-none-elf.md) | * | Bare RISC-V (RV64IM ISA)
`riscv64imac-unknown-none-elf` | * | Bare RISC-V (RV64IMAC ISA)
`sparc64-unknown-linux-gnu` | ✓ | SPARC Linux (kernel 4.4+, glibc 2.23)
[`s390x-unknown-none-softfloat`](platform-support/s390x-unknown-none-softfloat.md) | * | Bare S390x (softfloat ABI)
[`thumbv6m-none-eabi`](platform-support/thumbv6m-none-eabi.md) | * | Bare Armv6-M
[`thumbv7em-none-eabi`](platform-support/thumbv7em-none-eabi.md) | * | Bare Armv7E-M
[`thumbv7em-none-eabihf`](platform-support/thumbv7em-none-eabi.md) | * | Bare Armv7E-M, hardfloat

77
src/doc/rustc/src/platform-support/s390x-unknown-none-softfloat.md Normal file
View file

@ -0,0 +1,77 @@
# `s390x-unknown-none-softfloat`
**Tier: 2**
IBM z/Architecture (s390x) code in ELF format for kernels, etc.
## Target maintainers
[@uweigand](https://github.com/uweigand)
[@cuviper](https://github.com/cuviper)
## Requirements
This target is intended for kernel development on s390x only. This target is
cross-compiled. There is no support for `std`.There is no default allocator,
but it's possible to use `alloc` by supplying an allocator.
The target does not assume existence of a FPU and does not make use of any
non-GPR register. This allows the generated code to run in environments, such
as kernels, which may need to avoid the use of such registers or which may have
special considerations about the use of such registers (e.g. saving and
restoring them to avoid breaking userspace code using the same registers). You
can change code generation to use additional CPU features via the
`-C target-feature=` codegen options to rustc, or via the `#[target_feature]`
mechanism within Rust code.
By default, code generated with the soft-float target should run on any Z System
starting at [Z10][s390x-isa]. Enabling additional target features or changing the
`-Ctarget-cpu` may raise the ISA required from the `z10` baseline.
`extern "C"` does not use a stable ABI and is subject to change between compiler
or codegen backend versions.
The target only generates object files in the ELF format. Any alternate formats
or special considerations for binary layout will require linker options or linker
scripts.
* [z/Architecture Principles of Operation][s390x-isa]
[s390x-isa]: https://publibfp.dhe.ibm.com/epubs/pdf/a227832d.pdf
[s390x-abi]: https://github.com/IBM/s390x-abi
## Building the target
You can build Rust with support for the target by adding it to the `target`
list in `bootstrap.toml`:
```toml
[build]
target = ["s390x-unknown-none-softfloat"]
```
## Building Rust programs
This target is not intended to build stand-alone binaries. You should only use
it in conjunction with the kernel build toolchain.
## Testing
As code generated by this target is intended to always be part of the kernel,
there are no additional requirements for testing.
If you want to do native testing but do not have your own s390x
machine, there are several options how to get access to one:
* The [IBM LinuxONE Community Cloud][cloud-community] provides a
self-service portal where you can create s390x virtual machine
instances. These are intended for temporary use (limited to 120 days).
* The [IBM LinuxONE Open Source Cloud][cloud-opensource] provides
permanent access to s390x machines. This requires approval by IBM,
which will normally be granted if you're planning to use the machine
to work on an open-source project that is relevant to the IBM Z
ecosystem - the Rust compiler would certainly qualify.
[cloud-community]: https://linuxone.cloud.marist.edu/
[cloud-opensource]: https://community.ibm.com/zsystems/form/l1cc-oss-vm-request/

64
tests/assembly-llvm/s390x-softfloat-abi.rs Normal file
View file

@ -0,0 +1,64 @@
//@ add-minicore
//@ revisions: enable-softfloat disable-softfloat
//@ assembly-output: emit-asm
//@ compile-flags: -Copt-level=3 --crate-type=lib
//@[enable-softfloat] compile-flags: --target=s390x-unknown-none-softfloat
//@[enable-softfloat] needs-llvm-components: systemz
//@[disable-softfloat] compile-flags: --target=s390x-unknown-linux-gnu
//@[disable-softfloat] needs-llvm-components: systemz
//@ ignore-backends: gcc
#![feature(no_core, lang_items)]
#![no_std]
#![no_core]
extern crate minicore;
use minicore::*;
extern "C" {
fn extern_func(value: f64) -> f64;
}
// CHECK-LABEL: test_softfloat
#[no_mangle]
extern "C" fn test_softfloat() -> f64 {
let value = 3.141_f64;
// without softfloat we load the value direct to the first float register
// we do NOT construct a softfloat in r2 (first non-float arg register)
// disable-softfloat: ld %f{{.*}}, 0(%r{{.*}})
// disable-softfloat-NOT: llihf %r{{.*}}, 1074340036
// disable-softfloat-NOT: oilf %r{{.*}}, 2611340116
// with softfloat we construct the softfloat arg in r2
// we do NOT pass anything by f0 (first float arg register)
// float registers can not be accessed
// enable-softfloat: llihf %r{{.*}}, 1074340036
// enable-softfloat-NEXT: oilf %r{{.*}}, 2611340116
// enable-softfloat-NOT: ld %f{{.*}}, 0(%r{{.*}})
unsafe { extern_func(value) };
// disable-softfloat-NEXT: brasl %r{{.*}}, extern_func@PLT
// enable-softfloat-NEXT: brasl %r{{.*}}, extern_func@PLT
// for return we check that without softfloat we write to float register
// disable-softfloat: ld %f{{.*}}, 0(%r{{.*}})
// disable-softfloat-NOT: llihf %r{{.*}}, 1072841097
// disable-softfloat-NOT: oilf %r{{.*}}, 927712936
#[cfg(not(target_feature = "soft-float"))]
{
1.141_f64
}
// for return we check that WITH softfloat we write to genral purpose register
// enable-softfloat: llihf %r{{.*}}, 1072841097
// enable-softfloat-NEXT: oilf %r{{.*}}, 927712936
// enable-softfloat-NOT: ld %f{{.*}}, 0(%r{{.*}})
#[cfg(target_feature = "soft-float")]
{
2.718_f64
}
// enable-softfloat: br %r{{.*}}
// disable-softfloat: br %r{{.*}}
}

3
tests/assembly-llvm/targets/targets-elf.rs
View file

@ -544,6 +544,9 @@
//@ revisions: s390x_unknown_linux_musl
//@ [s390x_unknown_linux_musl] compile-flags: --target s390x-unknown-linux-musl
//@ [s390x_unknown_linux_musl] needs-llvm-components: systemz
//@ revisions: s390x_unknown_none_softfloat
//@ [s390x_unknown_none_softfloat] compile-flags: --target s390x-unknown-none-softfloat
//@ [s390x_unknown_none_softfloat] needs-llvm-components: systemz
//@ revisions: sparc64_unknown_helenos
//@ [sparc64_unknown_helenos] compile-flags: --target sparc64-unknown-helenos
//@ [sparc64_unknown_helenos] needs-llvm-components: sparc

7
tests/crashes/131292.rs
View file

@ -1,7 +0,0 @@
//@ known-bug: #131292
//@ needs-asm-support
use std::arch::asm;
unsafe fn f6() {
asm!(concat!(r#"lJ𐏿Æ<F0908FBF>.𐏿<>"#, "{}/day{:02}.txt"));
}

12
tests/ui/abi/s390x-softfloat-gate.disable-softfloat.stderr Normal file
View file

@ -0,0 +1,12 @@
warning: target feature `soft-float` cannot be enabled with `-Ctarget-feature`: unsupported ABI-configuration feature
|
= note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
warning: target feature `soft-float` must be disabled to ensure that the ABI of the current target can be implemented correctly
|
= note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
warning: 2 warnings emitted

7
tests/ui/abi/s390x-softfloat-gate.enable-softfloat.stderr Normal file
View file

@ -0,0 +1,7 @@
warning: target feature `vector` must be disabled to ensure that the ABI of the current target can be implemented correctly
|
= note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
warning: 1 warning emitted

38
tests/ui/abi/s390x-softfloat-gate.rs Normal file
View file

@ -0,0 +1,38 @@
//@ add-minicore
//@ revisions: disable-softfloat enable-softfloat
//@ assembly-output: emit-asm
//@ compile-flags: -Copt-level=3 --crate-type=lib
// we expect the build to fail in the feature
//@ build-pass
//@ [enable-softfloat] compile-flags: --target=s390x-unknown-none-softfloat
//@ [enable-softfloat] compile-flags: -C target-feature=+vector
//@ [enable-softfloat] needs-llvm-components: systemz
//@ [disable-softfloat] compile-flags: --target=s390x-unknown-linux-gnu
//@ [disable-softfloat] compile-flags: -C target-feature=+soft-float
//@ [disable-softfloat] needs-llvm-components: systemz
//@ ignore-backends: gcc
//[disable-softfloat]~? WARN target feature `soft-float` must be disabled to ensure that the ABI of the current target can be implemented correctly
//[disable-softfloat]~? WARN target feature `soft-float` cannot be enabled with `-Ctarget-feature`
//[enable-softfloat]~? WARN target feature `vector` must be disabled to ensure that the ABI of the current target can be implemented correctly
#![feature(no_core, lang_items)]
#![no_std]
#![no_core]
extern crate minicore;
use minicore::*;
extern "C" {
fn extern_func(value: f64) -> f64;
}
#[no_mangle]
extern "C" fn test_softfloat() -> f64 {
let value = 3.141_f64;
unsafe { extern_func(value) } ;
2.718_f64
}

2
tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr
View file

@ -1,4 +1,4 @@
warning: target feature `soft-float` cannot be enabled with `-Ctarget-feature`: currently unsupported ABI-configuration feature
warning: target feature `soft-float` cannot be enabled with `-Ctarget-feature`: unsupported ABI-configuration feature
|
= note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>

13
tests/ui/asm/ice-bad-err-span-in-template-129503.rs
View file

@ -1,17 +1,22 @@
// Regression test for ICE #129503
// Regression test for ICEs #129503 and #131292
//
// Tests that we come up with decent error spans
// when the template fed to `asm!()` is itself a
// macro call like `concat!()` and should not ICE
//@ needs-asm-support
use std::arch::asm;
fn main() {
// Should not ICE
// Should not ICE (test case for #129503)
asm!(concat!(r#"lJ𐏿Æ<F0908FBF>.𐏿<>"#, "r} {}"));
//~^ ERROR invalid asm template string: unmatched `}` found
// Should not ICE (test case for #131292)
asm!(concat!(r#"lJ𐏿Æ<F0908FBF>.𐏿<>"#, "{}/day{:02}.txt"));
//~^ ERROR invalid asm template string: expected `}`, found `0`
// Macro call template: should point to
// everything within `asm!()` as error span

19
tests/ui/asm/ice-bad-err-span-in-template-129503.stderr
View file

@ -1,13 +1,24 @@
error: invalid asm template string: unmatched `}` found
--> $DIR/ice-bad-err-span-in-template-129503.rs:12:10
--> $DIR/ice-bad-err-span-in-template-129503.rs:13:10
|
LL | asm!(concat!(r#"lJ𐏿Æ<F0908FBF>.𐏿<>"#, "r} {}"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unmatched `}` in asm template string
|
= note: if you intended to print `}`, you can escape it using `}}`
error: invalid asm template string: expected `}`, found `0`
--> $DIR/ice-bad-err-span-in-template-129503.rs:17:10
|
LL | asm!(concat!(r#"lJ𐏿Æ<F0908FBF>.𐏿<>"#, "{}/day{:02}.txt"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| expected `}` in asm template string
| because of this opening brace
|
= note: if you intended to print `{`, you can escape it using `{{`
error: invalid asm template string: unmatched `}` found
--> $DIR/ice-bad-err-span-in-template-129503.rs:18:10
--> $DIR/ice-bad-err-span-in-template-129503.rs:23:10
|
LL | asm!(concat!("abc", "r} {}"));
| ^^^^^^^^^^^^^^^^^^^^^^^ unmatched `}` in asm template string
@ -15,12 +26,12 @@ LL | asm!(concat!("abc", "r} {}"));
= note: if you intended to print `}`, you can escape it using `}}`
error: invalid asm template string: unmatched `}` found
--> $DIR/ice-bad-err-span-in-template-129503.rs:24:19
--> $DIR/ice-bad-err-span-in-template-129503.rs:29:19
|
LL | asm!("abc", "r} {}");
| ^ unmatched `}` in asm template string
|
= note: if you intended to print `}`, you can escape it using `}}`
error: aborting due to 3 previous errors
error: aborting due to 4 previous errors

3
tests/ui/fmt/format-string-error-2.rs
View file

@ -88,4 +88,7 @@ raw { \n
//~^ ERROR invalid format string: expected `}`, found `?`
println!("{x,}, world!",);
//~^ ERROR invalid format string: python's numeric grouping `,` is not supported in rust format strings
println!("{x=}");
//~^ ERROR invalid format string: python's f-string debug `=` is not supported in rust, use `dbg(x)` instead
}

12
tests/ui/fmt/format-string-error-2.stderr
View file

@ -198,5 +198,15 @@ LL | println!("{x,}, world!",);
|
= note: to print `{`, you can escape it using `{{`
error: aborting due to 20 previous errors
error: invalid format string: python's f-string debug `=` is not supported in rust, use `dbg(x)` instead
--> $DIR/format-string-error-2.rs:92:17
|
LL | println!("{x=}");
| - ^ expected `}` in format string
| |
| because of this opening brace
|
= note: to print `{`, you can escape it using `{{`
error: aborting due to 21 previous errors

5
tests/ui/fmt/format-string-error-3.fixed Normal file
View file

@ -0,0 +1,5 @@
//@ run-rustfix
fn main() {
let x = 32;
dbg!(x); //~ ERROR invalid format string: python's f-string debug
}

5
tests/ui/fmt/format-string-error-3.rs Normal file
View file

@ -0,0 +1,5 @@
//@ run-rustfix
fn main() {
let x = 32;
println!("{=}", x); //~ ERROR invalid format string: python's f-string debug
}

17
tests/ui/fmt/format-string-error-3.stderr Normal file
View file

@ -0,0 +1,17 @@
error: invalid format string: python's f-string debug `=` is not supported in rust, use `dbg(x)` instead
--> $DIR/format-string-error-3.rs:4:16
|
LL | println!("{=}", x);
| -^ expected `}` in format string
| |
| because of this opening brace
|
= note: to print `{`, you can escape it using `{{`
help: use rust debug printing macro
|
LL - println!("{=}", x);
LL + dbg!(x);
|
error: aborting due to 1 previous error

12
tests/ui/missing/missing-let.rs
View file

@ -1,6 +1,18 @@
fn main() {
let x = Some(42);
let y = Some(42);
let z = Some(42);
if let Some(_) = x
&& Some(x) = x //~^ ERROR expected expression, found `let` statement
//~| NOTE: only supported directly in conditions of `if` and `while` expressions
{}
if Some(_) = y &&
//~^ NOTE expected `let` expression, found assignment
//~| ERROR let-chain with missing `let`
let Some(_) = z
//~^ ERROR: expected expression, found `let` statement
//~| NOTE: let expression later in the condition
//~| NOTE: only supported directly in conditions of `if` and `while` expressions
{}
}

28
tests/ui/missing/missing-let.stderr
View file

@ -1,5 +1,5 @@
error: expected expression, found `let` statement
--> $DIR/missing-let.rs:3:8
--> $DIR/missing-let.rs:5:8
|
LL | if let Some(_) = x
| ^^^^^^^^^^^^^^^
@ -14,5 +14,29 @@ help: you might have meant to compare for equality
LL | && Some(x) == x
| +
error: aborting due to 1 previous error
error: expected expression, found `let` statement
--> $DIR/missing-let.rs:13:9
|
LL | let Some(_) = z
| ^^^
|
= note: only supported directly in conditions of `if` and `while` expressions
error: let-chain with missing `let`
--> $DIR/missing-let.rs:10:8
|
LL | if Some(_) = y &&
| ^^^^^^^----
| |
| expected `let` expression, found assignment
...
LL | let Some(_) = z
| --------------- let expression later in the condition
|
help: add `let` before the expression
|
LL | if let Some(_) = y &&
| +++
error: aborting due to 3 previous errors

8
tests/ui/target_modifiers/auxiliary/disabled_softfloat.rs Normal file
View file

@ -0,0 +1,8 @@
//@ add-minicore
//@ no-prefer-dynamic
//@ compile-flags: --target=s390x-unknown-linux-gnu
//@ needs-llvm-components: systemz
#![feature(no_core)]
#![crate_type = "rlib"]
#![no_core]

8
tests/ui/target_modifiers/auxiliary/enabled_softfloat.rs Normal file
View file

@ -0,0 +1,8 @@
//@ add-minicore
//@ no-prefer-dynamic
//@ compile-flags: --target=s390x-unknown-none-softfloat
//@ needs-llvm-components: systemz
#![feature(no_core)]
#![crate_type = "rlib"]
#![no_core]

12
tests/ui/target_modifiers/incompatible_softfloat_targets.disable-softfloat.stderr Normal file
View file

@ -0,0 +1,12 @@
error[E0461]: couldn't find crate `enabled_softfloat` with expected target triple s390x-unknown-linux-gnu
--> $DIR/incompatible_softfloat_targets.rs:17:1
|
LL | extern crate enabled_softfloat;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the following crate versions were found:
crate `enabled_softfloat`, target triple s390x-unknown-none-softfloat: $TEST_BUILD_DIR/auxiliary/libenabled_softfloat.rlib
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0461`.

12
tests/ui/target_modifiers/incompatible_softfloat_targets.enable-softfloat.stderr Normal file
View file

@ -0,0 +1,12 @@
error[E0461]: couldn't find crate `disabled_softfloat` with expected target triple s390x-unknown-none-softfloat
--> $DIR/incompatible_softfloat_targets.rs:19:1
|
LL | extern crate disabled_softfloat;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the following crate versions were found:
crate `disabled_softfloat`, target triple s390x-unknown-linux-gnu: $TEST_BUILD_DIR/auxiliary/libdisabled_softfloat.rlib
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0461`.

20
tests/ui/target_modifiers/incompatible_softfloat_targets.rs Normal file
View file

@ -0,0 +1,20 @@
//@ add-minicore
//@ aux-build: disabled_softfloat.rs
//@ aux-build: enabled_softfloat.rs
//@ revisions: disable-softfloat enable-softfloat
//@ check-fail
//@ [enable-softfloat] compile-flags: --target=s390x-unknown-none-softfloat
//@ [enable-softfloat] needs-llvm-components: systemz
//@ [disable-softfloat] compile-flags: --target=s390x-unknown-linux-gnu
//@ [disable-softfloat] needs-llvm-components: systemz
//@ ignore-backends: gcc
#![feature(no_core)]
#![crate_type = "rlib"]
#![no_core]
extern crate enabled_softfloat;
//[disable-softfloat]~^ ERROR couldn't find crate `enabled_softfloat` with expected target triple s390x-unknown-linux-gnu
extern crate disabled_softfloat;
//[enable-softfloat]~^ ERROR couldn't find crate `disabled_softfloat` with expected target triple s390x-unknown-none-softfloat

23
triagebot.toml
View file

@ -1449,29 +1449,6 @@ compiler_leads = [
"@davidtwco",
"@wesleywiser",
]
compiler = [
"@BoxyUwU",
"@chenyukang",
"@davidtwco",
"@eholk",
"@fee1-dead",
"@fmease",
"@jackh726",
"@jieyouxu",
"@jdonszelmann",
"@JonathanBrouwer",
"@madsmtm",
"@mati865",
"@Nadrieril",
"@nnethercote",
"@oli-obk",
"@petrochenkov",
"@SparrowLii",
"@TaKO8Ki",
"@tiif",
"@WaffleLapkin",
"@wesleywiser",
]
libs = [
"@Mark-Simulacrum",
"@workingjubilee",