mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-25 16:24:46 +00:00
Auto merge of #95403 - Dylan-DPC:rollup-9on30mg, r=Dylan-DPC
Rollup of 6 pull requests Successful merges: - #95301 (Remove `Nonterminal::NtTT`.) - #95314 (Tell users that `||` operators are not currently supported in let chain expressions) - #95350 (resolve: Simplify some diagnostic code to avoid an ICE) - #95370 ([bootstrap] Don't print `Suite not skipped` unless `--verbose` is set) - #95390 (Ignore doc comments in a declarative macro matcher.) - #95401 (Remove duplicated and unused test files) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
commit
600ec28483
@ -51,7 +51,6 @@ impl AstLike for crate::token::Nonterminal {
|
||||
| Nonterminal::NtMeta(_)
|
||||
| Nonterminal::NtPath(_)
|
||||
| Nonterminal::NtVis(_)
|
||||
| Nonterminal::NtTT(_)
|
||||
| Nonterminal::NtBlock(_)
|
||||
| Nonterminal::NtIdent(..)
|
||||
| Nonterminal::NtLifetime(_) => &[],
|
||||
@ -67,7 +66,6 @@ impl AstLike for crate::token::Nonterminal {
|
||||
| Nonterminal::NtMeta(_)
|
||||
| Nonterminal::NtPath(_)
|
||||
| Nonterminal::NtVis(_)
|
||||
| Nonterminal::NtTT(_)
|
||||
| Nonterminal::NtBlock(_)
|
||||
| Nonterminal::NtIdent(..)
|
||||
| Nonterminal::NtLifetime(_) => {}
|
||||
@ -84,7 +82,7 @@ impl AstLike for crate::token::Nonterminal {
|
||||
Nonterminal::NtPath(path) => path.tokens_mut(),
|
||||
Nonterminal::NtVis(vis) => vis.tokens_mut(),
|
||||
Nonterminal::NtBlock(block) => block.tokens_mut(),
|
||||
Nonterminal::NtIdent(..) | Nonterminal::NtLifetime(..) | Nonterminal::NtTT(..) => None,
|
||||
Nonterminal::NtIdent(..) | Nonterminal::NtLifetime(..) => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -787,7 +787,6 @@ pub fn visit_interpolated<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut
|
||||
visit_lazy_tts(tokens, vis);
|
||||
}
|
||||
token::NtPath(path) => vis.visit_path(path),
|
||||
token::NtTT(tt) => visit_tt(tt, vis),
|
||||
token::NtVis(visib) => vis.visit_vis(visib),
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,6 @@ pub use TokenKind::*;
|
||||
|
||||
use crate::ast;
|
||||
use crate::ptr::P;
|
||||
use crate::tokenstream::TokenTree;
|
||||
|
||||
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
|
||||
use rustc_data_structures::sync::Lrc;
|
||||
@ -680,7 +679,6 @@ pub enum Nonterminal {
|
||||
NtMeta(P<ast::AttrItem>),
|
||||
NtPath(ast::Path),
|
||||
NtVis(ast::Visibility),
|
||||
NtTT(TokenTree),
|
||||
}
|
||||
|
||||
// `Nonterminal` is used a lot. Make sure it doesn't unintentionally get bigger.
|
||||
@ -778,7 +776,6 @@ impl Nonterminal {
|
||||
NtMeta(attr_item) => attr_item.span(),
|
||||
NtPath(path) => path.span,
|
||||
NtVis(vis) => vis.span,
|
||||
NtTT(tt) => tt.span(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -790,7 +787,6 @@ impl PartialEq for Nonterminal {
|
||||
ident_lhs == ident_rhs && is_raw_lhs == is_raw_rhs
|
||||
}
|
||||
(NtLifetime(ident_lhs), NtLifetime(ident_rhs)) => ident_lhs == ident_rhs,
|
||||
(NtTT(tt_lhs), NtTT(tt_rhs)) => tt_lhs == tt_rhs,
|
||||
// FIXME: Assume that all "complex" nonterminal are not equal, we can't compare them
|
||||
// correctly based on data from AST. This will prevent them from matching each other
|
||||
// in macros. The comparison will become possible only when each nonterminal has an
|
||||
@ -813,7 +809,6 @@ impl fmt::Debug for Nonterminal {
|
||||
NtLiteral(..) => f.pad("NtLiteral(..)"),
|
||||
NtMeta(..) => f.pad("NtMeta(..)"),
|
||||
NtPath(..) => f.pad("NtPath(..)"),
|
||||
NtTT(..) => f.pad("NtTT(..)"),
|
||||
NtVis(..) => f.pad("NtVis(..)"),
|
||||
NtLifetime(..) => f.pad("NtLifetime(..)"),
|
||||
}
|
||||
|
@ -122,7 +122,10 @@ impl<'a> AstValidator<'a> {
|
||||
diag.note("only supported directly in conditions of `if` and `while` expressions");
|
||||
diag.note("as well as when nested within `&&` and parentheses in those conditions");
|
||||
if let ForbiddenLetReason::ForbiddenWithOr(span) = forbidden_let_reason {
|
||||
diag.span_note(span, "`||` operators are not allowed in let chain expressions");
|
||||
diag.span_note(
|
||||
span,
|
||||
"`||` operators are not currently supported in let chain expressions",
|
||||
);
|
||||
}
|
||||
diag.emit();
|
||||
} else {
|
||||
|
@ -714,7 +714,6 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
|
||||
token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(e, is_raw).to_string(),
|
||||
token::NtLifetime(e) => e.to_string(),
|
||||
token::NtLiteral(ref e) => self.expr_to_string(e),
|
||||
token::NtTT(ref tree) => self.tt_to_string(tree),
|
||||
token::NtVis(ref e) => self.vis_to_string(e),
|
||||
}
|
||||
}
|
||||
|
@ -76,7 +76,7 @@ crate use ParseResult::*;
|
||||
use crate::mbe::{self, SequenceRepetition, TokenTree};
|
||||
|
||||
use rustc_ast::token::{self, DocComment, Nonterminal, Token};
|
||||
use rustc_parse::parser::Parser;
|
||||
use rustc_parse::parser::{NtOrTt, Parser};
|
||||
use rustc_session::parse::ParseSess;
|
||||
use rustc_span::symbol::MacroRulesNormalizedIdent;
|
||||
|
||||
@ -275,7 +275,7 @@ pub(super) fn count_names(ms: &[TokenTree]) -> usize {
|
||||
}
|
||||
|
||||
/// `NamedMatch` is a pattern-match result for a single metavar. All
|
||||
/// `MatchedNtNonTt`s in the `NamedMatch` have the same non-terminal type
|
||||
/// `MatchedNonterminal`s in the `NamedMatch` have the same non-terminal type
|
||||
/// (expr, item, etc).
|
||||
///
|
||||
/// The in-memory structure of a particular `NamedMatch` represents the match
|
||||
@ -306,17 +306,17 @@ pub(super) fn count_names(ms: &[TokenTree]) -> usize {
|
||||
/// ```rust
|
||||
/// MatchedSeq([
|
||||
/// MatchedSeq([
|
||||
/// MatchedNtNonTt(a),
|
||||
/// MatchedNtNonTt(b),
|
||||
/// MatchedNtNonTt(c),
|
||||
/// MatchedNtNonTt(d),
|
||||
/// MatchedNonterminal(a),
|
||||
/// MatchedNonterminal(b),
|
||||
/// MatchedNonterminal(c),
|
||||
/// MatchedNonterminal(d),
|
||||
/// ]),
|
||||
/// MatchedSeq([
|
||||
/// MatchedNtNonTt(a),
|
||||
/// MatchedNtNonTt(b),
|
||||
/// MatchedNtNonTt(c),
|
||||
/// MatchedNtNonTt(d),
|
||||
/// MatchedNtNonTt(e),
|
||||
/// MatchedNonterminal(a),
|
||||
/// MatchedNonterminal(b),
|
||||
/// MatchedNonterminal(c),
|
||||
/// MatchedNonterminal(d),
|
||||
/// MatchedNonterminal(e),
|
||||
/// ])
|
||||
/// ])
|
||||
/// ```
|
||||
@ -324,14 +324,11 @@ pub(super) fn count_names(ms: &[TokenTree]) -> usize {
|
||||
crate enum NamedMatch {
|
||||
MatchedSeq(Lrc<NamedMatchVec>),
|
||||
|
||||
// This variant should never hold an `NtTT`. `MatchedNtTt` should be used
|
||||
// for that case.
|
||||
MatchedNtNonTt(Lrc<Nonterminal>),
|
||||
// A metavar match of type `tt`.
|
||||
MatchedTokenTree(rustc_ast::tokenstream::TokenTree),
|
||||
|
||||
// `NtTT` is handled without any cloning when transcribing, unlike other
|
||||
// nonterminals. Therefore, an `Lrc` isn't helpful and causes unnecessary
|
||||
// allocations. Hence this separate variant.
|
||||
MatchedNtTt(rustc_ast::tokenstream::TokenTree),
|
||||
// A metavar match of any type other than `tt`.
|
||||
MatchedNonterminal(Lrc<Nonterminal>),
|
||||
}
|
||||
|
||||
/// Takes a slice of token trees `ms` representing a matcher which successfully matched input
|
||||
@ -519,13 +516,14 @@ impl<'tt> TtParser<'tt> {
|
||||
}
|
||||
|
||||
TokenTree::Token(t) => {
|
||||
// Doc comments cannot appear in a matcher.
|
||||
debug_assert!(!matches!(t, Token { kind: DocComment(..), .. }));
|
||||
|
||||
// If the token matches, we can just advance the parser. Otherwise, this
|
||||
// match hash failed, there is nothing to do, and hopefully another item in
|
||||
// `cur_items` will match.
|
||||
if token_name_eq(&t, token) {
|
||||
// If it's a doc comment, we just ignore it and move on to the next tt in
|
||||
// the matcher. If the token matches, we can just advance the parser.
|
||||
// Otherwise, this match has failed, there is nothing to do, and hopefully
|
||||
// another item in `cur_items` will match.
|
||||
if matches!(t, Token { kind: DocComment(..), .. }) {
|
||||
item.idx += 1;
|
||||
self.cur_items.push(item);
|
||||
} else if token_name_eq(&t, token) {
|
||||
item.idx += 1;
|
||||
self.next_items.push(item);
|
||||
}
|
||||
@ -677,8 +675,8 @@ impl<'tt> TtParser<'tt> {
|
||||
Ok(nt) => nt,
|
||||
};
|
||||
let m = match nt {
|
||||
Nonterminal::NtTT(tt) => MatchedNtTt(tt),
|
||||
_ => MatchedNtNonTt(Lrc::new(nt)),
|
||||
NtOrTt::Nt(nt) => MatchedNonterminal(Lrc::new(nt)),
|
||||
NtOrTt::Tt(tt) => MatchedTokenTree(tt),
|
||||
};
|
||||
item.push_match(match_cur, m);
|
||||
item.idx += 1;
|
||||
|
@ -4,7 +4,7 @@ use crate::expand::{ensure_complete_parse, parse_ast_fragment, AstFragment, AstF
|
||||
use crate::mbe;
|
||||
use crate::mbe::macro_check;
|
||||
use crate::mbe::macro_parser::{Error, ErrorReported, Failure, Success, TtParser};
|
||||
use crate::mbe::macro_parser::{MatchedNtTt, MatchedSeq};
|
||||
use crate::mbe::macro_parser::{MatchedSeq, MatchedTokenTree};
|
||||
use crate::mbe::transcribe::transcribe;
|
||||
|
||||
use rustc_ast as ast;
|
||||
@ -470,7 +470,7 @@ pub fn compile_declarative_macro(
|
||||
MatchedSeq(ref s) => s
|
||||
.iter()
|
||||
.map(|m| {
|
||||
if let MatchedNtTt(ref tt) = *m {
|
||||
if let MatchedTokenTree(ref tt) = *m {
|
||||
let mut tts = vec![];
|
||||
mbe::quoted::parse(
|
||||
tt.clone().into(),
|
||||
@ -495,7 +495,7 @@ pub fn compile_declarative_macro(
|
||||
MatchedSeq(ref s) => s
|
||||
.iter()
|
||||
.map(|m| {
|
||||
if let MatchedNtTt(ref tt) = *m {
|
||||
if let MatchedTokenTree(ref tt) = *m {
|
||||
let mut tts = vec![];
|
||||
mbe::quoted::parse(
|
||||
tt.clone().into(),
|
||||
|
@ -1,8 +1,8 @@
|
||||
use crate::base::ExtCtxt;
|
||||
use crate::mbe::macro_parser::{MatchedNtNonTt, MatchedNtTt, MatchedSeq, NamedMatch};
|
||||
use crate::mbe::macro_parser::{MatchedNonterminal, MatchedSeq, MatchedTokenTree, NamedMatch};
|
||||
use crate::mbe::{self, MetaVarExpr};
|
||||
use rustc_ast::mut_visit::{self, MutVisitor};
|
||||
use rustc_ast::token::{self, Nonterminal, Token, TokenKind};
|
||||
use rustc_ast::token::{self, Token, TokenKind};
|
||||
use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree, TreeAndSpacing};
|
||||
use rustc_data_structures::fx::FxHashMap;
|
||||
use rustc_data_structures::sync::Lrc;
|
||||
@ -234,17 +234,16 @@ pub(super) fn transcribe<'a>(
|
||||
let ident = MacroRulesNormalizedIdent::new(orignal_ident);
|
||||
if let Some(cur_matched) = lookup_cur_matched(ident, interp, &repeats) {
|
||||
match cur_matched {
|
||||
MatchedNtTt(ref tt) => {
|
||||
MatchedTokenTree(ref tt) => {
|
||||
// `tt`s are emitted into the output stream directly as "raw tokens",
|
||||
// without wrapping them into groups.
|
||||
let token = tt.clone();
|
||||
result.push(token.into());
|
||||
}
|
||||
MatchedNtNonTt(ref nt) => {
|
||||
MatchedNonterminal(ref nt) => {
|
||||
// Other variables are emitted into the output stream as groups with
|
||||
// `Delimiter::None` to maintain parsing priorities.
|
||||
// `Interpolated` is currently used for such groups in rustc parser.
|
||||
debug_assert!(!matches!(**nt, Nonterminal::NtTT(_)));
|
||||
marker.visit_span(&mut sp);
|
||||
let token = TokenTree::token(token::Interpolated(nt.clone()), sp);
|
||||
result.push(token.into());
|
||||
@ -312,7 +311,7 @@ fn lookup_cur_matched<'a>(
|
||||
let mut matched = matched;
|
||||
for &(idx, _) in repeats {
|
||||
match matched {
|
||||
MatchedNtTt(_) | MatchedNtNonTt(_) => break,
|
||||
MatchedTokenTree(_) | MatchedNonterminal(_) => break,
|
||||
MatchedSeq(ref ads) => matched = ads.get(idx).unwrap(),
|
||||
}
|
||||
}
|
||||
@ -402,7 +401,7 @@ fn lockstep_iter_size(
|
||||
let name = MacroRulesNormalizedIdent::new(name);
|
||||
match lookup_cur_matched(name, interpolations, repeats) {
|
||||
Some(matched) => match matched {
|
||||
MatchedNtTt(_) | MatchedNtNonTt(_) => LockstepIterSize::Unconstrained,
|
||||
MatchedTokenTree(_) | MatchedNonterminal(_) => LockstepIterSize::Unconstrained,
|
||||
MatchedSeq(ref ads) => LockstepIterSize::Constraint(ads.len(), name),
|
||||
},
|
||||
_ => LockstepIterSize::Unconstrained,
|
||||
@ -449,7 +448,7 @@ fn count_repetitions<'a>(
|
||||
sp: &DelimSpan,
|
||||
) -> PResult<'a, usize> {
|
||||
match matched {
|
||||
MatchedNtTt(_) | MatchedNtNonTt(_) => {
|
||||
MatchedTokenTree(_) | MatchedNonterminal(_) => {
|
||||
if declared_lhs_depth == 0 {
|
||||
return Err(cx.struct_span_err(
|
||||
sp.entire(),
|
||||
|
@ -290,7 +290,6 @@ pub fn nt_to_tokenstream(
|
||||
Nonterminal::NtMeta(ref attr) => convert_tokens(attr.tokens.as_ref()),
|
||||
Nonterminal::NtPath(ref path) => convert_tokens(path.tokens.as_ref()),
|
||||
Nonterminal::NtVis(ref vis) => convert_tokens(vis.tokens.as_ref()),
|
||||
Nonterminal::NtTT(ref tt) => Some(tt.clone().into()),
|
||||
Nonterminal::NtExpr(ref expr) | Nonterminal::NtLiteral(ref expr) => {
|
||||
prepend_attrs(&expr.attrs, expr.tokens.as_ref())
|
||||
}
|
||||
|
@ -19,7 +19,7 @@ pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
|
||||
pub use path::PathStyle;
|
||||
|
||||
use rustc_ast::ptr::P;
|
||||
use rustc_ast::token::{self, DelimToken, Token, TokenKind};
|
||||
use rustc_ast::token::{self, DelimToken, Nonterminal, Token, TokenKind};
|
||||
use rustc_ast::tokenstream::AttributesData;
|
||||
use rustc_ast::tokenstream::{self, DelimSpan, Spacing};
|
||||
use rustc_ast::tokenstream::{TokenStream, TokenTree};
|
||||
@ -1507,3 +1507,9 @@ pub enum FlatToken {
|
||||
/// handling of replace ranges.
|
||||
Empty,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum NtOrTt {
|
||||
Nt(Nonterminal),
|
||||
Tt(TokenTree),
|
||||
}
|
||||
|
@ -1,12 +1,12 @@
|
||||
use rustc_ast::ptr::P;
|
||||
use rustc_ast::token::{self, Nonterminal, NonterminalKind, Token};
|
||||
use rustc_ast::token::{self, NonterminalKind, Token};
|
||||
use rustc_ast::AstLike;
|
||||
use rustc_ast_pretty::pprust;
|
||||
use rustc_errors::PResult;
|
||||
use rustc_span::symbol::{kw, Ident};
|
||||
|
||||
use crate::parser::pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
|
||||
use crate::parser::{FollowedByType, ForceCollect, Parser, PathStyle};
|
||||
use crate::parser::{FollowedByType, ForceCollect, NtOrTt, Parser, PathStyle};
|
||||
|
||||
impl<'a> Parser<'a> {
|
||||
/// Checks whether a non-terminal may begin with a particular token.
|
||||
@ -85,7 +85,7 @@ impl<'a> Parser<'a> {
|
||||
NonterminalKind::Lifetime => match token.kind {
|
||||
token::Lifetime(_) => true,
|
||||
token::Interpolated(ref nt) => {
|
||||
matches!(**nt, token::NtLifetime(_) | token::NtTT(_))
|
||||
matches!(**nt, token::NtLifetime(_))
|
||||
}
|
||||
_ => false,
|
||||
},
|
||||
@ -96,7 +96,7 @@ impl<'a> Parser<'a> {
|
||||
}
|
||||
|
||||
/// Parse a non-terminal (e.g. MBE `:pat` or `:ident`).
|
||||
pub fn parse_nonterminal(&mut self, kind: NonterminalKind) -> PResult<'a, Nonterminal> {
|
||||
pub fn parse_nonterminal(&mut self, kind: NonterminalKind) -> PResult<'a, NtOrTt> {
|
||||
// Any `Nonterminal` which stores its tokens (currently `NtItem` and `NtExpr`)
|
||||
// needs to have them force-captured here.
|
||||
// A `macro_rules!` invocation may pass a captured item/expr to a proc-macro,
|
||||
@ -104,6 +104,8 @@ impl<'a> Parser<'a> {
|
||||
// in advance whether or not a proc-macro will be (transitively) invoked,
|
||||
// we always capture tokens for any `Nonterminal` which needs them.
|
||||
let mut nt = match kind {
|
||||
// Note that TT is treated differently to all the others.
|
||||
NonterminalKind::TT => return Ok(NtOrTt::Tt(self.parse_token_tree())),
|
||||
NonterminalKind::Item => match self.parse_item(ForceCollect::Yes)? {
|
||||
Some(item) => token::NtItem(item),
|
||||
None => {
|
||||
@ -124,9 +126,12 @@ impl<'a> Parser<'a> {
|
||||
NonterminalKind::PatParam { .. } | NonterminalKind::PatWithOr { .. } => {
|
||||
token::NtPat(self.collect_tokens_no_attrs(|this| match kind {
|
||||
NonterminalKind::PatParam { .. } => this.parse_pat_no_top_alt(None),
|
||||
NonterminalKind::PatWithOr { .. } => {
|
||||
this.parse_pat_allow_top_alt(None, RecoverComma::No, RecoverColon::No, CommaRecoveryMode::EitherTupleOrPipe)
|
||||
}
|
||||
NonterminalKind::PatWithOr { .. } => this.parse_pat_allow_top_alt(
|
||||
None,
|
||||
RecoverComma::No,
|
||||
RecoverColon::No,
|
||||
CommaRecoveryMode::EitherTupleOrPipe,
|
||||
),
|
||||
_ => unreachable!(),
|
||||
})?)
|
||||
}
|
||||
@ -139,9 +144,10 @@ impl<'a> Parser<'a> {
|
||||
)
|
||||
}
|
||||
|
||||
NonterminalKind::Ty => {
|
||||
token::NtTy(self.collect_tokens_no_attrs(|this| this.parse_no_question_mark_recover())?)
|
||||
}
|
||||
NonterminalKind::Ty => token::NtTy(
|
||||
self.collect_tokens_no_attrs(|this| this.parse_no_question_mark_recover())?,
|
||||
),
|
||||
|
||||
// this could be handled like a token, since it is one
|
||||
NonterminalKind::Ident
|
||||
if let Some((ident, is_raw)) = get_macro_ident(&self.token) =>
|
||||
@ -158,7 +164,6 @@ impl<'a> Parser<'a> {
|
||||
self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?,
|
||||
),
|
||||
NonterminalKind::Meta => token::NtMeta(P(self.parse_attr_item(true)?)),
|
||||
NonterminalKind::TT => token::NtTT(self.parse_token_tree()),
|
||||
NonterminalKind::Vis => token::NtVis(
|
||||
self.collect_tokens_no_attrs(|this| this.parse_visibility(FollowedByType::Yes))?,
|
||||
),
|
||||
@ -183,7 +188,7 @@ impl<'a> Parser<'a> {
|
||||
);
|
||||
}
|
||||
|
||||
Ok(nt)
|
||||
Ok(NtOrTt::Nt(nt))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -696,14 +696,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
|
||||
) = &bounded_ty.kind
|
||||
{
|
||||
// use this to verify that ident is a type param.
|
||||
let Ok(Some(partial_res)) = self.resolve_qpath_anywhere(
|
||||
None,
|
||||
&Segment::from_path(path),
|
||||
Namespace::TypeNS,
|
||||
span,
|
||||
true,
|
||||
Finalize::No,
|
||||
) else {
|
||||
let Some(partial_res) = self.r.partial_res_map.get(&bounded_ty.id) else {
|
||||
return false;
|
||||
};
|
||||
if !(matches!(
|
||||
@ -718,16 +711,10 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
|
||||
return false;
|
||||
};
|
||||
|
||||
if let ast::TyKind::Path(None, type_param_path) = &ty.peel_refs().kind {
|
||||
let peeled_ty = ty.peel_refs();
|
||||
if let ast::TyKind::Path(None, type_param_path) = &peeled_ty.kind {
|
||||
// Confirm that the `SelfTy` is a type parameter.
|
||||
let Ok(Some(partial_res)) = self.resolve_qpath_anywhere(
|
||||
None,
|
||||
&Segment::from_path(type_param_path),
|
||||
Namespace::TypeNS,
|
||||
span,
|
||||
true,
|
||||
Finalize::No,
|
||||
) else {
|
||||
let Some(partial_res) = self.r.partial_res_map.get(&peeled_ty.id) else {
|
||||
return false;
|
||||
};
|
||||
if !(matches!(
|
||||
|
@ -231,10 +231,10 @@ impl StepDescription {
|
||||
}
|
||||
|
||||
if !builder.config.exclude.is_empty() {
|
||||
eprintln!(
|
||||
builder.verbose(&format!(
|
||||
"{:?} not skipped for {:?} -- not in {:?}",
|
||||
pathset, self.name, builder.config.exclude
|
||||
);
|
||||
));
|
||||
}
|
||||
false
|
||||
}
|
||||
|
@ -1,9 +0,0 @@
|
||||
pub struct XEmpty1 {}
|
||||
pub struct XEmpty2;
|
||||
pub struct XEmpty6();
|
||||
|
||||
pub enum XE {
|
||||
XEmpty3 {},
|
||||
XEmpty4,
|
||||
XEmpty5(),
|
||||
}
|
@ -1,5 +0,0 @@
|
||||
// compile-flags:--cfg foo
|
||||
|
||||
#![cfg_attr(foo, unstable(feature = "unstable_test_feature", issue = "none"))]
|
||||
#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))]
|
||||
#![feature(staged_api)]
|
@ -1,22 +0,0 @@
|
||||
// no-prefer-dynamic
|
||||
|
||||
// This aux-file will require the eh_personality function to be codegen'd, but
|
||||
// it hasn't been defined just yet. Make sure we don't explode.
|
||||
|
||||
#![no_std]
|
||||
#![crate_type = "rlib"]
|
||||
|
||||
struct A;
|
||||
|
||||
impl core::ops::Drop for A {
|
||||
fn drop(&mut self) {}
|
||||
}
|
||||
|
||||
pub fn foo() {
|
||||
let _a = A;
|
||||
panic!("wut");
|
||||
}
|
||||
|
||||
mod std {
|
||||
pub use core::{option, fmt};
|
||||
}
|
@ -1,9 +0,0 @@
|
||||
pub struct Foo {
|
||||
pub x: isize
|
||||
}
|
||||
|
||||
impl Foo {
|
||||
pub fn new() -> Foo {
|
||||
Foo { x: 3 }
|
||||
}
|
||||
}
|
@ -1,3 +0,0 @@
|
||||
#![crate_type="lib"]
|
||||
|
||||
pub struct Au(pub isize);
|
@ -1,28 +0,0 @@
|
||||
#![crate_type = "lib"]
|
||||
|
||||
// used by the rpass test
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Struct;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum Unit {
|
||||
UnitVariant,
|
||||
Argument(Struct)
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct TupleStruct(pub usize, pub &'static str);
|
||||
|
||||
// used by the cfail test
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct StructWithFields {
|
||||
foo: isize,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum EnumWithVariants {
|
||||
EnumVariant,
|
||||
EnumVariantArg(isize)
|
||||
}
|
@ -1,9 +0,0 @@
|
||||
pub struct XEmpty1 {}
|
||||
pub struct XEmpty2;
|
||||
pub struct XEmpty6();
|
||||
|
||||
pub enum XE {
|
||||
XEmpty3 {},
|
||||
XEmpty4,
|
||||
XEmpty5(),
|
||||
}
|
@ -1,4 +0,0 @@
|
||||
fn main() {
|
||||
let ref my_ref @ _ = 0;
|
||||
*my_ref = 0; //~ ERROR cannot assign to `*my_ref`, which is behind a `&` reference [E0594]
|
||||
}
|
@ -1,11 +0,0 @@
|
||||
error[E0594]: cannot assign to `*my_ref`, which is behind a `&` reference
|
||||
--> $DIR/issue-51244.rs:3:5
|
||||
|
|
||||
LL | let ref my_ref @ _ = 0;
|
||||
| -------------- help: consider changing this to be a mutable reference: `ref mut my_ref @ _`
|
||||
LL | *my_ref = 0;
|
||||
| ^^^^^^^^^^^ `my_ref` is a `&` reference, so the data it refers to cannot be written
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
For more information about this error, try `rustc --explain E0594`.
|
13
src/test/ui/macros/issue-95267.rs
Normal file
13
src/test/ui/macros/issue-95267.rs
Normal file
@ -0,0 +1,13 @@
|
||||
// check-pass
|
||||
|
||||
// This is a valid macro. Commit 4 in #95159 broke things such that it failed
|
||||
// with a "missing tokens in macro arguments" error, as reported in #95267.
|
||||
macro_rules! f {
|
||||
(
|
||||
/// ab
|
||||
) => {};
|
||||
}
|
||||
|
||||
fn main() {
|
||||
f!();
|
||||
}
|
@ -1,39 +0,0 @@
|
||||
// Various examples of structs whose fields are not well-formed.
|
||||
|
||||
#![allow(dead_code)]
|
||||
|
||||
trait Dummy<'a> {
|
||||
type Out;
|
||||
}
|
||||
impl<'a, T> Dummy<'a> for T
|
||||
where
|
||||
T: 'a,
|
||||
{
|
||||
type Out = ();
|
||||
}
|
||||
type RequireOutlives<'a, T> = <T as Dummy<'a>>::Out;
|
||||
|
||||
enum Ref1<'a, T> {
|
||||
Ref1Variant1(RequireOutlives<'a, T>), //~ ERROR the parameter type `T` may not live long enough
|
||||
}
|
||||
|
||||
enum Ref2<'a, T> {
|
||||
Ref2Variant1,
|
||||
Ref2Variant2(isize, RequireOutlives<'a, T>), //~ ERROR the parameter type `T` may not live long enough
|
||||
}
|
||||
|
||||
enum RefOk<'a, T: 'a> {
|
||||
RefOkVariant1(&'a T),
|
||||
}
|
||||
|
||||
// This is now well formed. RFC 2093
|
||||
enum RefIndirect<'a, T> {
|
||||
RefIndirectVariant1(isize, RefOk<'a, T>),
|
||||
}
|
||||
|
||||
enum RefDouble<'a, 'b, T> {
|
||||
RefDoubleVariant1(&'a RequireOutlives<'b, T>),
|
||||
//~^ the parameter type `T` may not live long enough [E0309]
|
||||
}
|
||||
|
||||
fn main() {}
|
@ -1,28 +0,0 @@
|
||||
error[E0309]: the parameter type `T` may not live long enough
|
||||
--> $DIR/regions-enum-not-wf.rs:17:18
|
||||
|
|
||||
LL | enum Ref1<'a, T> {
|
||||
| - help: consider adding an explicit lifetime bound...: `T: 'a`
|
||||
LL | Ref1Variant1(RequireOutlives<'a, T>),
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
||||
|
||||
error[E0309]: the parameter type `T` may not live long enough
|
||||
--> $DIR/regions-enum-not-wf.rs:22:25
|
||||
|
|
||||
LL | enum Ref2<'a, T> {
|
||||
| - help: consider adding an explicit lifetime bound...: `T: 'a`
|
||||
LL | Ref2Variant1,
|
||||
LL | Ref2Variant2(isize, RequireOutlives<'a, T>),
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
||||
|
||||
error[E0309]: the parameter type `T` may not live long enough
|
||||
--> $DIR/regions-enum-not-wf.rs:35:23
|
||||
|
|
||||
LL | enum RefDouble<'a, 'b, T> {
|
||||
| - help: consider adding an explicit lifetime bound...: `T: 'b`
|
||||
LL | RefDoubleVariant1(&'a RequireOutlives<'b, T>),
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
||||
|
||||
error: aborting due to 3 previous errors
|
||||
|
||||
For more information about this error, try `rustc --explain E0309`.
|
@ -62,7 +62,7 @@ LL | if true || let 0 = 0 {}
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:47:13
|
||||
|
|
||||
LL | if true || let 0 = 0 {}
|
||||
@ -76,7 +76,7 @@ LL | if (true || let 0 = 0) {}
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:48:14
|
||||
|
|
||||
LL | if (true || let 0 = 0) {}
|
||||
@ -90,7 +90,7 @@ LL | if true && (true || let 0 = 0) {}
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:49:22
|
||||
|
|
||||
LL | if true && (true || let 0 = 0) {}
|
||||
@ -104,7 +104,7 @@ LL | if true || (true && let 0 = 0) {}
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:50:13
|
||||
|
|
||||
LL | if true || (true && let 0 = 0) {}
|
||||
@ -244,7 +244,7 @@ LL | while true || let 0 = 0 {}
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:111:16
|
||||
|
|
||||
LL | while true || let 0 = 0 {}
|
||||
@ -258,7 +258,7 @@ LL | while (true || let 0 = 0) {}
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:112:17
|
||||
|
|
||||
LL | while (true || let 0 = 0) {}
|
||||
@ -272,7 +272,7 @@ LL | while true && (true || let 0 = 0) {}
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:113:25
|
||||
|
|
||||
LL | while true && (true || let 0 = 0) {}
|
||||
@ -286,7 +286,7 @@ LL | while true || (true && let 0 = 0) {}
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:114:16
|
||||
|
|
||||
LL | while true || (true && let 0 = 0) {}
|
||||
@ -426,7 +426,7 @@ LL | true || let 0 = 0;
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:184:10
|
||||
|
|
||||
LL | true || let 0 = 0;
|
||||
@ -440,7 +440,7 @@ LL | (true || let 0 = 0);
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:185:11
|
||||
|
|
||||
LL | (true || let 0 = 0);
|
||||
@ -454,7 +454,7 @@ LL | true && (true || let 0 = 0);
|
||||
|
|
||||
= note: only supported directly in conditions of `if` and `while` expressions
|
||||
= note: as well as when nested within `&&` and parentheses in those conditions
|
||||
note: `||` operators are not allowed in let chain expressions
|
||||
note: `||` operators are not currently supported in let chain expressions
|
||||
--> $DIR/disallowed-positions.rs:186:19
|
||||
|
|
||||
LL | true && (true || let 0 = 0);
|
||||
|
@ -1,6 +0,0 @@
|
||||
fn main() {
|
||||
let f = |x| x * 3;
|
||||
let a = f(); //~ ERROR E0057
|
||||
let b = f(4);
|
||||
let c = f(2, 3); //~ ERROR E0057
|
||||
}
|
@ -1,19 +0,0 @@
|
||||
error[E0057]: this function takes 1 argument but 0 arguments were supplied
|
||||
--> $DIR/E0057.rs:3:13
|
||||
|
|
||||
LL | let a = f();
|
||||
| ^-- supplied 0 arguments
|
||||
| |
|
||||
| expected 1 argument
|
||||
|
||||
error[E0057]: this function takes 1 argument but 2 arguments were supplied
|
||||
--> $DIR/E0057.rs:5:13
|
||||
|
|
||||
LL | let c = f(2, 3);
|
||||
| ^ - - supplied 2 arguments
|
||||
| |
|
||||
| expected 1 argument
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
|
||||
For more information about this error, try `rustc --explain E0057`.
|
@ -1,9 +0,0 @@
|
||||
pub struct A {
|
||||
a: isize,
|
||||
pub b: isize,
|
||||
}
|
||||
|
||||
pub struct B {
|
||||
pub a: isize,
|
||||
b: isize,
|
||||
}
|
@ -16,4 +16,8 @@ fn foo<T: Bar>(_: T) where <T as Bar>::Baz: String { //~ ERROR expected trait, f
|
||||
fn qux<'a, T: Bar>(_: &'a T) where <&'a T as Bar>::Baz: String { //~ ERROR expected trait, found
|
||||
}
|
||||
|
||||
fn issue_95327() where <u8 as Unresolved>::Assoc: String {}
|
||||
//~^ ERROR expected trait, found struct
|
||||
//~| ERROR use of undeclared type `Unresolved`
|
||||
|
||||
fn main() {}
|
||||
|
@ -1,3 +1,9 @@
|
||||
error[E0433]: failed to resolve: use of undeclared type `Unresolved`
|
||||
--> $DIR/assoc_type_bound_with_struct.rs:19:31
|
||||
|
|
||||
LL | fn issue_95327() where <u8 as Unresolved>::Assoc: String {}
|
||||
| ^^^^^^^^^^ use of undeclared type `Unresolved`
|
||||
|
||||
error[E0404]: expected trait, found struct `String`
|
||||
--> $DIR/assoc_type_bound_with_struct.rs:5:46
|
||||
|
|
||||
@ -78,6 +84,18 @@ help: a trait with a similar name exists
|
||||
LL | fn qux<'a, T: Bar>(_: &'a T) where <&'a T as Bar>::Baz: ToString {
|
||||
| ~~~~~~~~
|
||||
|
||||
error: aborting due to 4 previous errors
|
||||
error[E0404]: expected trait, found struct `String`
|
||||
--> $DIR/assoc_type_bound_with_struct.rs:19:51
|
||||
|
|
||||
LL | fn issue_95327() where <u8 as Unresolved>::Assoc: String {}
|
||||
| ^^^^^^ help: a trait with a similar name exists: `ToString`
|
||||
|
|
||||
::: $SRC_DIR/alloc/src/string.rs:LL:COL
|
||||
|
|
||||
LL | pub trait ToString {
|
||||
| ------------------ similarly named trait `ToString` defined here
|
||||
|
||||
For more information about this error, try `rustc --explain E0404`.
|
||||
error: aborting due to 6 previous errors
|
||||
|
||||
Some errors have detailed explanations: E0404, E0433.
|
||||
For more information about an error, try `rustc --explain E0404`.
|
||||
|
Loading…
Reference in New Issue
Block a user