nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-16 05:56:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #130066 - compiler-errors:rollup-sq6l0va, r=compiler-errors

Browse Source 
Rollup of 9 pull requests

Successful merges:

 - #128871 (bypass linker configuration and cross target check for specific commands)
 - #129468 ([testsuite][cleanup] Remove all usages of `dont_merge` hack to avoid function merging)
 - #129614 (Adjust doc comment of Condvar::wait_while)
 - #129840 (Implement suggestions for `elided_named_lifetimes`)
 - #129891 (Do not request sanitizers for naked functions)
 - #129899 (Add Suggestions for Misspelled Keywords)
 - #129940 (s390x: Fix a regression related to backchain feature)
 - #129987 (Don't store region in `CapturedPlace`)
 - #130054 (Add missing quotation marks)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-09-07 15:47:14 +00:00
commit 4ff16a9770
87 changed files with 945 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
compiler/rustc_codegen_llvm/src/attributes.rs
View File

@ -411,26 +411,31 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
// the string "false". Now it is disabled by absence of the attribute.
to_add.push(llvm::CreateAttrStringValue(cx.llcx, "branch-target-enforcement", "false"));
}
} else if llvm_util::get_version() >= (19, 0, 0) {
// For non-naked functions, set branch protection attributes on aarch64.
if let Some(BranchProtection { bti, pac_ret }) =
cx.sess().opts.unstable_opts.branch_protection
{
assert!(cx.sess().target.arch == "aarch64");
if bti {
to_add.push(llvm::CreateAttrString(cx.llcx, "branch-target-enforcement"));
}
if let Some(PacRet { leaf, key }) = pac_ret {
to_add.push(llvm::CreateAttrStringValue(
cx.llcx,
"sign-return-address",
if leaf { "all" } else { "non-leaf" },
));
to_add.push(llvm::CreateAttrStringValue(
cx.llcx,
"sign-return-address-key",
if key == PAuthKey::A { "a_key" } else { "b_key" },
));
} else {
// Do not set sanitizer attributes for naked functions.
to_add.extend(sanitize_attrs(cx, codegen_fn_attrs.no_sanitize));
if llvm_util::get_version() >= (19, 0, 0) {
// For non-naked functions, set branch protection attributes on aarch64.
if let Some(BranchProtection { bti, pac_ret }) =
cx.sess().opts.unstable_opts.branch_protection
{
assert!(cx.sess().target.arch == "aarch64");
if bti {
to_add.push(llvm::CreateAttrString(cx.llcx, "branch-target-enforcement"));
}
if let Some(PacRet { leaf, key }) = pac_ret {
to_add.push(llvm::CreateAttrStringValue(
cx.llcx,
"sign-return-address",
if leaf { "all" } else { "non-leaf" },
));
to_add.push(llvm::CreateAttrStringValue(
cx.llcx,
"sign-return-address-key",
if key == PAuthKey::A { "a_key" } else { "b_key" },
));
}
}
}
}
@ -485,7 +490,6 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
if let Some(backchain) = backchain_attr(cx) {
to_add.push(backchain);
}
to_add.extend(sanitize_attrs(cx, codegen_fn_attrs.no_sanitize));
to_add.extend(patchable_function_entry_attrs(cx, codegen_fn_attrs.patchable_function_entry));
// Always annotate functions with the target-cpu they are compiled for.

4
compiler/rustc_codegen_llvm/src/llvm_util.rs
View File

@ -353,9 +353,7 @@ pub fn target_features(sess: &Session, allow_unstable: bool) -> Vec<Symbol> {
None
}
})
.filter(|feature| {
RUSTC_SPECIAL_FEATURES.contains(feature) || features.contains(&Symbol::intern(feature))
})
.filter(|feature| features.contains(&Symbol::intern(feature)))
.map(|feature| Symbol::intern(feature))
.collect()
}

59
compiler/rustc_hir_typeck/src/upvar.rs
View File

@ -39,7 +39,6 @@ use rustc_hir as hir;
use rustc_hir::def_id::LocalDefId;
use rustc_hir::intravisit::{self, Visitor};
use rustc_hir::HirId;
use rustc_infer::infer::UpvarRegion;
use rustc_middle::hir::place::{Place, PlaceBase, PlaceWithHirId, Projection, ProjectionKind};
use rustc_middle::mir::FakeReadCause;
use rustc_middle::traits::ObligationCauseCode;
@ -425,7 +424,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.tcx,
upvar_ty,
capture,
if needs_ref { Some(closure_env_region) } else { child_capture.region },
if needs_ref {
closure_env_region
} else {
self.tcx.lifetimes.re_erased
},
);
},
),
@ -587,7 +590,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
debug!(?captured_place.place, ?upvar_ty, ?capture, ?captured_place.mutability);
apply_capture_kind_on_capture_ty(self.tcx, upvar_ty, capture, captured_place.region)
apply_capture_kind_on_capture_ty(
self.tcx,
upvar_ty,
capture,
self.tcx.lifetimes.re_erased,
)
})
.collect()
}
@ -775,13 +783,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let Some(min_cap_list) = root_var_min_capture_list.get_mut(&var_hir_id) else {
let mutability = self.determine_capture_mutability(&typeck_results, &place);
let min_cap_list = vec![ty::CapturedPlace {
var_ident,
place,
info: capture_info,
mutability,
region: None,
}];
let min_cap_list =
vec![ty::CapturedPlace { var_ident, place, info: capture_info, mutability }];
root_var_min_capture_list.insert(var_hir_id, min_cap_list);
continue;
};
@ -874,34 +877,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Only need to insert when we don't have an ancestor in the existing min capture list
if !ancestor_found {
let mutability = self.determine_capture_mutability(&typeck_results, &place);
let captured_place = ty::CapturedPlace {
var_ident,
place,
info: updated_capture_info,
mutability,
region: None,
};
let captured_place =
ty::CapturedPlace { var_ident, place, info: updated_capture_info, mutability };
min_cap_list.push(captured_place);
}
}
// For each capture that is determined to be captured by ref, add region info.
for (_, captures) in &mut root_var_min_capture_list {
for capture in captures {
match capture.info.capture_kind {
ty::UpvarCapture::ByRef(_) => {
let PlaceBase::Upvar(upvar_id) = capture.place.base else {
bug!("expected upvar")
};
let origin = UpvarRegion(upvar_id, closure_span);
let upvar_region = self.next_region_var(origin);
capture.region = Some(upvar_region);
}
_ => (),
}
}
}
debug!(
"For closure={:?}, min_captures before sorting={:?}",
closure_def_id, root_var_min_capture_list
@ -1195,7 +1176,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.tcx,
ty,
max_capture_info.capture_kind,
Some(self.tcx.lifetimes.re_erased),
self.tcx.lifetimes.re_erased,
)
}
};
@ -1217,7 +1198,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.tcx,
capture.place.ty(),
capture.info.capture_kind,
Some(self.tcx.lifetimes.re_erased),
self.tcx.lifetimes.re_erased,
);
// Checks if a capture implements any of the auto traits
@ -1935,13 +1916,11 @@ fn apply_capture_kind_on_capture_ty<'tcx>(
tcx: TyCtxt<'tcx>,
ty: Ty<'tcx>,
capture_kind: UpvarCapture,
region: Option<ty::Region<'tcx>>,
region: ty::Region<'tcx>,
) -> Ty<'tcx> {
match capture_kind {
ty::UpvarCapture::ByValue => ty,
ty::UpvarCapture::ByRef(kind) => {
Ty::new_ref(tcx, region.unwrap(), ty, kind.to_mutbl_lossy())
}
ty::UpvarCapture::ByRef(kind) => Ty::new_ref(tcx, region, ty, kind.to_mutbl_lossy()),
}
}

1
compiler/rustc_lint/messages.ftl
View File

@ -255,6 +255,7 @@ lint_duplicate_matcher_binding = duplicate matcher binding
lint_elided_named_lifetime = elided lifetime has a name
.label_elided = this elided lifetime gets resolved as `{$name}`
.label_named = lifetime `{$name}` declared here
.suggestion = consider specifying it explicitly
lint_enum_intrinsics_mem_discriminant =
the return value of `mem::discriminant` is unspecified when called with a non-enum type

21
compiler/rustc_lint/src/context/diagnostics.rs
View File

@ -8,13 +8,13 @@ use rustc_errors::{
elided_lifetime_in_path_suggestion, Applicability, Diag, DiagArgValue, LintDiagnostic,
};
use rustc_middle::middle::stability;
use rustc_session::lint::BuiltinLintDiag;
use rustc_session::lint::{BuiltinLintDiag, ElidedLifetimeResolution};
use rustc_session::Session;
use rustc_span::symbol::kw;
use rustc_span::BytePos;
use tracing::debug;
use crate::lints;
use crate::lints::{self, ElidedNamedLifetime};
mod check_cfg;
@ -442,15 +442,14 @@ pub(super) fn decorate_lint(sess: &Session, diagnostic: BuiltinLintDiag, diag: &
BuiltinLintDiag::UnexpectedBuiltinCfg { cfg, cfg_name, controlled_by } => {
lints::UnexpectedBuiltinCfg { cfg, cfg_name, controlled_by }.decorate_lint(diag)
}
BuiltinLintDiag::ElidedIsStatic { elided } => {
lints::ElidedNamedLifetime { elided, name: kw::StaticLifetime, named_declaration: None }
.decorate_lint(diag)
}
BuiltinLintDiag::ElidedIsParam { elided, param: (param_name, param_span) } => {
lints::ElidedNamedLifetime {
elided,
name: param_name,
named_declaration: Some(param_span),
BuiltinLintDiag::ElidedNamedLifetimes { elided: (span, kind), resolution } => {
match resolution {
ElidedLifetimeResolution::Static => {
ElidedNamedLifetime { span, kind, name: kw::StaticLifetime, declaration: None }
}
ElidedLifetimeResolution::Param(name, declaration) => {
ElidedNamedLifetime { span, kind, name, declaration: Some(declaration) }
}
}
.decorate_lint(diag)
}

56
compiler/rustc_lint/src/lints.rs
View File

@ -9,7 +9,7 @@ use rustc_errors::{
};
use rustc_hir::def::Namespace;
use rustc_hir::def_id::DefId;
use rustc_hir::{self as hir};
use rustc_hir::{self as hir, MissingLifetimeKind};
use rustc_macros::{LintDiagnostic, Subdiagnostic};
use rustc_middle::ty::inhabitedness::InhabitedPredicate;
use rustc_middle::ty::{Clause, PolyExistentialTraitRef, Ty, TyCtxt};
@ -2623,14 +2623,56 @@ pub(crate) struct ElidedLifetimesInPaths {
pub subdiag: ElidedLifetimeInPathSubdiag,
}
#[derive(LintDiagnostic)]
#[diag(lint_elided_named_lifetime)]
pub(crate) struct ElidedNamedLifetime {
#[label(lint_label_elided)]
pub elided: Span,
pub span: Span,
pub kind: MissingLifetimeKind,
pub name: Symbol,
#[label(lint_label_named)]
pub named_declaration: Option<Span>,
pub declaration: Option<Span>,
}
impl<G: EmissionGuarantee> LintDiagnostic<'_, G> for ElidedNamedLifetime {
fn decorate_lint(self, diag: &mut rustc_errors::Diag<'_, G>) {
let Self { span, kind, name, declaration } = self;
diag.primary_message(fluent::lint_elided_named_lifetime);
diag.arg("name", name);
diag.span_label(span, fluent::lint_label_elided);
if let Some(declaration) = declaration {
diag.span_label(declaration, fluent::lint_label_named);
}
// FIXME(GrigorenkoPV): this `if` and `return` should be removed,
// but currently this lint's suggestions can conflict with those of `clippy::needless_lifetimes`:
// https://github.com/rust-lang/rust/pull/129840#issuecomment-2323349119
// HACK: `'static` suggestions will never sonflict, emit only those for now.
if name != rustc_span::symbol::kw::StaticLifetime {
return;
}
match kind {
MissingLifetimeKind::Underscore => diag.span_suggestion_verbose(
span,
fluent::lint_suggestion,
format!("{name}"),
Applicability::MachineApplicable,
),
MissingLifetimeKind::Ampersand => diag.span_suggestion_verbose(
span.shrink_to_hi(),
fluent::lint_suggestion,
format!("{name} "),
Applicability::MachineApplicable,
),
MissingLifetimeKind::Comma => diag.span_suggestion_verbose(
span.shrink_to_hi(),
fluent::lint_suggestion,
format!("{name}, "),
Applicability::MachineApplicable,
),
MissingLifetimeKind::Brackets => diag.span_suggestion_verbose(
span.shrink_to_hi(),
fluent::lint_suggestion,
format!("<{name}>"),
Applicability::MachineApplicable,
),
};
}
}
#[derive(LintDiagnostic)]

17
compiler/rustc_lint_defs/src/lib.rs
View File

@ -10,7 +10,7 @@ use rustc_data_structures::stable_hasher::{
};
use rustc_error_messages::{DiagMessage, MultiSpan};
use rustc_hir::def::Namespace;
use rustc_hir::{HashStableContext, HirId};
use rustc_hir::{HashStableContext, HirId, MissingLifetimeKind};
use rustc_macros::{Decodable, Encodable, HashStable_Generic};
use rustc_span::edition::Edition;
use rustc_span::symbol::{Ident, MacroRulesNormalizedIdent};
@ -556,6 +556,12 @@ pub enum DeprecatedSinceKind {
InVersion(String),
}
#[derive(Debug)]
pub enum ElidedLifetimeResolution {
Static,
Param(Symbol, Span),
}
// This could be a closure, but then implementing derive trait
// becomes hacky (and it gets allocated).
#[derive(Debug)]
@ -568,12 +574,9 @@ pub enum BuiltinLintDiag {
},
MacroExpandedMacroExportsAccessedByAbsolutePaths(Span),
ElidedLifetimesInPaths(usize, Span, bool, Span),
ElidedIsStatic {
elided: Span,
},
ElidedIsParam {
elided: Span,
param: (Symbol, Span),
ElidedNamedLifetimes {
elided: (Span, MissingLifetimeKind),
resolution: ElidedLifetimeResolution,
},
UnknownCrateTypes {
span: Span,

3
compiler/rustc_middle/src/ty/closure.rs
View File

@ -88,9 +88,6 @@ pub struct CapturedPlace<'tcx> {
/// Represents if `place` can be mutated or not.
pub mutability: hir::Mutability,
/// Region of the resulting reference if the upvar is captured by ref.
pub region: Option<ty::Region<'tcx>>,
}
impl<'tcx> CapturedPlace<'tcx> {

6
compiler/rustc_parse/messages.ftl
View File

@ -381,6 +381,7 @@ parse_invalid_char_in_escape_msg = invalid character in {$is_hex ->
*[false] unicode
} escape
parse_invalid_comparison_operator = invalid comparison operator `{$invalid}`
.use_instead = `{$invalid}` is not a valid comparison operator, use `{$correct}`
.spaceship_operator_invalid = `<=>` is not a valid comparison operator, use `std::cmp::Ordering`
@ -581,6 +582,11 @@ parse_missing_trait_in_trait_impl = missing trait in a trait impl
.suggestion_add_trait = add a trait here
.suggestion_remove_for = for an inherent impl, drop this `for`
parse_misspelled_kw = {$is_incorrect_case ->
[true] write keyword `{$similar_kw}` in lowercase
*[false] there is a keyword `{$similar_kw}` with a similar name
}
parse_modifier_lifetime = `{$modifier}` may only modify trait bounds, not lifetime bounds
.suggestion = remove the `{$modifier}`

85
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -19,8 +19,9 @@ use rustc_errors::{
Subdiagnostic,
};
use rustc_session::errors::ExprParenthesesNeeded;
use rustc_span::edit_distance::find_best_match_for_name;
use rustc_span::source_map::Spanned;
use rustc_span::symbol::{kw, sym, Ident};
use rustc_span::symbol::{kw, sym, AllKeywords, Ident};
use rustc_span::{BytePos, Span, SpanSnippetError, Symbol, DUMMY_SP};
use thin_vec::{thin_vec, ThinVec};
use tracing::{debug, trace};
@ -203,6 +204,37 @@ impl std::fmt::Display for UnaryFixity {
}
}
#[derive(Debug, rustc_macros::Subdiagnostic)]
#[suggestion(
parse_misspelled_kw,
applicability = "machine-applicable",
code = "{similar_kw}",
style = "verbose"
)]
struct MisspelledKw {
similar_kw: String,
#[primary_span]
span: Span,
is_incorrect_case: bool,
}
/// Checks if the given `lookup` identifier is similar to any keyword symbol in `candidates`.
fn find_similar_kw(lookup: Ident, candidates: &[Symbol]) -> Option<MisspelledKw> {
let lowercase = lookup.name.as_str().to_lowercase();
let lowercase_sym = Symbol::intern(&lowercase);
if candidates.contains(&lowercase_sym) {
Some(MisspelledKw { similar_kw: lowercase, span: lookup.span, is_incorrect_case: true })
} else if let Some(similar_sym) = find_best_match_for_name(candidates, lookup.name, None) {
Some(MisspelledKw {
similar_kw: similar_sym.to_string(),
span: lookup.span,
is_incorrect_case: false,
})
} else {
None
}
}
struct MultiSugg {
msg: String,
patches: Vec<(Span, String)>,
@ -638,9 +670,9 @@ impl<'a> Parser<'a> {
let concat = Symbol::intern(&format!("{prev}{cur}"));
let ident = Ident::new(concat, DUMMY_SP);
if ident.is_used_keyword() || ident.is_reserved() || ident.is_raw_guess() {
let span = self.prev_token.span.to(self.token.span);
let concat_span = self.prev_token.span.to(self.token.span);
err.span_suggestion_verbose(
span,
concat_span,
format!("consider removing the space to spell keyword `{concat}`"),
concat,
Applicability::MachineApplicable,
@ -741,9 +773,55 @@ impl<'a> Parser<'a> {
err.span_label(sp, label_exp);
err.span_label(self.token.span, "unexpected token");
}
// Check for misspelled keywords if there are no suggestions added to the diagnostic.
if err.suggestions.as_ref().is_ok_and(|code_suggestions| code_suggestions.is_empty()) {
self.check_for_misspelled_kw(&mut err, &expected);
}
Err(err)
}
/// Checks if the current token or the previous token are misspelled keywords
/// and adds a helpful suggestion.
fn check_for_misspelled_kw(&self, err: &mut Diag<'_>, expected: &[TokenType]) {
let Some((curr_ident, _)) = self.token.ident() else {
return;
};
let expected_tokens: &[TokenType] =
expected.len().checked_sub(10).map_or(&expected, |index| &expected[index..]);
let expected_keywords: Vec<Symbol> = expected_tokens
.iter()
.filter_map(|token| if let TokenType::Keyword(kw) = token { Some(*kw) } else { None })
.collect();
// When there are a few keywords in the last ten elements of `self.expected_tokens` and the current
// token is an identifier, it's probably a misspelled keyword.
// This handles code like `async Move {}`, misspelled `if` in match guard, misspelled `else` in `if`-`else`
// and mispelled `where` in a where clause.
if !expected_keywords.is_empty()
&& !curr_ident.is_used_keyword()
&& let Some(misspelled_kw) = find_similar_kw(curr_ident, &expected_keywords)
{
err.subdiagnostic(misspelled_kw);
} else if let Some((prev_ident, _)) = self.prev_token.ident()
&& !prev_ident.is_used_keyword()
{
// We generate a list of all keywords at runtime rather than at compile time
// so that it gets generated only when the diagnostic needs it.
// Also, it is unlikely that this list is generated multiple times because the
// parser halts after execution hits this path.
let all_keywords = AllKeywords::new().collect_used(|| prev_ident.span.edition());
// Otherwise, check the previous token with all the keywords as possible candidates.
// This handles code like `Struct Human;` and `While a < b {}`.
// We check the previous token only when the current token is an identifier to avoid false
// positives like suggesting keyword `for` for `extern crate foo {}`.
if let Some(misspelled_kw) = find_similar_kw(prev_ident, &all_keywords) {
err.subdiagnostic(misspelled_kw);
}
}
}
/// The user has written `#[attr] expr` which is unsupported. (#106020)
pub(super) fn attr_on_non_tail_expr(&self, expr: &Expr) -> ErrorGuaranteed {
// Missing semicolon typo error.
@ -846,6 +924,7 @@ impl<'a> Parser<'a> {
);
}
}
err.emit()
}

14
compiler/rustc_resolve/src/late.rs
View File

@ -2062,7 +2062,10 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
lint::builtin::ELIDED_NAMED_LIFETIMES,
missing.id_for_lint,
missing.span,
BuiltinLintDiag::ElidedIsStatic { elided: missing.span },
BuiltinLintDiag::ElidedNamedLifetimes {
elided: (missing.span, missing.kind),
resolution: lint::ElidedLifetimeResolution::Static,
},
);
}
}
@ -2072,9 +2075,12 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
lint::builtin::ELIDED_NAMED_LIFETIMES,
missing.id_for_lint,
missing.span,
BuiltinLintDiag::ElidedIsParam {
elided: missing.span,
param: (tcx.item_name(param.into()), tcx.source_span(param)),
BuiltinLintDiag::ElidedNamedLifetimes {
elided: (missing.span, missing.kind),
resolution: lint::ElidedLifetimeResolution::Param(
tcx.item_name(param.into()),
tcx.source_span(param),
),
},
);
}

42
compiler/rustc_span/src/symbol.rs
View File

@ -20,7 +20,8 @@ mod tests;
// The proc macro code for this is in `compiler/rustc_macros/src/symbols.rs`.
symbols! {
// If you modify this list, adjust `is_special` and `is_used_keyword`/`is_unused_keyword`.
// If you modify this list, adjust `is_special`, `is_used_keyword`/`is_unused_keyword`
// and `AllKeywords`.
// But this should rarely be necessary if the keywords are kept in alphabetic order.
Keywords {
// Special reserved identifiers used internally for elided lifetimes,
@ -2579,3 +2580,42 @@ impl Ident {
self.name.can_be_raw() && self.is_reserved()
}
}
/// An iterator over all the keywords in Rust.
#[derive(Copy, Clone)]
pub struct AllKeywords {
curr_idx: u32,
end_idx: u32,
}
impl AllKeywords {
/// Initialize a new iterator over all the keywords.
///
/// *Note:* Please update this if a new keyword is added beyond the current
/// range.
pub fn new() -> Self {
AllKeywords { curr_idx: kw::Empty.as_u32(), end_idx: kw::Yeet.as_u32() }
}
/// Collect all the keywords in a given edition into a vector.
pub fn collect_used(&self, edition: impl Copy + FnOnce() -> Edition) -> Vec<Symbol> {
self.filter(|&keyword| {
keyword.is_used_keyword_always() || keyword.is_used_keyword_conditional(edition)
})
.collect()
}
}
impl Iterator for AllKeywords {
type Item = Symbol;
fn next(&mut self) -> Option<Self::Item> {
if self.curr_idx <= self.end_idx {
let keyword = Symbol::new(self.curr_idx);
self.curr_idx += 1;
Some(keyword)
} else {
None
}
}
}

8
library/std/src/sync/condvar.rs
View File

@ -195,8 +195,11 @@ impl Condvar {
if poisoned { Err(PoisonError::new(guard)) } else { Ok(guard) }
}
/// Blocks the current thread until this condition variable receives a
/// notification and the provided condition is false.
/// Blocks the current thread until the provided condition becomes false.
///
/// `condition` is checked immediately; if not met (returns `true`), this
/// will [`wait`] for the next notification then check again. This repeats
/// until `condition` returns `false`, in which case this function returns.
///
/// This function will atomically unlock the mutex specified (represented by
/// `guard`) and block the current thread. This means that any calls
@ -210,6 +213,7 @@ impl Condvar {
/// poisoned when this thread re-acquires the lock. For more information,
/// see information about [poisoning] on the [`Mutex`] type.
///
/// [`wait`]: Self::wait
/// [`notify_one`]: Self::notify_one
/// [`notify_all`]: Self::notify_all
/// [poisoning]: super::Mutex#poisoning

7
tests/assembly/asm/aarch64-modifiers.rs
View File

@ -1,6 +1,7 @@
//@ assembly-output: emit-asm
//@ compile-flags: -O -C panic=abort
//@ compile-flags: --target aarch64-unknown-linux-gnu
//@ compile-flags: -Zmerge-functions=disabled
//@ needs-llvm-components: aarch64
#![feature(no_core, lang_items, rustc_attrs)]
@ -29,12 +30,6 @@ macro_rules! check {
// -O and extern "C" guarantee that the selected register is always r0/s0/d0/q0
#[no_mangle]
pub unsafe extern "C" fn $func() -> i32 {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!($code, out($reg) y);
y

13
tests/assembly/asm/aarch64-types.rs
View File

@ -4,6 +4,7 @@
//@ [aarch64] needs-llvm-components: aarch64
//@ [arm64ec] compile-flags: --target arm64ec-pc-windows-msvc
//@ [arm64ec] needs-llvm-components: aarch64
//@ compile-flags: -Zmerge-functions=disabled
#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch, f16, f128)]
#![crate_type = "rlib"]
@ -132,12 +133,6 @@ macro_rules! check {
// LLVM issue: <https://github.com/llvm/llvm-project/issues/94434>
#[no_mangle]
pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let x = *inp;
let y;
asm!(
@ -155,12 +150,6 @@ macro_rules! check_reg {
// FIXME(f16_f128): See FIXME in `check!`
#[no_mangle]
pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let x = *inp;
let y;
asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);

7
tests/assembly/asm/arm-modifiers.rs
View File

@ -2,6 +2,7 @@
//@ compile-flags: -O -C panic=abort
//@ compile-flags: --target armv7-unknown-linux-gnueabihf
//@ compile-flags: -C target-feature=+neon
//@ compile-flags: -Zmerge-functions=disabled
//@ needs-llvm-components: arm
#![feature(no_core, lang_items, rustc_attrs, repr_simd)]
@ -40,12 +41,6 @@ macro_rules! check {
// -O and extern "C" guarantee that the selected register is always r0/s0/d0/q0
#[no_mangle]
pub unsafe extern "C" fn $func() -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " {0:", $modifier, "}, {0:", $modifier, "}"), out($reg) y);
y

13
tests/assembly/asm/arm-types.rs
View File

@ -2,6 +2,7 @@
//@ assembly-output: emit-asm
//@ compile-flags: --target armv7-unknown-linux-gnueabihf
//@ compile-flags: -C opt-level=0
//@ compile-flags: -Zmerge-functions=disabled
//@[d32] compile-flags: -C target-feature=+d32
//@[neon] compile-flags: -C target-feature=+neon --cfg d32
//@[neon] filecheck-flags: --check-prefix d32
@ -114,12 +115,6 @@ macro_rules! check {
($func:ident $ty:ident $class:ident $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " {}, {}"), out($class) y, in($class) x);
y
@ -131,12 +126,6 @@ macro_rules! check_reg {
($func:ident $ty:ident $reg:tt $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
y

25
tests/assembly/asm/hexagon-types.rs
View File

@ -1,5 +1,6 @@
//@ assembly-output: emit-asm
//@ compile-flags: --target hexagon-unknown-linux-musl
//@ compile-flags: -Zmerge-functions=disabled
//@ needs-llvm-components: hexagon
#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch)]
@ -41,12 +42,6 @@ macro_rules! check {
($func:ident $ty:ident $class:ident) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!("{} = {}", out($class) y, in($class) x);
y
@ -58,12 +53,6 @@ macro_rules! check_reg {
($func:ident $ty:ident $reg:tt) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x);
y
@ -77,12 +66,6 @@ macro_rules! check_reg {
// CHECK: InlineAsm End
#[no_mangle]
pub unsafe fn sym_static() {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
asm!("r0 = #{}", sym extern_static);
}
@ -92,12 +75,6 @@ pub unsafe fn sym_static() {
// CHECK: InlineAsm End
#[no_mangle]
pub unsafe fn sym_fn() {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
asm!("r0 = #{}", sym extern_func);
}

10
tests/assembly/asm/loongarch-type.rs
View File

@ -1,5 +1,6 @@
//@ assembly-output: emit-asm
//@ compile-flags: --target loongarch64-unknown-linux-gnu
//@ compile-flags: -Zmerge-functions=disabled
//@ needs-llvm-components: loongarch
#![feature(no_core, lang_items, rustc_attrs, asm_experimental_arch)]
@ -39,11 +40,6 @@ extern "C" {
static extern_static: u8;
}
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
// CHECK-LABEL: sym_fn:
// CHECK: #APP
// CHECK: pcalau12i $t0, %got_pc_hi20(extern_func)
@ -67,8 +63,6 @@ pub unsafe fn sym_static() {
macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
dont_merge(stringify!($func));
let y;
asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
y
@ -78,8 +72,6 @@ macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
y

10
tests/assembly/asm/mips-types.rs
View File

@ -4,6 +4,7 @@
//@[mips32] needs-llvm-components: mips
//@[mips64] compile-flags: --target mips64-unknown-linux-gnuabi64
//@[mips64] needs-llvm-components: mips
//@ compile-flags: -Zmerge-functions=disabled
#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch)]
#![crate_type = "rlib"]
@ -43,16 +44,9 @@ extern "C" {
static extern_static: u8;
}
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
dont_merge(stringify!($func));
let y;
asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
y
@ -62,8 +56,6 @@ macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
y

10
tests/assembly/asm/powerpc-types.rs
View File

@ -4,6 +4,7 @@
//@[powerpc] needs-llvm-components: powerpc
//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu
//@[powerpc64] needs-llvm-components: powerpc
//@ compile-flags: -Zmerge-functions=disabled
#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch)]
#![crate_type = "rlib"]
@ -43,16 +44,9 @@ extern "C" {
static extern_static: u8;
}
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
dont_merge(stringify!($func));
let y;
asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
y
@ -62,8 +56,6 @@ macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
macro_rules! check_reg { ($func:ident, $ty:ty, $rego:tt, $regc:tt, $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " ", $rego, ", ", $rego), lateout($regc) y, in($regc) x);
y

13
tests/assembly/asm/riscv-types.rs
View File

@ -27,6 +27,7 @@
//@[riscv32-zfh] filecheck-flags: --check-prefix zfhmin
//@ compile-flags: -C target-feature=+d
//@ compile-flags: -Zmerge-functions=disabled
#![feature(no_core, lang_items, rustc_attrs, f16)]
#![crate_type = "rlib"]
@ -90,12 +91,6 @@ macro_rules! check {
($func:ident $ty:ident $class:ident $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " {}, {}"), out($class) y, in($class) x);
y
@ -107,12 +102,6 @@ macro_rules! check_reg {
($func:ident $ty:ident $reg:tt $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
y

10
tests/assembly/asm/s390x-types.rs
View File

@ -2,6 +2,7 @@
//@ assembly-output: emit-asm
//@[s390x] compile-flags: --target s390x-unknown-linux-gnu
//@[s390x] needs-llvm-components: systemz
//@ compile-flags: -Zmerge-functions=disabled
#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch)]
#![crate_type = "rlib"]
@ -42,16 +43,9 @@ extern "C" {
static extern_static: u8;
}
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
dont_merge(stringify!($func));
let y;
asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
y
@ -61,8 +55,6 @@ macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " %", $reg, ", %", $reg), lateout($reg) y, in($reg) x);
y

7
tests/assembly/asm/x86-modifiers.rs
View File

@ -7,6 +7,7 @@
//@[i686] needs-llvm-components: x86
//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
//@ compile-flags: -C target-feature=+avx512bw
//@ compile-flags: -Zmerge-functions=disabled
#![feature(no_core, lang_items, rustc_attrs)]
#![crate_type = "rlib"]
@ -38,12 +39,6 @@ macro_rules! check {
// -O and extern "C" guarantee that the selected register is always ax/xmm0
#[no_mangle]
pub unsafe extern "C" fn $func() -> i32 {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " {0:", $modifier, "}, {0:", $modifier, "}"), out($reg) y);
y

13
tests/assembly/asm/x86-types.rs
View File

@ -6,6 +6,7 @@
//@[i686] needs-llvm-components: x86
//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
//@ compile-flags: -C target-feature=+avx512bw
//@ compile-flags: -Zmerge-functions=disabled
#![feature(no_core, lang_items, rustc_attrs, repr_simd, f16, f128)]
#![crate_type = "rlib"]
@ -283,12 +284,6 @@ macro_rules! check {
($func:ident $ty:ident $class:ident $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " {}, {}"), lateout($class) y, in($class) x);
y
@ -300,12 +295,6 @@ macro_rules! check_reg {
($func:ident $ty:ident $reg:tt $mov:literal) => {
#[no_mangle]
pub unsafe fn $func(x: $ty) -> $ty {
// Hack to avoid function merging
extern "Rust" {
fn dont_merge(s: &str);
}
dont_merge(stringify!($func));
let y;
asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
y

46
tests/assembly/s390x-backchain-toggle.rs Normal file
View File

@ -0,0 +1,46 @@
//@ revisions: enable-backchain disable-backchain
//@ assembly-output: emit-asm
//@ compile-flags: -O --crate-type=lib --target=s390x-unknown-linux-gnu
//@ needs-llvm-components: systemz
//@[enable-backchain] compile-flags: -Ctarget-feature=+backchain
//@[disable-backchain] compile-flags: -Ctarget-feature=-backchain
#![feature(no_core, lang_items)]
#![no_std]
#![no_core]
#[lang = "sized"]
trait Sized {}
extern "C" {
fn extern_func();
}
// CHECK-LABEL: test_backchain
#[no_mangle]
extern "C" fn test_backchain() -> i32 {
// Here we try to match if backchain register is saved to the parameter area (stored in r15/sp)
// And also if a new parameter area (160 bytes) is allocated for the upcoming function call
// enable-backchain: lgr [[REG1:.*]], %r15
// enable-backchain-NEXT: aghi %r15, -160
// enable-backchain: stg [[REG1]], 0(%r15)
// disable-backchain: aghi %r15, -160
// disable-backchain-NOT: stg %r{{.*}}, 0(%r15)
unsafe {
extern_func();
}
// enable-backchain-NEXT: brasl %r{{.*}}, extern_func@PLT
// disable-backchain: brasl %r{{.*}}, extern_func@PLT
// Make sure that the expected return value is written into %r2 (return register):
// enable-backchain-NEXT: lghi %r2, 1
// disable-backchain: lghi %r2, 0
#[cfg(target_feature = "backchain")]
{
1
}
#[cfg(not(target_feature = "backchain"))]
{
0
}
// CHECK: br %r{{.*}}
}

22
tests/codegen/naked-asan.rs Normal file
View File

@ -0,0 +1,22 @@
// Make sure we do not request sanitizers for naked functions.
//@ only-x86_64
//@ needs-sanitizer-address
//@ compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static
#![crate_type = "lib"]
#![no_std]
#![feature(abi_x86_interrupt, naked_functions)]
// CHECK: define x86_intrcc void @page_fault_handler(ptr {{.*}}%0, i64 {{.*}}%1){{.*}}#[[ATTRS:[0-9]+]] {
// CHECK-NOT: memcpy
#[naked]
#[no_mangle]
pub extern "x86-interrupt" fn page_fault_handler(_: u64, _: u64) {
unsafe {
core::arch::asm!("ud2", options(noreturn));
}
}
// CHECK: #[[ATTRS]] =
// CHECK-NOT: sanitize_address

2
tests/ui/const-generics/invariant.rs
View File

@ -5,7 +5,7 @@ use std::marker::PhantomData;
trait SadBee {
const ASSOC: usize;
}
// fn(&'static ())` is a supertype of `for<'a> fn(&'a ())` while
// `fn(&'static ())` is a supertype of `for<'a> fn(&'a ())` while
// we allow two different impls for these types, leading
// to different const eval results.
impl SadBee for for<'a> fn(&'a ()) {

4
tests/ui/lint/elided-named-lifetimes/example-from-issue48686.stderr
View File

@ -9,6 +9,10 @@ note: the lint level is defined here
|
LL | #![deny(elided_named_lifetimes)]
| ^^^^^^^^^^^^^^^^^^^^^^
help: consider specifying it explicitly
|
LL | pub fn get_mut(&'static self, x: &mut u8) -> &'static mut u8 {
| +++++++
error: aborting due to 1 previous error

8
tests/ui/lint/elided-named-lifetimes/not-tied-to-crate.stderr
View File

@ -9,6 +9,10 @@ note: the lint level is defined here
|
LL | #[warn(elided_named_lifetimes)]
| ^^^^^^^^^^^^^^^^^^^^^^
help: consider specifying it explicitly
|
LL | fn bar(x: &'static u8) -> &'static u8 {
| +++++++
error: elided lifetime has a name
--> $DIR/not-tied-to-crate.rs:11:31
@ -21,6 +25,10 @@ note: the lint level is defined here
|
LL | #[deny(elided_named_lifetimes)]
| ^^^^^^^^^^^^^^^^^^^^^^
help: consider specifying it explicitly
|
LL | fn baz(x: &'static u8) -> &'static u8 {
| +++++++
error: aborting due to 1 previous error; 1 warning emitted

19
tests/ui/lint/elided-named-lifetimes/static.stderr
View File

@ -9,24 +9,43 @@ note: the lint level is defined here
|
LL | #![deny(elided_named_lifetimes)]
| ^^^^^^^^^^^^^^^^^^^^^^
help: consider specifying it explicitly
|
LL | fn ampersand(x: &'static u8) -> &'static u8 {
| +++++++
error: elided lifetime has a name
--> $DIR/static.rs:23:32
|
LL | fn brackets(x: &'static u8) -> Brackets {
| ^^^^^^^^ this elided lifetime gets resolved as `'static`
|
help: consider specifying it explicitly
|
LL | fn brackets(x: &'static u8) -> Brackets<'static> {
| +++++++++
error: elided lifetime has a name
--> $DIR/static.rs:30:34
|
LL | fn comma(x: &'static u8) -> Comma<u8> {
| ^ this elided lifetime gets resolved as `'static`
|
help: consider specifying it explicitly
|
LL | fn comma(x: &'static u8) -> Comma<'static, u8> {
| ++++++++
error: elided lifetime has a name
--> $DIR/static.rs:35:35
|
LL | fn underscore(x: &'static u8) -> &'_ u8 {
| ^^ this elided lifetime gets resolved as `'static`
|
help: consider specifying it explicitly
|
LL | fn underscore(x: &'static u8) -> &'static u8 {
| ~~~~~~~
error: aborting due to 4 previous errors

5
tests/ui/parser/extern-crate-unexpected-token.stderr
View File

@ -3,6 +3,11 @@ error: expected one of `crate` or `{`, found `crte`
|
LL | extern crte foo;
| ^^^^ expected one of `crate` or `{`
|
help: there is a keyword `crate` with a similar name
|
LL | extern crate foo;
| ~~~~~
error: aborting due to 1 previous error

33
tests/ui/parser/issues/issue-70549-resolve-after-recovered-self-ctor.stderr
View File

@ -8,10 +8,16 @@ error: expected one of `:`, `@`, or `|`, found keyword `Self`
--> $DIR/issue-70549-resolve-after-recovered-self-ctor.rs:4:17
|
LL | fn foo(&mur Self) {}
| -----^^^^
| | |
| | expected one of `:`, `@`, or `|`
| help: declare the type after the parameter binding: `<identifier>: <type>`
| ^^^^ expected one of `:`, `@`, or `|`
|
help: there is a keyword `mut` with a similar name
|
LL | fn foo(&mut Self) {}
| ~~~
help: declare the type after the parameter binding
|
LL | fn foo(<identifier>: <type>) {}
| ~~~~~~~~~~~~~~~~~~~~
error: unexpected lifetime `'static` in pattern
--> $DIR/issue-70549-resolve-after-recovered-self-ctor.rs:8:13
@ -35,16 +41,27 @@ error: expected one of `:`, `@`, or `|`, found keyword `Self`
--> $DIR/issue-70549-resolve-after-recovered-self-ctor.rs:8:25
|
LL | fn bar(&'static mur Self) {}
| -------------^^^^
| | |
| | expected one of `:`, `@`, or `|`
| help: declare the type after the parameter binding: `<identifier>: <type>`
| ^^^^ expected one of `:`, `@`, or `|`
|
help: there is a keyword `mut` with a similar name
|
LL | fn bar(&'static mut Self) {}
| ~~~
help: declare the type after the parameter binding
|
LL | fn bar(<identifier>: <type>) {}
| ~~~~~~~~~~~~~~~~~~~~
error: expected one of `:`, `@`, or `|`, found keyword `Self`
--> $DIR/issue-70549-resolve-after-recovered-self-ctor.rs:14:17
|
LL | fn baz(&mur Self @ _) {}
| ^^^^ expected one of `:`, `@`, or `|`
|
help: there is a keyword `mut` with a similar name
|
LL | fn baz(&mut Self @ _) {}
| ~~~
error[E0533]: expected unit struct, found self constructor `Self`
--> $DIR/issue-70549-resolve-after-recovered-self-ctor.rs:4:17

6
tests/ui/parser/misspelled-keywords/assoc-type.rs Normal file
View File

@ -0,0 +1,6 @@
trait Animal {
Type Result = u8;
//~^ ERROR expected one of
}
fn main() {}

18
tests/ui/parser/misspelled-keywords/assoc-type.stderr Normal file
View File

@ -0,0 +1,18 @@
error: expected one of `!` or `::`, found `Result`
--> $DIR/assoc-type.rs:2:10
|
LL | trait Animal {
| - while parsing this item list starting here
LL | Type Result = u8;
| ^^^^^^ expected one of `!` or `::`
LL |
LL | }
| - the item list ends here
|
help: write keyword `type` in lowercase
|
LL | type Result = u8;
| ~~~~
error: aborting due to 1 previous error

6
tests/ui/parser/misspelled-keywords/async-move.rs Normal file
View File

@ -0,0 +1,6 @@
//@ edition: 2018
fn main() {
async Move {}
//~^ ERROR expected one of
}

13
tests/ui/parser/misspelled-keywords/async-move.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `move`, `|`, or `||`, found `Move`
--> $DIR/async-move.rs:4:11
|
LL | async Move {}
| ^^^^ expected one of `move`, `|`, or `||`
|
help: write keyword `move` in lowercase
|
LL | async move {}
| ~~~~
error: aborting due to 1 previous error

5
tests/ui/parser/misspelled-keywords/const-fn.rs Normal file
View File

@ -0,0 +1,5 @@
cnst fn code() {}
//~^ ERROR expected one of
fn main() {
}

13
tests/ui/parser/misspelled-keywords/const-fn.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!` or `::`, found keyword `fn`
--> $DIR/const-fn.rs:1:6
|
LL | cnst fn code() {}
| ^^ expected one of `!` or `::`
|
help: there is a keyword `const` with a similar name
|
LL | const fn code() {}
| ~~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/const-generics.rs Normal file
View File

@ -0,0 +1,4 @@
fn foo<consta N: usize>(_arr: [i32; N]) {}
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/const-generics.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `,`, `:`, `=`, or `>`, found `N`
--> $DIR/const-generics.rs:1:15
|
LL | fn foo<consta N: usize>(_arr: [i32; N]) {}
| ^ expected one of `,`, `:`, `=`, or `>`
|
help: there is a keyword `const` with a similar name
|
LL | fn foo<const N: usize>(_arr: [i32; N]) {}
| ~~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/const.rs Normal file
View File

@ -0,0 +1,4 @@
cons A: u8 = 10;
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/const.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!` or `::`, found `A`
--> $DIR/const.rs:1:6
|
LL | cons A: u8 = 10;
| ^ expected one of `!` or `::`
|
help: there is a keyword `const` with a similar name
|
LL | const A: u8 = 10;
| ~~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/for-loop.rs Normal file
View File

@ -0,0 +1,4 @@
fn main() {
form i in 1..10 {}
//~^ ERROR expected one of
}

13
tests/ui/parser/misspelled-keywords/for-loop.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `i`
--> $DIR/for-loop.rs:2:10
|
LL | form i in 1..10 {}
| ^ expected one of 8 possible tokens
|
help: there is a keyword `for` with a similar name
|
LL | for i in 1..10 {}
| ~~~
error: aborting due to 1 previous error

16
tests/ui/parser/misspelled-keywords/hrdt.rs Normal file
View File

@ -0,0 +1,16 @@
struct Closure<F> {
data: (u8, u16),
func: F,
}
impl<F> Closure<F>
Where for<'a> F: Fn(&'a (u8, u16)) -> &'a u8,
//~^ ERROR expected one of
{
fn call(&self) -> &u8 {
(self.func)(&self.data)
}
}
fn main() {}

13
tests/ui/parser/misspelled-keywords/hrdt.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!`, `(`, `+`, `::`, `<`, `where`, or `{`, found keyword `for`
--> $DIR/hrdt.rs:7:11
|
LL | Where for<'a> F: Fn(&'a (u8, u16)) -> &'a u8,
| ^^^ expected one of 7 possible tokens
|
help: write keyword `where` in lowercase (notice the capitalization difference)
|
LL | where for<'a> F: Fn(&'a (u8, u16)) -> &'a u8,
| ~~~~~
error: aborting due to 1 previous error

6
tests/ui/parser/misspelled-keywords/impl-block.rs Normal file
View File

@ -0,0 +1,6 @@
struct Human;
ipml Human {}
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/impl-block.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!` or `::`, found `Human`
--> $DIR/impl-block.rs:3:6
|
LL | ipml Human {}
| ^^^^^ expected one of `!` or `::`
|
help: there is a keyword `impl` with a similar name
|
LL | impl Human {}
| ~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/impl-return.rs Normal file
View File

@ -0,0 +1,4 @@
fn code() -> Impl Display {}
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/impl-return.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!`, `(`, `+`, `::`, `<`, `where`, or `{`, found `Display`
--> $DIR/impl-return.rs:1:19
|
LL | fn code() -> Impl Display {}
| ^^^^^^^ expected one of 7 possible tokens
|
help: write keyword `impl` in lowercase (notice the capitalization difference)
|
LL | fn code() -> impl Display {}
| ~~~~
error: aborting due to 1 previous error

6
tests/ui/parser/misspelled-keywords/impl-trait-for.rs Normal file
View File

@ -0,0 +1,6 @@
struct Human;
impl Debug form Human {}
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/impl-trait-for.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!`, `(`, `+`, `::`, `<`, `where`, or `{`, found `Human`
--> $DIR/impl-trait-for.rs:3:17
|
LL | impl Debug form Human {}
| ^^^^^ expected one of 7 possible tokens
|
help: there is a keyword `for` with a similar name
|
LL | impl Debug for Human {}
| ~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/impl-trait.rs Normal file
View File

@ -0,0 +1,4 @@
fn code<T: impll Debug>() -> u8 {}
//~^ ERROR expected one of
fn main() {}

17
tests/ui/parser/misspelled-keywords/impl-trait.stderr Normal file
View File

@ -0,0 +1,17 @@
error: expected one of `(`, `+`, `,`, `::`, `<`, `=`, or `>`, found `Debug`
--> $DIR/impl-trait.rs:1:18
|
LL | fn code<T: impll Debug>() -> u8 {}
| ^^^^^ expected one of 7 possible tokens
|
help: there is a keyword `impl` with a similar name
|
LL | fn code<T: impl Debug>() -> u8 {}
| ~~~~
help: you might have meant to end the type parameters here
|
LL | fn code<T: impll> Debug>() -> u8 {}
| +
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/let-else.rs Normal file
View File

@ -0,0 +1,4 @@
fn main() {
let Some(a) = Some(10) elze {}
//~^ ERROR expected one of
}

13
tests/ui/parser/misspelled-keywords/let-else.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `elze`
--> $DIR/let-else.rs:2:28
|
LL | let Some(a) = Some(10) elze {}
| ^^^^ expected one of `.`, `;`, `?`, `else`, or an operator
|
help: there is a keyword `else` with a similar name
|
LL | let Some(a) = Some(10) else {}
| ~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/let-mut.rs Normal file
View File

@ -0,0 +1,4 @@
fn main() {
let muta a = 10;
//~^ ERROR expected one of
}

13
tests/ui/parser/misspelled-keywords/let-mut.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `:`, `;`, `=`, `@`, or `|`, found `a`
--> $DIR/let-mut.rs:2:14
|
LL | let muta a = 10;
| ^ expected one of `:`, `;`, `=`, `@`, or `|`
|
help: there is a keyword `mut` with a similar name
|
LL | let mut a = 10;
| ~~~
error: aborting due to 1 previous error

9
tests/ui/parser/misspelled-keywords/let.rs Normal file
View File

@ -0,0 +1,9 @@
fn main() {
Let a = 10;
//~^ ERROR expected one of
}
fn code() {
lett a = 10;
//~^ ERROR expected one of
}

24
tests/ui/parser/misspelled-keywords/let.stderr Normal file
View File

@ -0,0 +1,24 @@
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `a`
--> $DIR/let.rs:2:9
|
LL | Let a = 10;
| ^ expected one of 8 possible tokens
|
help: write keyword `let` in lowercase
|
LL | let a = 10;
| ~~~
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `a`
--> $DIR/let.rs:7:10
|
LL | lett a = 10;
| ^ expected one of 8 possible tokens
|
help: there is a keyword `let` with a similar name
|
LL | let a = 10;
| ~~~
error: aborting due to 2 previous errors

5
tests/ui/parser/misspelled-keywords/match.rs Normal file
View File

@ -0,0 +1,5 @@
fn main() {
let a = 10;
matche a {}
//~^ ERROR expected one of
}

13
tests/ui/parser/misspelled-keywords/match.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `a`
--> $DIR/match.rs:3:12
|
LL | matche a {}
| ^ expected one of 8 possible tokens
|
help: there is a keyword `match` with a similar name
|
LL | match a {}
| ~~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/mod.rs Normal file
View File

@ -0,0 +1,4 @@
mode parser;
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/mod.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!` or `::`, found `parser`
--> $DIR/mod.rs:1:6
|
LL | mode parser;
| ^^^^^^ expected one of `!` or `::`
|
help: there is a keyword `mod` with a similar name
|
LL | mod parser;
| ~~~
error: aborting due to 1 previous error

5
tests/ui/parser/misspelled-keywords/pub-fn.rs Normal file
View File

@ -0,0 +1,5 @@
puB fn code() {}
//~^ ERROR expected one of
fn main() {
}

13
tests/ui/parser/misspelled-keywords/pub-fn.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `#`, `async`, `auto`, `const`, `default`, `enum`, `extern`, `fn`, `gen`, `impl`, `macro_rules`, `macro`, `mod`, `pub`, `safe`, `static`, `struct`, `trait`, `type`, `unsafe`, or `use`, found `puB`
--> $DIR/pub-fn.rs:1:1
|
LL | puB fn code() {}
| ^^^ expected one of 21 possible tokens
|
help: write keyword `pub` in lowercase
|
LL | pub fn code() {}
| ~~~
error: aborting due to 1 previous error

9
tests/ui/parser/misspelled-keywords/ref.rs Normal file
View File

@ -0,0 +1,9 @@
fn main() {
let a = Some(vec![1, 2]);
match a {
Some(refe list) => println!("{list:?}"),
//~^ ERROR expected one of
//~| ERROR this pattern has 2 fields,
_ => println!("none"),
}
}

27
tests/ui/parser/misspelled-keywords/ref.stderr Normal file
View File

@ -0,0 +1,27 @@
error: expected one of `)`, `,`, `@`, or `|`, found `list`
--> $DIR/ref.rs:4:19
|
LL | Some(refe list) => println!("{list:?}"),
| ^^^^ expected one of `)`, `,`, `@`, or `|`
|
help: there is a keyword `ref` with a similar name
|
LL | Some(ref list) => println!("{list:?}"),
| ~~~
help: missing `,`
|
LL | Some(refe, list) => println!("{list:?}"),
| +
error[E0023]: this pattern has 2 fields, but the corresponding tuple variant has 1 field
--> $DIR/ref.rs:4:14
|
LL | Some(refe list) => println!("{list:?}"),
| ^^^^ ^^^^ expected 1 field, found 2
--> $SRC_DIR/core/src/option.rs:LL:COL
|
= note: tuple variant has 1 field
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0023`.

7
tests/ui/parser/misspelled-keywords/return.rs Normal file
View File

@ -0,0 +1,7 @@
fn code() -> u8 {
let a = 10;
returnn a;
//~^ ERROR expected one of
}
fn main() {}

13
tests/ui/parser/misspelled-keywords/return.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `a`
--> $DIR/return.rs:3:13
|
LL | returnn a;
| ^ expected one of 8 possible tokens
|
help: there is a keyword `return` with a similar name
|
LL | return a;
| ~~~~~~
error: aborting due to 1 previous error

5
tests/ui/parser/misspelled-keywords/static-mut.rs Normal file
View File

@ -0,0 +1,5 @@
static muta a: u8 = 0;
//~^ ERROR expected one of
//~| ERROR missing type for
fn main() {}

24
tests/ui/parser/misspelled-keywords/static-mut.stderr Normal file
View File

@ -0,0 +1,24 @@
error: expected one of `:`, `;`, or `=`, found `a`
--> $DIR/static-mut.rs:1:13
|
LL | static muta a: u8 = 0;
| ^ expected one of `:`, `;`, or `=`
|
help: there is a keyword `mut` with a similar name
|
LL | static mut a: u8 = 0;
| ~~~
error: missing type for `static` item
--> $DIR/static-mut.rs:1:12
|
LL | static muta a: u8 = 0;
| ^
|
help: provide a type for the item
|
LL | static muta: <type> a: u8 = 0;
| ++++++++
error: aborting due to 2 previous errors

4
tests/ui/parser/misspelled-keywords/static.rs Normal file
View File

@ -0,0 +1,4 @@
Static a = 0;
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/static.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!` or `::`, found `a`
--> $DIR/static.rs:1:8
|
LL | Static a = 0;
| ^ expected one of `!` or `::`
|
help: write keyword `static` in lowercase (notice the capitalization difference)
|
LL | static a = 0;
| ~~~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/struct.rs Normal file
View File

@ -0,0 +1,4 @@
Struct Foor {
//~^ ERROR expected one of
hello: String,
}

13
tests/ui/parser/misspelled-keywords/struct.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!` or `::`, found `Foor`
--> $DIR/struct.rs:1:8
|
LL | Struct Foor {
| ^^^^ expected one of `!` or `::`
|
help: write keyword `struct` in lowercase (notice the capitalization difference)
|
LL | struct Foor {
| ~~~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/unsafe-fn.rs Normal file
View File

@ -0,0 +1,4 @@
unsafee fn code() {}
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/unsafe-fn.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!` or `::`, found keyword `fn`
--> $DIR/unsafe-fn.rs:1:9
|
LL | unsafee fn code() {}
| ^^ expected one of `!` or `::`
|
help: there is a keyword `unsafe` with a similar name
|
LL | unsafe fn code() {}
| ~~~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/use.rs Normal file
View File

@ -0,0 +1,4 @@
usee a::b;
//~^ ERROR expected one of
fn main() {}

13
tests/ui/parser/misspelled-keywords/use.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!` or `::`, found `a`
--> $DIR/use.rs:1:6
|
LL | usee a::b;
| ^ expected one of `!` or `::`
|
help: there is a keyword `use` with a similar name
|
LL | use a::b;
| ~~~
error: aborting due to 1 previous error

8
tests/ui/parser/misspelled-keywords/where-clause.rs Normal file
View File

@ -0,0 +1,8 @@
fn code<T>() -> u8
wheree
//~^ ERROR expected one of
T: Debug,
{
}
fn main() {}

15
tests/ui/parser/misspelled-keywords/where-clause.stderr Normal file
View File

@ -0,0 +1,15 @@
error: expected one of `!`, `(`, `+`, `::`, `<`, `where`, or `{`, found `wheree`
--> $DIR/where-clause.rs:2:1
|
LL | fn code<T>() -> u8
| - expected one of 7 possible tokens
LL | wheree
| ^^^^^^ unexpected token
|
help: there is a keyword `where` with a similar name
|
LL | where
|
error: aborting due to 1 previous error

5
tests/ui/parser/misspelled-keywords/while-loop.rs Normal file
View File

@ -0,0 +1,5 @@
fn main() {
whilee a < b {
//~^ ERROR expected one of
}
}

13
tests/ui/parser/misspelled-keywords/while-loop.stderr Normal file
View File

@ -0,0 +1,13 @@
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `a`
--> $DIR/while-loop.rs:2:12
|
LL | whilee a < b {
| ^ expected one of 8 possible tokens
|
help: there is a keyword `while` with a similar name
|
LL | while a < b {
| ~~~~~
error: aborting due to 1 previous error

4
tests/ui/parser/misspelled-keywords/while-without-identifiers.rs Normal file
View File

@ -0,0 +1,4 @@
fn main() {
whilee 2 > 1 {}
//~^ ERROR expected one of
}

8
tests/ui/parser/misspelled-keywords/while-without-identifiers.stderr Normal file
View File

@ -0,0 +1,8 @@
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `2`
--> $DIR/while-without-identifiers.rs:2:12
|
LL | whilee 2 > 1 {}
| ^ expected one of 8 possible tokens
error: aborting due to 1 previous error