nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 23:04:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #108586 - matthiaskrgr:rollup-ry9u2ou, r=matthiaskrgr

Browse Source 
Rollup of 8 pull requests

Successful merges:

 - #108297 (Exit when there are unmatched delims to avoid noisy diagnostics)
 - #108531 (rustdoc: Show that repeated expression arrays can be made with constant values)
 - #108536 (Update books)
 - #108550 (Remove the `capture_disjoint_fields` feature)
 - #108551 (Descriptive error when users try to combine RPITIT/AFIT with specialization)
 - #108554 (Only look for param in item's generics if it actually comes from generics)
 - #108555 (Fix a race in the query system)
 - #108558 (add missing feature in core/tests)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2023-03-01 03:11:44 +00:00
commit 5983a3a99e
134 changed files with 560 additions and 1739 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
compiler/rustc_ast_lowering/src/item.rs
View File

@ -1339,13 +1339,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
.map(|predicate| self.lower_where_predicate(predicate)),
);
let mut params: SmallVec<[hir::GenericParam<'hir>; 4]> =
self.lower_generic_params_mut(&generics.params).collect();
let mut params: SmallVec<[hir::GenericParam<'hir>; 4]> = self
.lower_generic_params_mut(&generics.params, hir::GenericParamSource::Generics)
.collect();
// Introduce extra lifetimes if late resolution tells us to.
let extra_lifetimes = self.resolver.take_extra_lifetime_params(parent_node_id);
params.extend(extra_lifetimes.into_iter().filter_map(|(ident, node_id, res)| {
self.lifetime_res_to_generic_param(ident, node_id, res)
self.lifetime_res_to_generic_param(
ident,
node_id,
res,
hir::GenericParamSource::Generics,
)
}));
let has_where_clause_predicates = !generics.where_clause.predicates.is_empty();
@ -1449,7 +1455,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
span,
}) => hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
hir_id: self.next_id(),
bound_generic_params: self.lower_generic_params(bound_generic_params),
bound_generic_params: self
.lower_generic_params(bound_generic_params, hir::GenericParamSource::Binder),
bounded_ty: self
.lower_ty(bounded_ty, &ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
bounds: self.arena.alloc_from_iter(bounds.iter().map(|bound| {

39
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -804,6 +804,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
ident: Ident,
node_id: NodeId,
res: LifetimeRes,
source: hir::GenericParamSource,
) -> Option<hir::GenericParam<'hir>> {
let (name, kind) = match res {
LifetimeRes::Param { .. } => {
@ -837,6 +838,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
pure_wrt_drop: false,
kind: hir::GenericParamKind::Lifetime { kind },
colon_span: None,
source,
})
}
@ -852,11 +854,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
binder: NodeId,
generic_params: &[GenericParam],
) -> &'hir [hir::GenericParam<'hir>] {
let mut generic_params: Vec<_> = self.lower_generic_params_mut(generic_params).collect();
let mut generic_params: Vec<_> = self
.lower_generic_params_mut(generic_params, hir::GenericParamSource::Binder)
.collect();
let extra_lifetimes = self.resolver.take_extra_lifetime_params(binder);
debug!(?extra_lifetimes);
generic_params.extend(extra_lifetimes.into_iter().filter_map(|(ident, node_id, res)| {
self.lifetime_res_to_generic_param(ident, node_id, res)
self.lifetime_res_to_generic_param(ident, node_id, res, hir::GenericParamSource::Binder)
}));
let generic_params = self.arena.alloc_from_iter(generic_params);
debug!(?generic_params);
@ -1375,8 +1379,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
span,
);
let ident = Ident::from_str_and_span(&pprust::ty_to_string(t), span);
let (param, bounds, path) =
self.lower_generic_and_bounds(*def_node_id, span, ident, bounds);
let (param, bounds, path) = self.lower_universal_param_and_bounds(
*def_node_id,
span,
ident,
bounds,
);
self.impl_trait_defs.push(param);
if let Some(bounds) = bounds {
self.impl_trait_bounds.push(bounds);
@ -1530,6 +1538,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
pure_wrt_drop: false,
kind: hir::GenericParamKind::Lifetime { kind },
colon_span: None,
source: hir::GenericParamSource::Generics,
}
},
));
@ -1987,6 +1996,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
pure_wrt_drop: false,
kind: hir::GenericParamKind::Lifetime { kind },
colon_span: None,
source: hir::GenericParamSource::Generics,
}
},
));
@ -2152,16 +2162,25 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_generic_params_mut<'s>(
&'s mut self,
params: &'s [GenericParam],
source: hir::GenericParamSource,
) -> impl Iterator<Item = hir::GenericParam<'hir>> + Captures<'a> + Captures<'s> {
params.iter().map(move |param| self.lower_generic_param(param))
params.iter().map(move |param| self.lower_generic_param(param, source))
}
fn lower_generic_params(&mut self, params: &[GenericParam]) -> &'hir [hir::GenericParam<'hir>] {
self.arena.alloc_from_iter(self.lower_generic_params_mut(params))
fn lower_generic_params(
&mut self,
params: &[GenericParam],
source: hir::GenericParamSource,
) -> &'hir [hir::GenericParam<'hir>] {
self.arena.alloc_from_iter(self.lower_generic_params_mut(params, source))
}
#[instrument(level = "trace", skip(self))]
fn lower_generic_param(&mut self, param: &GenericParam) -> hir::GenericParam<'hir> {
fn lower_generic_param(
&mut self,
param: &GenericParam,
source: hir::GenericParamSource,
) -> hir::GenericParam<'hir> {
let (name, kind) = self.lower_generic_param_kind(param);
let hir_id = self.lower_node_id(param.id);
@ -2174,6 +2193,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
pure_wrt_drop: self.tcx.sess.contains_name(&param.attrs, sym::may_dangle),
kind,
colon_span: param.colon_span.map(|s| self.lower_span(s)),
source,
}
}
@ -2266,7 +2286,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
#[instrument(level = "debug", skip(self), ret)]
fn lower_generic_and_bounds(
fn lower_universal_param_and_bounds(
&mut self,
node_id: NodeId,
span: Span,
@ -2286,6 +2306,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
span,
kind: hir::GenericParamKind::Type { default: None, synthetic: true },
colon_span: None,
source: hir::GenericParamSource::Generics,
};
let preds = self.lower_generic_bound_predicate(

1
compiler/rustc_expand/src/tests.rs
View File

@ -43,7 +43,6 @@ pub(crate) fn string_to_stream(source_str: String) -> TokenStream {
ps.source_map().new_source_file(PathBuf::from("bogofile").into(), source_str),
None,
)
.0
}
/// Parses a string, returns a crate.

2
compiler/rustc_feature/src/active.rs
View File

@ -316,8 +316,6 @@ declare_features! (
(active, c_unwind, "1.52.0", Some(74990), None),
/// Allows using C-variadics.
(active, c_variadic, "1.34.0", Some(44930), None),
/// Allows capturing disjoint fields in a closure/generator (RFC 2229).
(incomplete, capture_disjoint_fields, "1.49.0", Some(53488), None),
/// Allows the use of `#[cfg(sanitize = "option")]`; set when -Zsanitizer is used.
(active, cfg_sanitize, "1.41.0", Some(39699), None),
/// Allows `cfg(target_abi = "...")`.

2
compiler/rustc_feature/src/removed.rs
View File

@ -52,6 +52,8 @@ declare_features! (
(removed, allow_fail, "1.19.0", Some(46488), None, Some("removed due to no clear use cases")),
(removed, await_macro, "1.38.0", Some(50547), None,
Some("subsumed by `.await` syntax")),
/// Allows capturing disjoint fields in a closure/generator (RFC 2229).
(removed, capture_disjoint_fields, "1.49.0", Some(53488), None, Some("stabilized in Rust 2021")),
/// Allows comparing raw pointers during const eval.
(removed, const_compare_raw_pointers, "1.46.0", Some(53020), None,
Some("cannot be allowed in const eval in any meaningful way")),

15
compiler/rustc_hir/src/hir.rs
View File

@ -498,6 +498,7 @@ pub struct GenericParam<'hir> {
pub pure_wrt_drop: bool,
pub kind: GenericParamKind<'hir>,
pub colon_span: Option<Span>,
pub source: GenericParamSource,
}
impl<'hir> GenericParam<'hir> {
@ -516,6 +517,20 @@ impl<'hir> GenericParam<'hir> {
}
}
/// Records where the generic parameter originated from.
///
/// This can either be from an item's generics, in which case it's typically
/// early-bound (but can be a late-bound lifetime in functions, for example),
/// or from a `for<...>` binder, in which case it's late-bound (and notably,
/// does not show up in the parent item's generics).
#[derive(Debug, HashStable_Generic, PartialEq, Eq, Copy, Clone)]
pub enum GenericParamSource {
// Early or late-bound parameters defined on an item
Generics,
// Late-bound parameters defined via a `for<...>`
Binder,
}
#[derive(Default)]
pub struct GenericParamCount {
pub lifetimes: usize,

40
compiler/rustc_hir_analysis/src/check/check.rs
View File

@ -792,8 +792,10 @@ fn check_impl_items_against_trait<'tcx>(
trait_def.must_implement_one_of.as_deref();
for &trait_item_id in tcx.associated_item_def_ids(impl_trait_ref.def_id) {
let is_implemented = ancestors
.leaf_def(tcx, trait_item_id)
let leaf_def = ancestors.leaf_def(tcx, trait_item_id);
let is_implemented = leaf_def
.as_ref()
.map_or(false, |node_item| node_item.item.defaultness(tcx).has_value());
if !is_implemented && tcx.impl_defaultness(impl_id).is_final() {
@ -801,8 +803,8 @@ fn check_impl_items_against_trait<'tcx>(
}
// true if this item is specifically implemented in this impl
let is_implemented_here = ancestors
.leaf_def(tcx, trait_item_id)
let is_implemented_here = leaf_def
.as_ref()
.map_or(false, |node_item| !node_item.defining_node.is_from_trait());
if !is_implemented_here {
@ -831,6 +833,36 @@ fn check_impl_items_against_trait<'tcx>(
}
}
}
if let Some(leaf_def) = &leaf_def
&& !leaf_def.is_final()
&& let def_id = leaf_def.item.def_id
&& tcx.impl_method_has_trait_impl_trait_tys(def_id)
{
let def_kind = tcx.def_kind(def_id);
let descr = tcx.def_kind_descr(def_kind, def_id);
let (msg, feature) = if tcx.asyncness(def_id).is_async() {
(
format!("async {descr} in trait cannot be specialized"),
sym::async_fn_in_trait,
)
} else {
(
format!(
"{descr} with return-position `impl Trait` in trait cannot be specialized"
),
sym::return_position_impl_trait_in_trait,
)
};
tcx.sess
.struct_span_err(tcx.def_span(def_id), msg)
.note(format!(
"specialization behaves in inconsistent and \
surprising ways with `#![feature({feature})]`, \
and for now is disallowed"
))
.emit();
}
}
if !missing_items.is_empty() {

77
compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
View File

@ -1034,45 +1034,53 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
fn object_lifetime_default(tcx: TyCtxt<'_>, param_def_id: DefId) -> ObjectLifetimeDefault {
debug_assert_eq!(tcx.def_kind(param_def_id), DefKind::TyParam);
let param_def_id = param_def_id.expect_local();
let parent_def_id = tcx.local_parent(param_def_id);
let generics = tcx.hir().get_generics(parent_def_id).unwrap();
let param_hir_id = tcx.local_def_id_to_hir_id(param_def_id);
let param = generics.params.iter().find(|p| p.hir_id == param_hir_id).unwrap();
let hir::Node::GenericParam(param) = tcx.hir().get_by_def_id(param_def_id) else {
bug!("expected GenericParam for object_lifetime_default");
};
match param.source {
hir::GenericParamSource::Generics => {
let parent_def_id = tcx.local_parent(param_def_id);
let generics = tcx.hir().get_generics(parent_def_id).unwrap();
let param_hir_id = tcx.local_def_id_to_hir_id(param_def_id);
let param = generics.params.iter().find(|p| p.hir_id == param_hir_id).unwrap();
// Scan the bounds and where-clauses on parameters to extract bounds
// of the form `T:'a` so as to determine the `ObjectLifetimeDefault`
// for each type parameter.
match param.kind {
GenericParamKind::Type { .. } => {
let mut set = Set1::Empty;
// Scan the bounds and where-clauses on parameters to extract bounds
// of the form `T:'a` so as to determine the `ObjectLifetimeDefault`
// for each type parameter.
match param.kind {
GenericParamKind::Type { .. } => {
let mut set = Set1::Empty;
// Look for `type: ...` where clauses.
for bound in generics.bounds_for_param(param_def_id) {
// Ignore `for<'a> type: ...` as they can change what
// lifetimes mean (although we could "just" handle it).
if !bound.bound_generic_params.is_empty() {
continue;
}
// Look for `type: ...` where clauses.
for bound in generics.bounds_for_param(param_def_id) {
// Ignore `for<'a> type: ...` as they can change what
// lifetimes mean (although we could "just" handle it).
if !bound.bound_generic_params.is_empty() {
continue;
}
for bound in bound.bounds {
if let hir::GenericBound::Outlives(lifetime) = bound {
set.insert(lifetime.res);
for bound in bound.bounds {
if let hir::GenericBound::Outlives(lifetime) = bound {
set.insert(lifetime.res);
}
}
}
match set {
Set1::Empty => ObjectLifetimeDefault::Empty,
Set1::One(hir::LifetimeName::Static) => ObjectLifetimeDefault::Static,
Set1::One(hir::LifetimeName::Param(param_def_id)) => {
ObjectLifetimeDefault::Param(param_def_id.to_def_id())
}
_ => ObjectLifetimeDefault::Ambiguous,
}
}
}
match set {
Set1::Empty => ObjectLifetimeDefault::Empty,
Set1::One(hir::LifetimeName::Static) => ObjectLifetimeDefault::Static,
Set1::One(hir::LifetimeName::Param(param_def_id)) => {
ObjectLifetimeDefault::Param(param_def_id.to_def_id())
_ => {
bug!("object_lifetime_default_raw must only be called on a type parameter")
}
_ => ObjectLifetimeDefault::Ambiguous,
}
}
_ => {
bug!("object_lifetime_default_raw must only be called on a type parameter")
}
hir::GenericParamSource::Binder => ObjectLifetimeDefault::Empty,
}
}
@ -1392,9 +1400,10 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
return;
}
self.tcx
.sess
.delay_span_bug(self.tcx.hir().span(hir_id), "could not resolve {param_def_id:?}");
self.tcx.sess.delay_span_bug(
self.tcx.hir().span(hir_id),
format!("could not resolve {param_def_id:?}"),
);
}
#[instrument(level = "debug", skip(self))]

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

@ -231,7 +231,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// We now fake capture information for all variables that are mentioned within the closure
// We do this after handling migrations so that min_captures computes before
if !enable_precise_capture(self.tcx, span) {
if !enable_precise_capture(span) {
let mut capture_information: InferredCaptureInformation<'tcx> = Default::default();
if let Some(upvars) = self.tcx.upvars_mentioned(closure_def_id) {
@ -265,7 +265,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// If we have an origin, store it.
if let Some(origin) = origin {
let origin = if enable_precise_capture(self.tcx, span) {
let origin = if enable_precise_capture(span) {
(origin.0, origin.1)
} else {
(origin.0, Place { projections: vec![], ..origin.1 })
@ -1243,8 +1243,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
///
/// This will make more sense with an example:
///
/// ```rust
/// #![feature(capture_disjoint_fields)]
/// ```rust,edition2021
///
/// struct FancyInteger(i32); // This implements Drop
///
@ -2250,12 +2249,10 @@ fn truncate_capture_for_optimization(
(place, curr_mode)
}
/// Precise capture is enabled if the feature gate `capture_disjoint_fields` is enabled or if
/// user is using Rust Edition 2021 or higher.
///
/// Precise capture is enabled if user is using Rust Edition 2021 or higher.
/// `span` is the span of the closure.
fn enable_precise_capture(tcx: TyCtxt<'_>, span: Span) -> bool {
fn enable_precise_capture(span: Span) -> bool {
// We use span here to ensure that if the closure was generated by a macro with a different
// edition.
tcx.features().capture_disjoint_fields || span.rust_2021()
span.rust_2021()
}

30
compiler/rustc_metadata/src/rmeta/encoder.rs
View File

@ -1101,34 +1101,6 @@ fn should_encode_const(def_kind: DefKind) -> bool {
}
}
fn should_encode_trait_impl_trait_tys(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
if tcx.def_kind(def_id) != DefKind::AssocFn {
return false;
}
let Some(item) = tcx.opt_associated_item(def_id) else { return false; };
if item.container != ty::AssocItemContainer::ImplContainer {
return false;
}
let Some(trait_item_def_id) = item.trait_item_def_id else { return false; };
// FIXME(RPITIT): This does a somewhat manual walk through the signature
// of the trait fn to look for any RPITITs, but that's kinda doing a lot
// of work. We can probably remove this when we refactor RPITITs to be
// associated types.
tcx.fn_sig(trait_item_def_id).subst_identity().skip_binder().output().walk().any(|arg| {
if let ty::GenericArgKind::Type(ty) = arg.unpack()
&& let ty::Alias(ty::Projection, data) = ty.kind()
&& tcx.def_kind(data.def_id) == DefKind::ImplTraitPlaceholder
{
true
} else {
false
}
})
}
// Return `false` to avoid encoding impl trait in trait, while we don't use the query.
fn should_encode_fn_impl_trait_in_trait<'tcx>(_tcx: TyCtxt<'tcx>, _def_id: DefId) -> bool {
false
@ -1211,7 +1183,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
if let DefKind::Enum | DefKind::Struct | DefKind::Union = def_kind {
self.encode_info_for_adt(def_id);
}
if should_encode_trait_impl_trait_tys(tcx, def_id)
if tcx.impl_method_has_trait_impl_trait_tys(def_id)
&& let Ok(table) = self.tcx.collect_return_position_impl_trait_in_trait_tys(def_id)
{
record!(self.tables.trait_impl_trait_tys[def_id] <- table);

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

@ -2541,6 +2541,34 @@ impl<'tcx> TyCtxt<'tcx> {
}
def_id
}
pub fn impl_method_has_trait_impl_trait_tys(self, def_id: DefId) -> bool {
if self.def_kind(def_id) != DefKind::AssocFn {
return false;
}
let Some(item) = self.opt_associated_item(def_id) else { return false; };
if item.container != ty::AssocItemContainer::ImplContainer {
return false;
}
let Some(trait_item_def_id) = item.trait_item_def_id else { return false; };
// FIXME(RPITIT): This does a somewhat manual walk through the signature
// of the trait fn to look for any RPITITs, but that's kinda doing a lot
// of work. We can probably remove this when we refactor RPITITs to be
// associated types.
self.fn_sig(trait_item_def_id).subst_identity().skip_binder().output().walk().any(|arg| {
if let ty::GenericArgKind::Type(ty) = arg.unpack()
&& let ty::Alias(ty::Projection, data) = ty.kind()
&& self.def_kind(data.def_id) == DefKind::ImplTraitPlaceholder
{
true
} else {
false
}
})
}
}
/// Yields the parent function's `LocalDefId` if `def_id` is an `impl Trait` definition.

11
compiler/rustc_mir_build/src/build/expr/as_place.rs
View File

@ -11,7 +11,7 @@ use rustc_middle::mir::AssertKind::BoundsCheck;
use rustc_middle::mir::*;
use rustc_middle::thir::*;
use rustc_middle::ty::AdtDef;
use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, TyCtxt, Variance};
use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, Variance};
use rustc_span::Span;
use rustc_target::abi::VariantIdx;
@ -183,7 +183,7 @@ fn to_upvars_resolved_place_builder<'tcx>(
&projection,
) else {
let closure_span = cx.tcx.def_span(closure_def_id);
if !enable_precise_capture(cx.tcx, closure_span) {
if !enable_precise_capture(closure_span) {
bug!(
"No associated capture found for {:?}[{:#?}] even though \
capture_disjoint_fields isn't enabled",
@ -745,8 +745,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
}
}
/// Precise capture is enabled if the feature gate `capture_disjoint_fields` is enabled or if
/// user is using Rust Edition 2021 or higher.
fn enable_precise_capture(tcx: TyCtxt<'_>, closure_span: Span) -> bool {
tcx.features().capture_disjoint_fields || closure_span.rust_2021()
/// Precise capture is enabled if user is using Rust Edition 2021 or higher.
fn enable_precise_capture(closure_span: Span) -> bool {
closure_span.rust_2021()
}

10
compiler/rustc_parse/src/lexer/diagnostics.rs
View File

@ -1,4 +1,4 @@
use super::UnmatchedBrace;
use super::UnmatchedDelim;
use rustc_ast::token::Delimiter;
use rustc_errors::Diagnostic;
use rustc_span::source_map::SourceMap;
@ -8,7 +8,7 @@ use rustc_span::Span;
pub struct TokenTreeDiagInfo {
/// Stack of open delimiters and their spans. Used for error message.
pub open_braces: Vec<(Delimiter, Span)>,
pub unmatched_braces: Vec<UnmatchedBrace>,
pub unmatched_delims: Vec<UnmatchedDelim>,
/// Used only for error recovery when arriving to EOF with mismatched braces.
pub last_unclosed_found_span: Option<Span>,
@ -32,10 +32,10 @@ pub fn same_identation_level(sm: &SourceMap, open_sp: Span, close_sp: Span) -> b
// it's more friendly compared to report `unmatched error` in later phase
pub fn report_missing_open_delim(
err: &mut Diagnostic,
unmatched_braces: &[UnmatchedBrace],
unmatched_delims: &[UnmatchedDelim],
) -> bool {
let mut reported_missing_open = false;
for unmatch_brace in unmatched_braces.iter() {
for unmatch_brace in unmatched_delims.iter() {
if let Some(delim) = unmatch_brace.found_delim
&& matches!(delim, Delimiter::Parenthesis | Delimiter::Bracket)
{
@ -60,7 +60,7 @@ pub fn report_suspicious_mismatch_block(
sm: &SourceMap,
delim: Delimiter,
) {
if report_missing_open_delim(err, &diag_info.unmatched_braces) {
if report_missing_open_delim(err, &diag_info.unmatched_delims) {
return;
}

31
compiler/rustc_parse/src/lexer/mod.rs
View File

@ -1,10 +1,11 @@
use crate::errors;
use crate::lexer::unicode_chars::UNICODE_ARRAY;
use crate::make_unclosed_delims_error;
use rustc_ast::ast::{self, AttrStyle};
use rustc_ast::token::{self, CommentKind, Delimiter, Token, TokenKind};
use rustc_ast::tokenstream::TokenStream;
use rustc_ast::util::unicode::contains_text_flow_control_chars;
use rustc_errors::{error_code, Applicability, DiagnosticBuilder, PResult, StashKey};
use rustc_errors::{error_code, Applicability, Diagnostic, DiagnosticBuilder, StashKey};
use rustc_lexer::unescape::{self, Mode};
use rustc_lexer::Cursor;
use rustc_lexer::{Base, DocStyle, RawStrError};
@ -31,7 +32,7 @@ use unescape_error_reporting::{emit_unescape_error, escaped_char};
rustc_data_structures::static_assert_size!(rustc_lexer::Token, 12);
#[derive(Clone, Debug)]
pub struct UnmatchedBrace {
pub struct UnmatchedDelim {
pub expected_delim: Delimiter,
pub found_delim: Option<Delimiter>,
pub found_span: Span,
@ -44,7 +45,7 @@ pub(crate) fn parse_token_trees<'a>(
mut src: &'a str,
mut start_pos: BytePos,
override_span: Option<Span>,
) -> (PResult<'a, TokenStream>, Vec<UnmatchedBrace>) {
) -> Result<TokenStream, Vec<Diagnostic>> {
// Skip `#!`, if present.
if let Some(shebang_len) = rustc_lexer::strip_shebang(src) {
src = &src[shebang_len..];
@ -61,7 +62,29 @@ pub(crate) fn parse_token_trees<'a>(
override_span,
nbsp_is_whitespace: false,
};
tokentrees::TokenTreesReader::parse_all_token_trees(string_reader)
let (token_trees, unmatched_delims) =
tokentrees::TokenTreesReader::parse_all_token_trees(string_reader);
match token_trees {
Ok(stream) if unmatched_delims.is_empty() => Ok(stream),
_ => {
// Return error if there are unmatched delimiters or unclosng delimiters.
// We emit delimiter mismatch errors first, then emit the unclosing delimiter mismatch
// because the delimiter mismatch is more likely to be the root cause of error
let mut buffer = Vec::with_capacity(1);
// Not using `emit_unclosed_delims` to use `db.buffer`
for unmatched in unmatched_delims {
if let Some(err) = make_unclosed_delims_error(unmatched, &sess) {
err.buffer(&mut buffer);
}
}
if let Err(err) = token_trees {
// Add unclosing delimiter error
err.buffer(&mut buffer);
}
Err(buffer)
}
}
}
struct StringReader<'a> {

27
compiler/rustc_parse/src/lexer/tokentrees.rs
View File

@ -1,7 +1,7 @@
use super::diagnostics::report_suspicious_mismatch_block;
use super::diagnostics::same_identation_level;
use super::diagnostics::TokenTreeDiagInfo;
use super::{StringReader, UnmatchedBrace};
use super::{StringReader, UnmatchedDelim};
use rustc_ast::token::{self, Delimiter, Token};
use rustc_ast::tokenstream::{DelimSpan, Spacing, TokenStream, TokenTree};
use rustc_ast_pretty::pprust::token_to_string;
@ -18,14 +18,14 @@ pub(super) struct TokenTreesReader<'a> {
impl<'a> TokenTreesReader<'a> {
pub(super) fn parse_all_token_trees(
string_reader: StringReader<'a>,
) -> (PResult<'a, TokenStream>, Vec<UnmatchedBrace>) {
) -> (PResult<'a, TokenStream>, Vec<UnmatchedDelim>) {
let mut tt_reader = TokenTreesReader {
string_reader,
token: Token::dummy(),
diag_info: TokenTreeDiagInfo::default(),
};
let res = tt_reader.parse_token_trees(/* is_delimited */ false);
(res, tt_reader.diag_info.unmatched_braces)
(res, tt_reader.diag_info.unmatched_delims)
}
// Parse a stream of tokens into a list of `TokenTree`s.
@ -34,7 +34,7 @@ impl<'a> TokenTreesReader<'a> {
let mut buf = Vec::new();
loop {
match self.token.kind {
token::OpenDelim(delim) => buf.push(self.parse_token_tree_open_delim(delim)),
token::OpenDelim(delim) => buf.push(self.parse_token_tree_open_delim(delim)?),
token::CloseDelim(delim) => {
return if is_delimited {
Ok(TokenStream::new(buf))
@ -43,10 +43,11 @@ impl<'a> TokenTreesReader<'a> {
};
}
token::Eof => {
if is_delimited {
self.eof_err().emit();
}
return Ok(TokenStream::new(buf));
return if is_delimited {
Err(self.eof_err())
} else {
Ok(TokenStream::new(buf))
};
}
_ => {
// Get the next normal token. This might require getting multiple adjacent
@ -78,7 +79,7 @@ impl<'a> TokenTreesReader<'a> {
let mut err = self.string_reader.sess.span_diagnostic.struct_span_err(self.token.span, msg);
for &(_, sp) in &self.diag_info.open_braces {
err.span_label(sp, "unclosed delimiter");
self.diag_info.unmatched_braces.push(UnmatchedBrace {
self.diag_info.unmatched_delims.push(UnmatchedDelim {
expected_delim: Delimiter::Brace,
found_delim: None,
found_span: self.token.span,
@ -98,7 +99,7 @@ impl<'a> TokenTreesReader<'a> {
err
}
fn parse_token_tree_open_delim(&mut self, open_delim: Delimiter) -> TokenTree {
fn parse_token_tree_open_delim(&mut self, open_delim: Delimiter) -> PResult<'a, TokenTree> {
// The span for beginning of the delimited section
let pre_span = self.token.span;
@ -107,7 +108,7 @@ impl<'a> TokenTreesReader<'a> {
// Parse the token trees within the delimiters.
// We stop at any delimiter so we can try to recover if the user
// uses an incorrect delimiter.
let tts = self.parse_token_trees(/* is_delimited */ true).unwrap();
let tts = self.parse_token_trees(/* is_delimited */ true)?;
// Expand to cover the entire delimited token tree
let delim_span = DelimSpan::from_pair(pre_span, self.token.span);
@ -160,7 +161,7 @@ impl<'a> TokenTreesReader<'a> {
}
}
let (tok, _) = self.diag_info.open_braces.pop().unwrap();
self.diag_info.unmatched_braces.push(UnmatchedBrace {
self.diag_info.unmatched_delims.push(UnmatchedDelim {
expected_delim: tok,
found_delim: Some(close_delim),
found_span: self.token.span,
@ -190,7 +191,7 @@ impl<'a> TokenTreesReader<'a> {
_ => unreachable!(),
}
TokenTree::Delimited(delim_span, open_delim, tts)
Ok(TokenTree::Delimited(delim_span, open_delim, tts))
}
fn close_delim_err(&mut self, delim: Delimiter) -> PErr<'a> {

32
compiler/rustc_parse/src/lib.rs
View File

@ -30,7 +30,7 @@ pub const MACRO_ARGUMENTS: Option<&str> = Some("macro arguments");
#[macro_use]
pub mod parser;
use parser::{emit_unclosed_delims, make_unclosed_delims_error, Parser};
use parser::{make_unclosed_delims_error, Parser};
pub mod lexer;
pub mod validate_attr;
@ -96,10 +96,7 @@ pub fn parse_stream_from_source_str(
sess: &ParseSess,
override_span: Option<Span>,
) -> TokenStream {
let (stream, mut errors) =
source_file_to_stream(sess, sess.source_map().new_source_file(name, source), override_span);
emit_unclosed_delims(&mut errors, &sess);
stream
source_file_to_stream(sess, sess.source_map().new_source_file(name, source), override_span)
}
/// Creates a new parser from a source string.
@ -135,9 +132,8 @@ fn maybe_source_file_to_parser(
source_file: Lrc<SourceFile>,
) -> Result<Parser<'_>, Vec<Diagnostic>> {
let end_pos = source_file.end_pos;
let (stream, unclosed_delims) = maybe_file_to_stream(sess, source_file, None)?;
let stream = maybe_file_to_stream(sess, source_file, None)?;
let mut parser = stream_to_parser(sess, stream, None);
parser.unclosed_delims = unclosed_delims;
if parser.token == token::Eof {
parser.token.span = Span::new(end_pos, end_pos, parser.token.span.ctxt(), None);
}
@ -182,7 +178,7 @@ pub fn source_file_to_stream(
sess: &ParseSess,
source_file: Lrc<SourceFile>,
override_span: Option<Span>,
) -> (TokenStream, Vec<lexer::UnmatchedBrace>) {
) -> TokenStream {
panictry_buffer!(&sess.span_diagnostic, maybe_file_to_stream(sess, source_file, override_span))
}
@ -192,7 +188,7 @@ pub fn maybe_file_to_stream(
sess: &ParseSess,
source_file: Lrc<SourceFile>,
override_span: Option<Span>,
) -> Result<(TokenStream, Vec<lexer::UnmatchedBrace>), Vec<Diagnostic>> {
) -> Result<TokenStream, Vec<Diagnostic>> {
let src = source_file.src.as_ref().unwrap_or_else(|| {
sess.span_diagnostic.bug(&format!(
"cannot lex `source_file` without source: {}",
@ -200,23 +196,7 @@ pub fn maybe_file_to_stream(
));
});
let (token_trees, unmatched_braces) =
lexer::parse_token_trees(sess, src.as_str(), source_file.start_pos, override_span);
match token_trees {
Ok(stream) => Ok((stream, unmatched_braces)),
Err(err) => {
let mut buffer = Vec::with_capacity(1);
err.buffer(&mut buffer);
// Not using `emit_unclosed_delims` to use `db.buffer`
for unmatched in unmatched_braces {
if let Some(err) = make_unclosed_delims_error(unmatched, &sess) {
err.buffer(&mut buffer);
}
}
Err(buffer)
}
}
lexer::parse_token_trees(sess, src.as_str(), source_file.start_pos, override_span)
}
/// Given a stream and the `ParseSess`, produces a parser.

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

@ -19,7 +19,7 @@ use crate::errors::{
};
use crate::fluent_generated as fluent;
use crate::lexer::UnmatchedBrace;
use crate::lexer::UnmatchedDelim;
use crate::parser;
use rustc_ast as ast;
use rustc_ast::ptr::P;
@ -222,7 +222,7 @@ impl MultiSugg {
/// is dropped.
pub struct SnapshotParser<'a> {
parser: Parser<'a>,
unclosed_delims: Vec<UnmatchedBrace>,
unclosed_delims: Vec<UnmatchedDelim>,
}
impl<'a> Deref for SnapshotParser<'a> {
@ -264,7 +264,7 @@ impl<'a> Parser<'a> {
self.unclosed_delims.extend(snapshot.unclosed_delims);
}
pub fn unclosed_delims(&self) -> &[UnmatchedBrace] {
pub fn unclosed_delims(&self) -> &[UnmatchedDelim] {
&self.unclosed_delims
}

10
compiler/rustc_parse/src/parser/mod.rs
View File

@ -10,7 +10,7 @@ mod path;
mod stmt;
mod ty;
use crate::lexer::UnmatchedBrace;
use crate::lexer::UnmatchedDelim;
pub use attr_wrapper::AttrWrapper;
pub use diagnostics::AttemptLocalParseRecovery;
pub(crate) use item::FnParseMode;
@ -149,7 +149,7 @@ pub struct Parser<'a> {
/// A list of all unclosed delimiters found by the lexer. If an entry is used for error recovery
/// it gets removed from here. Every entry left at the end gets emitted as an independent
/// error.
pub(super) unclosed_delims: Vec<UnmatchedBrace>,
pub(super) unclosed_delims: Vec<UnmatchedDelim>,
last_unexpected_token_span: Option<Span>,
/// Span pointing at the `:` for the last type ascription the parser has seen, and whether it
/// looked like it could have been a mistyped path or literal `Option:Some(42)`).
@ -1521,11 +1521,11 @@ impl<'a> Parser<'a> {
}
pub(crate) fn make_unclosed_delims_error(
unmatched: UnmatchedBrace,
unmatched: UnmatchedDelim,
sess: &ParseSess,
) -> Option<DiagnosticBuilder<'_, ErrorGuaranteed>> {
// `None` here means an `Eof` was found. We already emit those errors elsewhere, we add them to
// `unmatched_braces` only for error recovery in the `Parser`.
// `unmatched_delims` only for error recovery in the `Parser`.
let found_delim = unmatched.found_delim?;
let mut spans = vec![unmatched.found_span];
if let Some(sp) = unmatched.unclosed_span {
@ -1542,7 +1542,7 @@ pub(crate) fn make_unclosed_delims_error(
Some(err)
}
pub fn emit_unclosed_delims(unclosed_delims: &mut Vec<UnmatchedBrace>, sess: &ParseSess) {
pub fn emit_unclosed_delims(unclosed_delims: &mut Vec<UnmatchedDelim>, sess: &ParseSess) {
*sess.reached_eof.borrow_mut() |=
unclosed_delims.iter().any(|unmatched_delim| unmatched_delim.found_delim.is_none());
for unmatched in unclosed_delims.drain(..) {

9
compiler/rustc_query_system/src/query/plumbing.rs
View File

@ -25,7 +25,6 @@ use std::collections::hash_map::Entry;
use std::fmt::Debug;
use std::hash::Hash;
use std::mem;
use std::ptr;
use thin_vec::ThinVec;
use super::QueryConfig;
@ -250,13 +249,16 @@ where
where
C: QueryCache<Key = K>,
{
// We can move out of `self` here because we `mem::forget` it below
let key = unsafe { ptr::read(&self.key) };
let key = self.key;
let state = self.state;
// Forget ourself so our destructor won't poison the query
mem::forget(self);
// Mark as complete before we remove the job from the active state
// so no other thread can re-execute this query.
cache.complete(key, result, dep_node_index);
let job = {
#[cfg(parallel_compiler)]
let mut lock = state.active.get_shard_by_value(&key).lock();
@ -267,7 +269,6 @@ where
QueryResult::Poisoned => panic!(),
}
};
cache.complete(key, result, dep_node_index);
job.signal_complete();
}

24
compiler/rustc_trait_selection/src/traits/project.rs
View File

@ -1307,25 +1307,8 @@ fn assemble_candidate_for_impl_trait_in_trait<'cx, 'tcx>(
let _ = selcx.infcx.commit_if_ok(|_| {
match selcx.select(&obligation.with(tcx, trait_predicate)) {
Ok(Some(super::ImplSource::UserDefined(data))) => {
let Ok(leaf_def) = specialization_graph::assoc_def(tcx, data.impl_def_id, trait_fn_def_id) else {
return Err(());
};
// Only reveal a specializable default if we're past type-checking
// and the obligation is monomorphic, otherwise passes such as
// transmute checking and polymorphic MIR optimizations could
// get a result which isn't correct for all monomorphizations.
if leaf_def.is_final()
|| (obligation.param_env.reveal() == Reveal::All
&& !selcx
.infcx
.resolve_vars_if_possible(obligation.predicate.trait_ref(tcx))
.still_further_specializable())
{
candidate_set.push_candidate(ProjectionCandidate::ImplTraitInTrait(data));
Ok(())
} else {
Err(())
}
candidate_set.push_candidate(ProjectionCandidate::ImplTraitInTrait(data));
Ok(())
}
Ok(None) => {
candidate_set.mark_ambiguous();
@ -2216,7 +2199,8 @@ fn confirm_impl_trait_in_trait_candidate<'tcx>(
Ok(assoc_ty) => assoc_ty,
Err(guar) => return Progress::error(tcx, guar),
};
if !leaf_def.item.defaultness(tcx).has_value() {
// We don't support specialization for RPITITs anyways... yet.
if !leaf_def.is_final() {
return Progress { term: tcx.ty_error_misc().into(), obligations };
}

6
library/core/src/primitive_docs.rs
View File

@ -587,8 +587,10 @@ mod prim_pointer {}
/// There are two syntactic forms for creating an array:
///
/// * A list with each element, i.e., `[x, y, z]`.
/// * A repeat expression `[x; N]`, which produces an array with `N` copies of `x`.
/// The type of `x` must be [`Copy`].
/// * A repeat expression `[expr; N]` where `N` is how many times to repeat `expr` in the array. `expr` must either be:
///
/// * A value of a type implementing the [`Copy`] trait
/// * A `const` value
///
/// Note that `[expr; 0]` is allowed, and produces an empty array.
/// This will still evaluate `expr`, however, and immediately drop the resulting value, so

1
library/core/tests/lib.rs
View File

@ -67,6 +67,7 @@
#![feature(slice_internals)]
#![feature(slice_partition_dedup)]
#![feature(ip)]
#![feature(ip_in_core)]
#![feature(iter_advance_by)]
#![feature(iter_array_chunks)]
#![feature(iter_collect_into)]

6
library/std/src/primitive_docs.rs
View File

@ -587,8 +587,10 @@ mod prim_pointer {}
/// There are two syntactic forms for creating an array:
///
/// * A list with each element, i.e., `[x, y, z]`.
/// * A repeat expression `[x; N]`, which produces an array with `N` copies of `x`.
/// The type of `x` must be [`Copy`].
/// * A repeat expression `[expr; N]` where `N` is how many times to repeat `expr` in the array. `expr` must either be:
///
/// * A value of a type implementing the [`Copy`] trait
/// * A `const` value
///
/// Note that `[expr; 0]` is allowed, and produces an empty array.
/// This will still evaluate `expr`, however, and immediately drop the resulting value, so

2
src/doc/book

@ -1 +1 @@
Subproject commit d94e03a18a2590ed3f1c67b859cb11528d2a2d5c
Subproject commit 21a2ed14f4480dab62438dcc1130291bebc65379

2
src/doc/reference

@ -1 +1 @@
Subproject commit e5adb99c04817b7fbe08f4ffce5b36702667345f
Subproject commit a9afb04b47a84a6753e4dc657348c324c876102c

2
src/doc/rust-by-example

@ -1 +1 @@
Subproject commit efe23c4fe12e06351b8dc8c3d18312c761455109
Subproject commit af0998b7473839ca75563ba3d3e7fd0160bef235

2
src/doc/rustc-dev-guide

@ -1 +1 @@
Subproject commit 41a96ab971cb45e2a184df20619ad1829765c990
Subproject commit b06dab84083390e0ee1e998f466545a8a1a76a9f

14
src/librustdoc/doctest.rs
View File

@ -769,8 +769,8 @@ fn check_if_attr_is_complete(source: &str, edition: Edition) -> bool {
match maybe_new_parser_from_source_str(&sess, filename, source.to_owned()) {
Ok(p) => p,
Err(_) => {
debug!("Cannot build a parser to check mod attr so skipping...");
return true;
// If there is an unclosed delimiter, an error will be returned by the tokentrees.
return false;
}
};
// If a parsing error happened, it's very likely that the attribute is incomplete.
@ -778,15 +778,7 @@ fn check_if_attr_is_complete(source: &str, edition: Edition) -> bool {
e.cancel();
return false;
}
// We now check if there is an unclosed delimiter for the attribute. To do so, we look at
// the `unclosed_delims` and see if the opening square bracket was closed.
parser
.unclosed_delims()
.get(0)
.map(|unclosed| {
unclosed.unclosed_span.map(|s| s.lo()).unwrap_or(BytePos(0)) != BytePos(2)
})
.unwrap_or(true)
true
})
})
.unwrap_or(false)

3
tests/debuginfo/captured-fields-1.rs
View File

@ -1,5 +1,5 @@
// compile-flags:-g
// edition:2021
// === GDB TESTS ===================================================================================
// gdb-command:run
@ -44,7 +44,6 @@
// lldbg-check:(captured_fields_1::main::{closure_env#5}) $5 = { my_var = { my_field1 = 11 my_field2 = 22 } }
// lldb-command:continue
#![feature(capture_disjoint_fields)]
#![allow(unused)]
struct MyStruct {

8
tests/debuginfo/captured-fields-2.rs
View File

@ -1,5 +1,5 @@
// compile-flags:-g
// edition:2021
// === GDB TESTS ===================================================================================
// gdb-command:run
@ -20,7 +20,6 @@
// lldbg-check:(unsigned int) $1 = 22
// lldb-command:continue
#![feature(capture_disjoint_fields)]
#![allow(unused)]
struct MyStruct {
@ -29,10 +28,7 @@ struct MyStruct {
}
fn main() {
let mut my_var = MyStruct {
my_field1: 11,
my_field2: 22,
};
let mut my_var = MyStruct { my_field1: 11, my_field2: 22 };
let my_ref = &mut my_var;
let test = || {

15
tests/ui/async-await/in-trait/dont-project-to-specializable-projection.stderr
View File

@ -7,20 +7,13 @@ LL | #![feature(async_fn_in_trait)]
= note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
= note: `#[warn(incomplete_features)]` on by default
error[E0053]: method `foo` has an incompatible type for trait
--> $DIR/dont-project-to-specializable-projection.rs:14:35
error: async associated function in trait cannot be specialized
--> $DIR/dont-project-to-specializable-projection.rs:14:5
|
LL | default async fn foo(_: T) -> &'static str {
| ^^^^^^^^^^^^ expected associated type, found future
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: type in trait
--> $DIR/dont-project-to-specializable-projection.rs:10:27
|
LL | async fn foo(_: T) -> &'static str;
| ^^^^^^^^^^^^
= note: expected signature `fn(_) -> impl Future<Output = &'static str>`
found signature `fn(_) -> impl Future<Output = &'static str>`
= note: specialization behaves in inconsistent and surprising ways with `#![feature(async_fn_in_trait)]`, and for now is disallowed
error: aborting due to previous error; 1 warning emitted
For more information about this error, try `rustc --explain E0053`.

5
tests/ui/closures/2229_closure_analysis/issue_88118.rs
View File

@ -1,10 +1,7 @@
// Regression test for #88118. Used to ICE.
//
// edition:2021
// check-pass
#![allow(incomplete_features)]
#![feature(capture_disjoint_fields)]
fn foo<MsU>(handler: impl FnOnce() -> MsU + Clone + 'static) {
Box::new(move |value| {
(|_| handler.clone()())(value);

1
tests/ui/impl-trait/in-trait/specialization-broken.rs
View File

@ -15,6 +15,7 @@ where
{
fn bar(&self) -> U {
//~^ ERROR method `bar` has an incompatible type for trait
//~| ERROR method with return-position `impl Trait` in trait cannot be specialized
*self
}
}

10
tests/ui/impl-trait/in-trait/specialization-broken.stderr
View File

@ -18,6 +18,14 @@ LL | fn bar(&self) -> impl Sized;
= note: expected signature `fn(&U) -> impl Sized`
found signature `fn(&U) -> U`
error: aborting due to previous error
error: method with return-position `impl Trait` in trait cannot be specialized
--> $DIR/specialization-broken.rs:16:5
|
LL | fn bar(&self) -> U {
| ^^^^^^^^^^^^^^^^^^
|
= note: specialization behaves in inconsistent and surprising ways with `#![feature(return_position_impl_trait_in_trait)]`, and for now is disallowed
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0053`.

1
tests/ui/lint/issue-104897.rs
View File

@ -1,6 +1,5 @@
// error-pattern: this file contains an unclosed delimiter
// error-pattern: this file contains an unclosed delimiter
// error-pattern: this file contains an unclosed delimiter
// error-pattern: format argument must be a string literal
fn f(){(print!(á

35
tests/ui/lint/issue-104897.stderr
View File

@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-104897.rs:6:18
--> $DIR/issue-104897.rs:5:18
|
LL | fn f(){(print!(á
| -- - ^
@ -8,36 +8,5 @@ LL | fn f(){(print!(á
| |unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-104897.rs:6:18
|
LL | fn f(){(print!(á
| -- - ^
| || |
| || unclosed delimiter
| |unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-104897.rs:6:18
|
LL | fn f(){(print!(á
| -- - ^
| || |
| || unclosed delimiter
| |unclosed delimiter
| unclosed delimiter
error: format argument must be a string literal
--> $DIR/issue-104897.rs:6:16
|
LL | fn f(){(print!(á
| ^
|
help: you might be missing a string literal to format with
|
LL | fn f(){(print!("{}", á
| +++++
error: aborting due to 4 previous errors
error: aborting due to previous error

1
tests/ui/lint/unused_parens_multibyte_recovery.rs
View File

@ -3,7 +3,6 @@
// error-pattern: this file contains an unclosed delimiter
// error-pattern: this file contains an unclosed delimiter
// error-pattern: this file contains an unclosed delimiter
// error-pattern: format argument must be a string literal
//
// Verify that unused parens lint does not try to create a span
// which points in the middle of a multibyte character.

35
tests/ui/lint/unused_parens_multibyte_recovery.stderr
View File

@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
--> $DIR/unused_parens_multibyte_recovery.rs:11:17
--> $DIR/unused_parens_multibyte_recovery.rs:10:17
|
LL | fn f(){(print!(á
| -- - ^
@ -8,36 +8,5 @@ LL | fn f(){(print!(á
| |unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/unused_parens_multibyte_recovery.rs:11:17
|
LL | fn f(){(print!(á
| -- - ^
| || |
| || unclosed delimiter
| |unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/unused_parens_multibyte_recovery.rs:11:17
|
LL | fn f(){(print!(á
| -- - ^
| || |
| || unclosed delimiter
| |unclosed delimiter
| unclosed delimiter
error: format argument must be a string literal
--> $DIR/unused_parens_multibyte_recovery.rs:11:16
|
LL | fn f(){(print!(á
| ^
|
help: you might be missing a string literal to format with
|
LL | fn f(){(print!("{}", á
| +++++
error: aborting due to 4 previous errors
error: aborting due to previous error

4
tests/ui/macros/issue-102878.rs
View File

@ -1,9 +1,5 @@
macro_rules!test{($l:expr,$_:r)=>({const:y y)}
//~^ ERROR mismatched closing delimiter: `)`
//~| ERROR invalid fragment specifier `r`
//~| ERROR expected identifier, found keyword `const`
//~| ERROR expected identifier, found keyword `const`
//~| ERROR expected identifier, found `:`
fn s(){test!(1,i)}

51
tests/ui/macros/issue-102878.stderr
View File

@ -7,54 +7,5 @@ LL | macro_rules!test{($l:expr,$_:r)=>({const:y y)}
| |unclosed delimiter
| closing delimiter possibly meant for this
error: invalid fragment specifier `r`
--> $DIR/issue-102878.rs:1:27
|
LL | macro_rules!test{($l:expr,$_:r)=>({const:y y)}
| ^^^^
|
= help: valid fragment specifiers are `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, `literal`, `path`, `meta`, `tt`, `item` and `vis`
error: expected identifier, found keyword `const`
--> $DIR/issue-102878.rs:1:36
|
LL | macro_rules!test{($l:expr,$_:r)=>({const:y y)}
| ^^^^^ expected identifier, found keyword
...
LL | fn s(){test!(1,i)}
| ---------- in this macro invocation
|
= note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
help: escape `const` to use it as an identifier
|
LL | macro_rules!test{($l:expr,$_:r)=>({r#const:y y)}
| ++
error: expected identifier, found keyword `const`
--> $DIR/issue-102878.rs:1:36
|
LL | macro_rules!test{($l:expr,$_:r)=>({const:y y)}
| ^^^^^ expected identifier, found keyword
...
LL | fn s(){test!(1,i)}
| ---------- in this macro invocation
|
= note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
help: escape `const` to use it as an identifier
|
LL | macro_rules!test{($l:expr,$_:r)=>({r#const:y y)}
| ++
error: expected identifier, found `:`
--> $DIR/issue-102878.rs:1:41
|
LL | macro_rules!test{($l:expr,$_:r)=>({const:y y)}
| ^ expected identifier
...
LL | fn s(){test!(1,i)}
| ---------- in this macro invocation
|
= note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 5 previous errors
error: aborting due to previous error

22
tests/ui/malformed/issue-107423-unused-delim-only-one-no-pair.stderr
View File

@ -8,25 +8,5 @@ LL | fn a(){{{
| |unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-107423-unused-delim-only-one-no-pair.rs:7:11
|
LL | fn a(){{{
| --- ^
| |||
| ||unclosed delimiter
| |unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-107423-unused-delim-only-one-no-pair.rs:7:11
|
LL | fn a(){{{
| --- ^
| |||
| ||unclosed delimiter
| |unclosed delimiter
| unclosed delimiter
error: aborting due to 3 previous errors
error: aborting due to previous error

2
tests/ui/parser/deli-ident-issue-1.rs
View File

@ -15,8 +15,6 @@ impl dyn Demo {
if let Some(b) = val
&& let Some(c) = num {
&& b == c {
//~^ ERROR expected struct
//~| ERROR mismatched types
}
}
}

24
tests/ui/parser/deli-ident-issue-1.stderr
View File

@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
--> $DIR/deli-ident-issue-1.rs:24:66
--> $DIR/deli-ident-issue-1.rs:22:66
|
LL | impl dyn Demo {
| - unclosed delimiter
@ -13,25 +13,5 @@ LL | }
LL | fn main() { }
| ^
error[E0574]: expected struct, variant or union type, found local variable `c`
--> $DIR/deli-ident-issue-1.rs:17:17
|
LL | && b == c {
| ^ not a struct, variant or union type
error: aborting due to previous error
error[E0308]: mismatched types
--> $DIR/deli-ident-issue-1.rs:17:9
|
LL | fn check(&self, val: Option<u32>, num: Option<u32>) {
| - expected `()` because of default return type
...
LL | / && b == c {
LL | |
LL | |
LL | | }
| |_________^ expected `()`, found `bool`
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0308, E0574.
For more information about an error, try `rustc --explain E0308`.

16
tests/ui/parser/deli-ident-issue-2.stderr
View File

@ -1,3 +1,11 @@
error: mismatched closing delimiter: `]`
--> $DIR/deli-ident-issue-2.rs:2:14
|
LL | if 1 < 2 {
| ^ unclosed delimiter
LL | let _a = vec!];
| ^ mismatched closing delimiter
error: unexpected closing delimiter: `}`
--> $DIR/deli-ident-issue-2.rs:5:1
|
@ -7,13 +15,5 @@ LL | }
LL | }
| ^ unexpected closing delimiter
error: mismatched closing delimiter: `]`
--> $DIR/deli-ident-issue-2.rs:2:14
|
LL | if 1 < 2 {
| ^ unclosed delimiter
LL | let _a = vec!];
| ^ mismatched closing delimiter
error: aborting due to 2 previous errors

2
tests/ui/parser/do-not-suggest-semicolon-before-array.rs
View File

@ -2,7 +2,7 @@ fn foo() {}
fn bar() -> [u8; 2] {
foo()
[1, 3) //~ ERROR expected one of `.`, `?`, `]`, or an operator, found `,`
[1, 3) //~ ERROR mismatched closing delimiter
}
fn main() {}

4
tests/ui/parser/do-not-suggest-semicolon-before-array.stderr
View File

@ -1,8 +1,8 @@
error: expected one of `.`, `?`, `]`, or an operator, found `,`
error: mismatched closing delimiter: `)`
--> $DIR/do-not-suggest-semicolon-before-array.rs:5:5
|
LL | [1, 3)
| ^ ^ help: `]` may belong here
| ^ ^ mismatched closing delimiter
| |
| unclosed delimiter

1
tests/ui/parser/issue-103451.rs
View File

@ -1,5 +1,4 @@
// error-pattern: this file contains an unclosed delimiter
// error-pattern: expected value, found struct `R`
struct R { }
struct S {
x: [u8; R

24
tests/ui/parser/issue-103451.stderr
View File

@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-103451.rs:5:15
--> $DIR/issue-103451.rs:4:15
|
LL | struct S {
| - unclosed delimiter
@ -8,25 +8,5 @@ LL | x: [u8; R
| |
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-103451.rs:5:15
|
LL | struct S {
| - unclosed delimiter
LL | x: [u8; R
| - ^
| |
| unclosed delimiter
error: aborting due to previous error
error[E0423]: expected value, found struct `R`
--> $DIR/issue-103451.rs:5:13
|
LL | struct R { }
| ------------ `R` defined here
LL | struct S {
LL | x: [u8; R
| ^ help: use struct literal syntax instead: `R {}`
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0423`.

16
tests/ui/parser/issue-68987-unmatch-issue-2.stderr
View File

@ -1,3 +1,11 @@
error: mismatched closing delimiter: `)`
--> $DIR/issue-68987-unmatch-issue-2.rs:3:32
|
LL | async fn obstest() -> Result<> {
| ^ unclosed delimiter
LL | let obs_connect = || -> Result<(), MyError) {
| ^ mismatched closing delimiter
error: unexpected closing delimiter: `}`
--> $DIR/issue-68987-unmatch-issue-2.rs:14:1
|
@ -7,13 +15,5 @@ LL | let obs_connect = || -> Result<(), MyError) {
LL | }
| ^ unexpected closing delimiter
error: mismatched closing delimiter: `)`
--> $DIR/issue-68987-unmatch-issue-2.rs:3:32
|
LL | async fn obstest() -> Result<> {
| ^ unclosed delimiter
LL | let obs_connect = || -> Result<(), MyError) {
| ^ mismatched closing delimiter
error: aborting due to 2 previous errors

16
tests/ui/parser/issue-68987-unmatch-issue-3.stderr
View File

@ -1,3 +1,11 @@
error: mismatched closing delimiter: `)`
--> $DIR/issue-68987-unmatch-issue-3.rs:5:19
|
LL | while cnt < j {
| ^ unclosed delimiter
LL | write!&mut res, " ");
| ^ mismatched closing delimiter
error: unexpected closing delimiter: `}`
--> $DIR/issue-68987-unmatch-issue-3.rs:8:1
|
@ -7,13 +15,5 @@ LL | }
LL | }
| ^ unexpected closing delimiter
error: mismatched closing delimiter: `)`
--> $DIR/issue-68987-unmatch-issue-3.rs:5:19
|
LL | while cnt < j {
| ^ unclosed delimiter
LL | write!&mut res, " ");
| ^ mismatched closing delimiter
error: aborting due to 2 previous errors

3
tests/ui/parser/issue-81804.rs
View File

@ -1,8 +1,5 @@
// error-pattern: this file contains an unclosed delimiter
// error-pattern: this file contains an unclosed delimiter
// error-pattern: expected pattern, found `=`
// error-pattern: expected one of `)`, `,`, `->`, `where`, or `{`, found `]`
// error-pattern: expected item, found `]`
fn main() {}

44
tests/ui/parser/issue-81804.stderr
View File

@ -1,41 +1,19 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-81804.rs:9:11
error: mismatched closing delimiter: `}`
--> $DIR/issue-81804.rs:6:8
|
LL | fn p([=(}
| -- ^
| ||
| |unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-81804.rs:9:11
|
LL | fn p([=(}
| -- ^
| ||
| |unclosed delimiter
| unclosed delimiter
error: expected pattern, found `=`
--> $DIR/issue-81804.rs:9:7
|
LL | fn p([=(}
| ^ expected pattern
error: expected one of `)`, `,`, `->`, `where`, or `{`, found `]`
--> $DIR/issue-81804.rs:9:8
|
LL | fn p([=(}
| ^ -^
| | |
| | help: `)` may belong here
| ^^ mismatched closing delimiter
| |
| unclosed delimiter
error: expected item, found `]`
--> $DIR/issue-81804.rs:9:11
error: this file contains an unclosed delimiter
--> $DIR/issue-81804.rs:6:11
|
LL | fn p([=(}
| ^ expected item
| -- ^
| ||
| |unclosed delimiter
| unclosed delimiter
error: aborting due to 5 previous errors
error: aborting due to 2 previous errors

1
tests/ui/parser/issue-81827.rs
View File

@ -1,6 +1,5 @@
// error-pattern: this file contains an unclosed delimiter
// error-pattern: mismatched closing delimiter: `]`
// error-pattern: expected one of `)` or `,`, found `{`
#![crate_name="0"]

34
tests/ui/parser/issue-81827.stderr
View File

@ -1,25 +1,5 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-81827.rs:11:27
|
LL | fn r()->i{0|{#[cfg(r(0{]0
| - - - ^
| | | |
| | | missing open `[` for this delimiter
| | unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-81827.rs:11:27
|
LL | fn r()->i{0|{#[cfg(r(0{]0
| - - - ^
| | | |
| | | missing open `[` for this delimiter
| | unclosed delimiter
| unclosed delimiter
error: mismatched closing delimiter: `]`
--> $DIR/issue-81827.rs:11:23
--> $DIR/issue-81827.rs:10:23
|
LL | fn r()->i{0|{#[cfg(r(0{]0
| - ^^ mismatched closing delimiter
@ -27,11 +7,15 @@ LL | fn r()->i{0|{#[cfg(r(0{]0
| | unclosed delimiter
| closing delimiter possibly meant for this
error: expected one of `)` or `,`, found `{`
--> $DIR/issue-81827.rs:11:23
error: this file contains an unclosed delimiter
--> $DIR/issue-81827.rs:10:27
|
LL | fn r()->i{0|{#[cfg(r(0{]0
| ^ expected one of `)` or `,`
| - - - ^
| | | |
| | | missing open `[` for this delimiter
| | unclosed delimiter
| unclosed delimiter
error: aborting due to 4 previous errors
error: aborting due to 2 previous errors

4
tests/ui/parser/issues/issue-10636-2.rs
View File

@ -1,11 +1,11 @@
// error-pattern: mismatched closing delimiter: `}`
// FIXME(31528) we emit a bunch of silly errors here due to continuing past the
// first one. This would be easy-ish to address by better recovery in tokenisation.
pub fn trace_option(option: Option<isize>) {
option.map(|some| 42;
//~^ ERROR: expected one of
}
//~^ ERROR: expected expression, found `)`
fn main() {}

19
tests/ui/parser/issues/issue-10636-2.stderr
View File

@ -1,16 +1,13 @@
error: expected one of `)`, `,`, `.`, `?`, or an operator, found `;`
--> $DIR/issue-10636-2.rs:5:15
error: mismatched closing delimiter: `}`
--> $DIR/issue-10636-2.rs:6:15
|
LL | pub fn trace_option(option: Option<isize>) {
| - closing delimiter possibly meant for this
LL | option.map(|some| 42;
| ^ ^ help: `)` may belong here
| |
| unclosed delimiter
error: expected expression, found `)`
--> $DIR/issue-10636-2.rs:8:1
|
| ^ unclosed delimiter
...
LL | }
| ^ expected expression
| ^ mismatched closing delimiter
error: aborting due to 2 previous errors
error: aborting due to previous error

3
tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs
View File

@ -1,4 +1,5 @@
// Fixed in #66054.
// ignore-tidy-trailing-newlines
// error-pattern: aborting due to 2 previous errors
// error-pattern: this file contains an unclosed delimiter
// error-pattern: aborting due to previous error
#[Ѕ

10
tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr
View File

@ -1,16 +1,10 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-58094-missing-right-square-bracket.rs:4:4
--> $DIR/issue-58094-missing-right-square-bracket.rs:5:4
|
LL | #[Ѕ
| - ^
| |
| unclosed delimiter
error: expected item after attributes
--> $DIR/issue-58094-missing-right-square-bracket.rs:4:1
|
LL | #[Ѕ
| ^^^
error: aborting due to 2 previous errors
error: aborting due to previous error

5
tests/ui/parser/issues/issue-58856-1.rs
View File

@ -1,8 +1,5 @@
impl A {
//~^ ERROR cannot find type `A` in this scope
fn b(self>
//~^ ERROR expected one of `)`, `,`, or `:`, found `>`
//~| ERROR expected one of `->`, `where`, or `{`, found `>`
}
} //~ ERROR mismatched closing delimiter
fn main() {}

29
tests/ui/parser/issues/issue-58856-1.stderr
View File

@ -1,29 +1,12 @@
error: expected one of `)`, `,`, or `:`, found `>`
--> $DIR/issue-58856-1.rs:3:9
|
LL | fn b(self>
| ^ ^ help: `)` may belong here
| |
| unclosed delimiter
error: expected one of `->`, `where`, or `{`, found `>`
--> $DIR/issue-58856-1.rs:3:14
error: mismatched closing delimiter: `}`
--> $DIR/issue-58856-1.rs:2:9
|
LL | impl A {
| - while parsing this item list starting here
LL |
| - closing delimiter possibly meant for this
LL | fn b(self>
| ^ expected one of `->`, `where`, or `{`
...
| ^ unclosed delimiter
LL | }
| - the item list ends here
| ^ mismatched closing delimiter
error[E0412]: cannot find type `A` in this scope
--> $DIR/issue-58856-1.rs:1:6
|
LL | impl A {
| ^ not found in this scope
error: aborting due to previous error
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0412`.

5
tests/ui/parser/issues/issue-58856-2.rs
View File

@ -4,11 +4,8 @@ trait Howness {}
impl Howness for () {
fn how_are_you(&self -> Empty {
//~^ ERROR expected one of `)` or `,`, found `->`
//~| ERROR method `how_are_you` is not a member of trait `Howness`
Empty
}
}
//~^ ERROR non-item in item list
} //~ ERROR mismatched closing delimiter
fn main() {}

33
tests/ui/parser/issues/issue-58856-2.stderr
View File

@ -1,34 +1,13 @@
error: expected one of `)` or `,`, found `->`
error: mismatched closing delimiter: `}`
--> $DIR/issue-58856-2.rs:6:19
|
LL | fn how_are_you(&self -> Empty {
| ^ -^^
| | |
| | help: `)` may belong here
| unclosed delimiter
error: non-item in item list
--> $DIR/issue-58856-2.rs:11:1
|
LL | impl Howness for () {
| - item list starts here
| - closing delimiter possibly meant for this
LL | fn how_are_you(&self -> Empty {
| ^ unclosed delimiter
...
LL | }
| ^
| |
| non-item starts here
| item list ends here
| ^ mismatched closing delimiter
error[E0407]: method `how_are_you` is not a member of trait `Howness`
--> $DIR/issue-58856-2.rs:6:5
|
LL | / fn how_are_you(&self -> Empty {
LL | |
LL | |
LL | | Empty
LL | | }
| |_____^ not a member of trait `Howness`
error: aborting due to previous error
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0407`.

5
tests/ui/parser/issues/issue-60075.rs
View File

@ -3,9 +3,6 @@ fn main() {}
trait T {
fn qux() -> Option<usize> {
let _ = if true {
});
//~^ ERROR non-item in item list
//~| ERROR mismatched closing delimiter: `)`
//~| ERROR expected one of `.`, `;`
}); //~ ERROR mismatched closing delimiter
Some(4)
}

20
tests/ui/parser/issues/issue-60075.stderr
View File

@ -1,21 +1,3 @@
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `}`
--> $DIR/issue-60075.rs:6:10
|
LL | });
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
error: non-item in item list
--> $DIR/issue-60075.rs:6:11
|
LL | trait T {
| - item list starts here
...
LL | });
| ^ non-item starts here
...
LL | }
| - item list ends here
error: mismatched closing delimiter: `)`
--> $DIR/issue-60075.rs:4:31
|
@ -25,5 +7,5 @@ LL | let _ = if true {
LL | });
| ^ mismatched closing delimiter
error: aborting due to 3 previous errors
error: aborting due to previous error

2
tests/ui/parser/issues/issue-62524.rs
View File

@ -1,5 +1,5 @@
// ignore-tidy-trailing-newlines
// error-pattern: aborting due to 3 previous errors
// error-pattern: aborting due to previous error
#![allow(uncommon_codepoints)]
y![

25
tests/ui/parser/issues/issue-62524.stderr
View File

@ -6,28 +6,5 @@ LL | y![
LL | Ϥ,
| ^
error: macros that expand to items must be delimited with braces or followed by a semicolon
--> $DIR/issue-62524.rs:5:3
|
LL | y![
| ___^
LL | | Ϥ,
| |__^
|
help: change the delimiters to curly braces
|
LL | y! { /* items */ }
| ~~~~~~~~~~~~~~~
help: add a semicolon
|
LL | Ϥ,;
| +
error: cannot find macro `y` in this scope
--> $DIR/issue-62524.rs:5:1
|
LL | y![
| ^
error: aborting due to 3 previous errors
error: aborting due to previous error

4
tests/ui/parser/issues/issue-62546.rs
View File

@ -1,3 +1 @@
pub t(#
//~^ ERROR missing `fn` or `struct` for function or struct definition
//~ ERROR this file contains an unclosed delimiter
pub t(# //~ ERROR this file contains an unclosed delimiter

15
tests/ui/parser/issues/issue-62546.stderr
View File

@ -1,17 +1,8 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-62546.rs:3:52
--> $DIR/issue-62546.rs:1:60
|
LL | pub t(#
| - unclosed delimiter
LL |
LL |
| ^
| - unclosed delimiter ^
error: missing `fn` or `struct` for function or struct definition
--> $DIR/issue-62546.rs:1:4
|
LL | pub t(#
| ---^- help: if you meant to call a macro, try: `t!`
error: aborting due to 2 previous errors
error: aborting due to previous error

1
tests/ui/parser/issues/issue-62554.rs
View File

@ -1,5 +1,4 @@
// error-pattern:this file contains an unclosed delimiter
// error-pattern:xpected `{`, found `macro_rules`
fn main() {}

64
tests/ui/parser/issues/issue-62554.stderr
View File

@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-62554.rs:6:89
--> $DIR/issue-62554.rs:5:89
|
LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
| - - - - - ^
@ -9,65 +9,5 @@ LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s
| | | unclosed delimiter
| unclosed delimiter unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-62554.rs:6:89
|
LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
| - - - - - ^
| | | | | |
| | | | | unclosed delimiter
| | | | unclosed delimiter
| | | unclosed delimiter
| unclosed delimiter unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-62554.rs:6:89
|
LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
| - - - - - ^
| | | | | |
| | | | | unclosed delimiter
| | | | unclosed delimiter
| | | unclosed delimiter
| unclosed delimiter unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-62554.rs:6:89
|
LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
| - - - - - ^
| | | | | |
| | | | | unclosed delimiter
| | | | unclosed delimiter
| | | unclosed delimiter
| unclosed delimiter unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-62554.rs:6:89
|
LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
| - - - - - ^
| | | | | |
| | | | | unclosed delimiter
| | | | unclosed delimiter
| | | unclosed delimiter
| unclosed delimiter unclosed delimiter
error: expected `{`, found `macro_rules`
--> $DIR/issue-62554.rs:6:23
|
LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
| ^^^^^^^^^^^ expected `{`
|
note: the `if` expression is missing a block after this condition
--> $DIR/issue-62554.rs:6:20
|
LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
| ^^
help: try placing this code inside a block
|
LL | fn foo(u: u8) { if u8 { macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 { }
| + +
error: aborting due to 6 previous errors
error: aborting due to previous error

5
tests/ui/parser/issues/issue-62881.rs
View File

@ -1,6 +1,3 @@
fn main() {}
fn f() -> isize { fn f() -> isize {} pub f<
//~^ ERROR missing `fn` or `struct` for function or struct definition
//~| ERROR mismatched types
//~ ERROR this file contains an unclosed delimiter
fn f() -> isize { fn f() -> isize {} pub f< //~ ERROR this file contains an unclosed delimiter

24
tests/ui/parser/issues/issue-62881.stderr
View File

@ -1,26 +1,8 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-62881.rs:6:52
--> $DIR/issue-62881.rs:3:96
|
LL | fn f() -> isize { fn f() -> isize {} pub f<
| - unclosed delimiter
...
LL |
| ^
| - unclosed delimiter ^
error: missing `fn` or `struct` for function or struct definition
--> $DIR/issue-62881.rs:3:41
|
LL | fn f() -> isize { fn f() -> isize {} pub f<
| ^
error: aborting due to previous error
error[E0308]: mismatched types
--> $DIR/issue-62881.rs:3:29
|
LL | fn f() -> isize { fn f() -> isize {} pub f<
| - ^^^^^ expected `isize`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0308`.

1
tests/ui/parser/issues/issue-62894.rs
View File

@ -1,6 +1,5 @@
// Regression test for #62894, shouldn't crash.
// error-pattern: this file contains an unclosed delimiter
// error-pattern: expected one of `(`, `[`, or `{`, found keyword `fn`
fn f() { assert_eq!(f(), (), assert_eq!(assert_eq!

40
tests/ui/parser/issues/issue-62894.stderr
View File

@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-62894.rs:7:14
--> $DIR/issue-62894.rs:6:14
|
LL | fn f() { assert_eq!(f(), (), assert_eq!(assert_eq!
| - - - unclosed delimiter
@ -10,41 +10,5 @@ LL |
LL | fn main() {}
| ^
error: this file contains an unclosed delimiter
--> $DIR/issue-62894.rs:7:14
|
LL | fn f() { assert_eq!(f(), (), assert_eq!(assert_eq!
| - - - unclosed delimiter
| | |
| | unclosed delimiter
| unclosed delimiter
LL |
LL | fn main() {}
| ^
error: this file contains an unclosed delimiter
--> $DIR/issue-62894.rs:7:14
|
LL | fn f() { assert_eq!(f(), (), assert_eq!(assert_eq!
| - - - unclosed delimiter
| | |
| | unclosed delimiter
| unclosed delimiter
LL |
LL | fn main() {}
| ^
error: expected one of `(`, `[`, or `{`, found keyword `fn`
--> $DIR/issue-62894.rs:7:1
|
LL | fn f() { assert_eq!(f(), (), assert_eq!(assert_eq!
| - expected one of `(`, `[`, or `{`
LL |
LL | fn main() {}
| ^^ unexpected token
--> $SRC_DIR/core/src/macros/mod.rs:LL:COL
|
= note: while parsing argument for this `expr` macro fragment
error: aborting due to 4 previous errors
error: aborting due to previous error

14
tests/ui/parser/issues/issue-62895.rs
View File

@ -1,11 +1,11 @@
fn main() {}
fn v() -> isize { //~ ERROR mismatched types
mod _ { //~ ERROR expected identifier
pub fn g() -> isizee { //~ ERROR cannot find type `isizee` in this scope
mod _ { //~ ERROR expected identifier
pub g() -> is //~ ERROR missing `fn` for function definition
(), w20);
fn v() -> isize {
mod _ {
pub fn g() -> isizee {
mod _ {
pub g() -> is
(), w20); //~ ERROR mismatched closing delimiter
}
(), w20); //~ ERROR expected item, found `;`
(), w20); //~ ERROR mismatched closing delimiter
}

51
tests/ui/parser/issues/issue-62895.stderr
View File

@ -1,47 +1,20 @@
error: expected identifier, found reserved identifier `_`
--> $DIR/issue-62895.rs:4:5
error: mismatched closing delimiter: `)`
--> $DIR/issue-62895.rs:6:7
|
LL | mod _ {
| ^ expected identifier, found reserved identifier
error: expected identifier, found reserved identifier `_`
--> $DIR/issue-62895.rs:6:5
|
LL | mod _ {
| ^ expected identifier, found reserved identifier
error: missing `fn` for function definition
--> $DIR/issue-62895.rs:7:4
|
| ^ unclosed delimiter
LL | pub g() -> is
| ^^^^
|
help: add `fn` here to parse `g` as a public function
|
LL | pub fn g() -> is
| ++
error: expected item, found `;`
--> $DIR/issue-62895.rs:10:9
|
LL | (), w20);
| ^ help: remove this semicolon
| ^ mismatched closing delimiter
error[E0412]: cannot find type `isizee` in this scope
--> $DIR/issue-62895.rs:5:15
error: mismatched closing delimiter: `)`
--> $DIR/issue-62895.rs:4:7
|
LL | pub fn g() -> isizee {
| ^^^^^^ help: a builtin type with a similar name exists: `isize`
LL | mod _ {
| ^ unclosed delimiter
...
LL | (), w20);
| ^ mismatched closing delimiter
error[E0308]: mismatched types
--> $DIR/issue-62895.rs:3:11
|
LL | fn v() -> isize {
| - ^^^^^ expected `isize`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
error: aborting due to 2 previous errors
error: aborting due to 6 previous errors
Some errors have detailed explanations: E0308, E0412.
For more information about an error, try `rustc --explain E0308`.

2
tests/ui/parser/issues/issue-62973.rs
View File

@ -1,5 +1,5 @@
// ignore-tidy-trailing-newlines
// error-pattern: aborting due to 7 previous errors
// error-pattern: aborting due to 3 previous errors
fn main() {}

84
tests/ui/parser/issues/issue-62973.stderr
View File

@ -1,72 +1,3 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-62973.rs:8:2
|
LL | fn p() { match s { v, E { [) {) }
| - - - - missing open `(` for this delimiter
| | | |
| | | missing open `(` for this delimiter
| | unclosed delimiter
| unclosed delimiter
LL |
LL |
| ^
error: this file contains an unclosed delimiter
--> $DIR/issue-62973.rs:8:2
|
LL | fn p() { match s { v, E { [) {) }
| - - - - missing open `(` for this delimiter
| | | |
| | | missing open `(` for this delimiter
| | unclosed delimiter
| unclosed delimiter
LL |
LL |
| ^
error: expected one of `,`, `:`, or `}`, found `{`
--> $DIR/issue-62973.rs:6:8
|
LL | fn p() { match s { v, E { [) {) }
| ^ - ^ expected one of `,`, `:`, or `}`
| | |
| | while parsing this struct
| unclosed delimiter
|
help: `}` may belong here
|
LL | fn p() { match s { v, E} { [) {) }
| +
help: try naming a field
|
LL | fn p() { match s { v, E: E { [) {) }
| ++
error: struct literals are not allowed here
--> $DIR/issue-62973.rs:6:16
|
LL | fn p() { match s { v, E { [) {) }
| ________________^
LL | |
LL | |
| |_^
|
help: surround the struct literal with parentheses
|
LL ~ fn p() { match (s { v, E { [) {) }
LL |
LL ~ )
|
error: expected one of `.`, `?`, `{`, or an operator, found `}`
--> $DIR/issue-62973.rs:8:2
|
LL | fn p() { match s { v, E { [) {) }
| ----- while parsing this `match` expression
LL |
LL |
| ^ expected one of `.`, `?`, `{`, or an operator
error: mismatched closing delimiter: `)`
--> $DIR/issue-62973.rs:6:27
|
@ -83,5 +14,18 @@ LL | fn p() { match s { v, E { [) {) }
| |
| unclosed delimiter
error: aborting due to 7 previous errors
error: this file contains an unclosed delimiter
--> $DIR/issue-62973.rs:8:2
|
LL | fn p() { match s { v, E { [) {) }
| - - - - missing open `(` for this delimiter
| | | |
| | | missing open `(` for this delimiter
| | unclosed delimiter
| unclosed delimiter
LL |
LL |
| ^
error: aborting due to 3 previous errors

2
tests/ui/parser/issues/issue-63116.rs
View File

@ -1,3 +1,3 @@
// fixed by #66361
// error-pattern: aborting due to 3 previous errors
// error-pattern: aborting due to 2 previous errors
impl W <s(f;Y(;]

24
tests/ui/parser/issues/issue-63116.stderr
View File

@ -1,3 +1,11 @@
error: mismatched closing delimiter: `]`
--> $DIR/issue-63116.rs:3:14
|
LL | impl W <s(f;Y(;]
| ^ ^ mismatched closing delimiter
| |
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-63116.rs:3:18
|
@ -7,19 +15,5 @@ LL | impl W <s(f;Y(;]
| | missing open `[` for this delimiter
| unclosed delimiter
error: expected one of `!`, `(`, `)`, `+`, `,`, `::`, or `<`, found `;`
--> $DIR/issue-63116.rs:3:12
|
LL | impl W <s(f;Y(;]
| ^ expected one of 7 possible tokens
error: mismatched closing delimiter: `]`
--> $DIR/issue-63116.rs:3:14
|
LL | impl W <s(f;Y(;]
| ^ ^ mismatched closing delimiter
| |
| unclosed delimiter
error: aborting due to 3 previous errors
error: aborting due to 2 previous errors

4
tests/ui/parser/issues/issue-63135.rs
View File

@ -1,3 +1,3 @@
// error-pattern: aborting due to 5 previous errors
// error-pattern: this file contains an unclosed delimiter
// error-pattern: aborting due to previous error
fn i(n{...,f #

39
tests/ui/parser/issues/issue-63135.stderr
View File

@ -7,42 +7,5 @@ LL | fn i(n{...,f #
| | unclosed delimiter
| unclosed delimiter
error: this file contains an unclosed delimiter
--> $DIR/issue-63135.rs:3:16
|
LL | fn i(n{...,f #
| - - ^
| | |
| | unclosed delimiter
| unclosed delimiter
error: expected field pattern, found `...`
--> $DIR/issue-63135.rs:3:8
|
LL | fn i(n{...,f #
| ^^^
|
help: to omit remaining fields, use `..`
|
LL | fn i(n{..,f #
| ~~
error: expected `}`, found `,`
--> $DIR/issue-63135.rs:3:11
|
LL | fn i(n{...,f #
| ---^
| | |
| | expected `}`
| `..` must be at the end and cannot have a trailing comma
error: expected one of `!` or `[`, found `}`
--> $DIR/issue-63135.rs:3:16
|
LL | fn i(n{...,f #
| - ^ expected one of `!` or `[`
| |
| while parsing the fields for this pattern
error: aborting due to 5 previous errors
error: aborting due to previous error

4
tests/ui/parser/issues/issue-66357-unexpected-unreachable.rs
View File

@ -9,6 +9,4 @@
//
// ended up bubbling up `Ok(true)` to `unexpected` which then used `unreachable!()`.
fn f() { |[](* }
//~^ ERROR expected one of `,` or `:`, found `(`
//~| ERROR expected one of `&`, `(`, `)`, `-`, `...`, `..=`, `..`, `[`, `_`, `box`, `mut`, `ref`, `|`, identifier, or path, found `*`
fn f() { |[](* } //~ ERROR mismatched closing delimiter

17
tests/ui/parser/issues/issue-66357-unexpected-unreachable.stderr
View File

@ -1,16 +1,11 @@
error: expected one of `,` or `:`, found `(`
error: mismatched closing delimiter: `}`
--> $DIR/issue-66357-unexpected-unreachable.rs:12:13
|
LL | fn f() { |[](* }
| ^ expected one of `,` or `:`
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error: expected one of `&`, `(`, `)`, `-`, `...`, `..=`, `..`, `[`, `_`, `box`, `mut`, `ref`, `|`, identifier, or path, found `*`
--> $DIR/issue-66357-unexpected-unreachable.rs:12:13
|
LL | fn f() { |[](* }
| ^^ help: `)` may belong here
| |
| unclosed delimiter
error: aborting due to 2 previous errors
error: aborting due to previous error

14
tests/ui/parser/issues/issue-67377-invalid-syntax-in-enum-discriminant.rs
View File

@ -4,9 +4,6 @@ mod a {
enum Bug {
V = [PhantomData; { [ () ].len() ].len() as isize,
//~^ ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
}
}
@ -14,10 +11,6 @@ mod b {
enum Bug {
V = [Vec::new; { [].len() ].len() as isize,
//~^ ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
//~| ERROR type annotations needed
}
}
@ -25,11 +18,6 @@ mod c {
enum Bug {
V = [Vec::new; { [0].len() ].len() as isize,
//~^ ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
//~| ERROR mismatched closing delimiter: `]`
//~| ERROR type annotations needed
}
}
fn main() {}
fn main() {} //~ ERROR this file contains an unclosed delimiter

113
tests/ui/parser/issues/issue-67377-invalid-syntax-in-enum-discriminant.stderr
View File

@ -8,7 +8,7 @@ LL | V = [PhantomData; { [ () ].len() ].len() as isize,
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:24
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:12:24
|
LL | V = [Vec::new; { [].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
@ -17,7 +17,7 @@ LL | V = [Vec::new; { [].len() ].len() as isize,
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:24
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:19:24
|
LL | V = [Vec::new; { [0].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
@ -25,104 +25,23 @@ LL | V = [Vec::new; { [0].len() ].len() as isize,
| | unclosed delimiter
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:5:27
error: this file contains an unclosed delimiter
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:23:65
|
LL | V = [PhantomData; { [ () ].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:24
|
| - missing open `[` for this delimiter
...
LL | V = [Vec::new; { [].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:24
|
| - missing open `[` for this delimiter
...
LL | mod c {
| - unclosed delimiter
LL | enum Bug {
LL | V = [Vec::new; { [0].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
| - missing open `[` for this delimiter
...
LL | fn main() {}
| ^
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:5:27
|
LL | V = [PhantomData; { [ () ].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error: aborting due to 4 previous errors
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:24
|
LL | V = [Vec::new; { [].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:24
|
LL | V = [Vec::new; { [0].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:5:27
|
LL | V = [PhantomData; { [ () ].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:24
|
LL | V = [Vec::new; { [].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error: mismatched closing delimiter: `]`
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:24
|
LL | V = [Vec::new; { [0].len() ].len() as isize,
| - ^ ^ mismatched closing delimiter
| | |
| | unclosed delimiter
| closing delimiter possibly meant for this
error[E0282]: type annotations needed
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:26
|
LL | V = [Vec::new; { [].len() ].len() as isize,
| ^^ cannot infer type for type parameter `T`
error[E0282]: type annotations needed
--> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:14
|
LL | V = [Vec::new; { [0].len() ].len() as isize,
| ^^^^^^^^ cannot infer type of the type parameter `T` declared on the struct `Vec`
|
help: consider specifying the generic argument
|
LL | V = [Vec::<T>::new; { [0].len() ].len() as isize,
| +++++
error: aborting due to 14 previous errors
For more information about this error, try `rustc --explain E0282`.

BIN
tests/ui/parser/issues/issue-68629.rs
View File

Binary file not shown.

BIN
tests/ui/parser/issues/issue-68629.stderr
View File

Binary file not shown.

1
tests/ui/parser/issues/issue-84104.rs
View File

@ -1,3 +1,2 @@
// error-pattern: this file contains an unclosed delimiter
// error-pattern: expected one of
#[i=i::<ښܖ<

10
tests/ui/parser/issues/issue-84104.stderr
View File

@ -1,16 +1,10 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-84104.rs:3:13
--> $DIR/issue-84104.rs:2:13
|
LL | #[i=i::<ښܖ<
| - ^
| |
| unclosed delimiter
error: expected one of `>`, a const expression, lifetime, or type, found `]`
--> $DIR/issue-84104.rs:3:13
|
LL | #[i=i::<ښܖ<
| ^ expected one of `>`, a const expression, lifetime, or type
error: aborting due to 2 previous errors
error: aborting due to previous error

1
tests/ui/parser/issues/issue-84148-2.rs
View File

@ -1,3 +1,2 @@
// error-pattern: this file contains an unclosed delimiter
// error-pattern: invalid `?` in type
fn f(t:for<>t?

21
tests/ui/parser/issues/issue-84148-2.stderr
View File

@ -1,27 +1,10 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-84148-2.rs:3:16
--> $DIR/issue-84148-2.rs:2:16
|
LL | fn f(t:for<>t?
| - ^
| |
| unclosed delimiter
error: invalid `?` in type
--> $DIR/issue-84148-2.rs:3:14
|
LL | fn f(t:for<>t?
| ^ `?` is only allowed on expressions, not types
|
help: if you meant to express that the type might not contain a value, use the `Option` wrapper type
|
LL | fn f(t:Option<for<>t>
| +++++++ ~
error: expected one of `->`, `where`, or `{`, found `<eof>`
--> $DIR/issue-84148-2.rs:3:16
|
LL | fn f(t:for<>t?
| ^ expected one of `->`, `where`, or `{`
error: aborting due to 3 previous errors
error: aborting due to previous error

3
tests/ui/parser/issues/issue-88770.rs
View File

@ -1,9 +1,6 @@
// Regression test for the ICE described in #88770.
// error-pattern:this file contains an unclosed delimiter
// error-pattern:expected one of
// error-pattern:missing `in` in `for` loop
// error-pattern:expected one of `!`, `)`, `,`, `.`, `::`, `;`, `?`, `{`, or an operator, found `e`
fn m(){print!("",(c for&g
u

50
tests/ui/parser/issues/issue-88770.stderr
View File

@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
--> $DIR/issue-88770.rs:11:3
--> $DIR/issue-88770.rs:8:3
|
LL | fn m(){print!("",(c for&g
| - - - unclosed delimiter
@ -10,51 +10,5 @@ LL | fn m(){print!("",(c for&g
LL | e
| ^
error: this file contains an unclosed delimiter
--> $DIR/issue-88770.rs:11:3
|
LL | fn m(){print!("",(c for&g
| - - - unclosed delimiter
| | |
| | unclosed delimiter
| unclosed delimiter
...
LL | e
| ^
error: this file contains an unclosed delimiter
--> $DIR/issue-88770.rs:11:3
|
LL | fn m(){print!("",(c for&g
| - - - unclosed delimiter
| | |
| | unclosed delimiter
| unclosed delimiter
...
LL | e
| ^
error: missing `in` in `for` loop
--> $DIR/issue-88770.rs:8:26
|
LL | fn m(){print!("",(c for&g
| __________________________^
LL | | u
| |_ help: try adding `in` here
error: expected one of `!`, `)`, `,`, `.`, `::`, `?`, `{`, or an operator, found keyword `for`
--> $DIR/issue-88770.rs:8:21
|
LL | fn m(){print!("",(c for&g
| ^^^ expected one of 8 possible tokens
error: expected one of `!`, `)`, `,`, `.`, `::`, `;`, `?`, `{`, or an operator, found `e`
--> $DIR/issue-88770.rs:11:1
|
LL | e
| - expected one of 9 possible tokens
LL | e
| ^ unexpected token
error: aborting due to 6 previous errors
error: aborting due to previous error

18
tests/ui/parser/macro-mismatched-delim-paren-brace.stderr
View File

@ -1,3 +1,12 @@
error: mismatched closing delimiter: `}`
--> $DIR/macro-mismatched-delim-paren-brace.rs:2:10
|
LL | foo! (
| ^ unclosed delimiter
LL | bar, "baz", 1, 2.0
LL | }
| ^ mismatched closing delimiter
error: unexpected closing delimiter: `}`
--> $DIR/macro-mismatched-delim-paren-brace.rs:5:1
|
@ -9,14 +18,5 @@ LL | }
LL | }
| ^ unexpected closing delimiter
error: mismatched closing delimiter: `}`
--> $DIR/macro-mismatched-delim-paren-brace.rs:2:10
|
LL | foo! (
| ^ unclosed delimiter
LL | bar, "baz", 1, 2.0
LL | }
| ^ mismatched closing delimiter
error: aborting due to 2 previous errors

2
tests/ui/parser/mbe_missing_right_paren.rs
View File

@ -1,3 +1,3 @@
// ignore-tidy-trailing-newlines
// error-pattern: aborting due to 3 previous errors
// error-pattern: this file contains an unclosed delimiter
macro_rules! abc(ؼ

23
tests/ui/parser/mbe_missing_right_paren.stderr
View File

@ -6,26 +6,5 @@ LL | macro_rules! abc(ؼ
| |
| unclosed delimiter
error: macros that expand to items must be delimited with braces or followed by a semicolon
--> $DIR/mbe_missing_right_paren.rs:3:17
|
LL | macro_rules! abc(ؼ
| ^^
|
help: change the delimiters to curly braces
|
LL | macro_rules! abc { /* items */ }
| ~~~~~~~~~~~~~~~
help: add a semicolon
|
LL | macro_rules! abc(ؼ;
| +
error: unexpected end of macro invocation
--> $DIR/mbe_missing_right_paren.rs:3:19
|
LL | macro_rules! abc(ؼ
| ^ missing tokens in macro arguments
error: aborting due to 3 previous errors
error: aborting due to previous error

6
tests/ui/parser/mismatched-braces/missing-close-brace-in-impl-trait.rs
View File

@ -1,13 +1,13 @@
fn main() {}
impl T for () { //~ ERROR cannot find trait `T` in this scope
impl T for () {
fn foo(&self) {}
trait T { //~ ERROR trait is not supported in `trait`s or `impl`s
trait T {
fn foo(&self);
}
pub(crate) struct Bar<T>(); //~ ERROR struct is not supported in `trait`s or `impl`s
pub(crate) struct Bar<T>();
//~ ERROR this file contains an unclosed delimiter

25
tests/ui/parser/mismatched-braces/missing-close-brace-in-impl-trait.stderr
View File

@ -7,28 +7,5 @@ LL | impl T for () {
LL |
| ^
error: trait is not supported in `trait`s or `impl`s
--> $DIR/missing-close-brace-in-impl-trait.rs:7:1
|
LL | trait T {
| ^^^^^^^
|
= help: consider moving the trait out to a nearby module scope
error: aborting due to previous error
error: struct is not supported in `trait`s or `impl`s
--> $DIR/missing-close-brace-in-impl-trait.rs:11:1
|
LL | pub(crate) struct Bar<T>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: consider moving the struct out to a nearby module scope
error[E0405]: cannot find trait `T` in this scope
--> $DIR/missing-close-brace-in-impl-trait.rs:3:6
|
LL | impl T for () {
| ^ not found in this scope
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0405`.

2
tests/ui/parser/mismatched-braces/missing-close-brace-in-struct.rs
View File

@ -1,7 +1,7 @@
pub(crate) struct Bar<T> {
foo: T,
trait T { //~ ERROR expected identifier, found keyword `trait`
trait T {
fn foo(&self);
}

Some files were not shown because too many files have changed in this diff Show More