Auto merge of #148762 - matthiaskrgr:rollup-4oifvkr, r=matthiaskrgr

Rollup of 4 pull requests
Successful merges:
- #148248 (Constify `ControlFlow` methods without unstable bounds)
- #148285 (Constify `ControlFlow` methods with unstable bounds)
- #148510 (compiletest: Do the known-directives check only once, and improve its error message)
- #148655 (Fix invalid macro tag generation for keywords which can be followed by values)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

library/core/src/ops/control_flow.rs

@@ -1,3 +1,4 @@
+usecrate::marker::Destruct;
 usecrate::{convert, ops};
 
 /// Used to tell an operation whether it should exit early or go on as usual.
@@ -150,7 +151,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_break(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_break(&self) -> bool{
 matches!(*self,ControlFlow::Break(_))
 }
 
@@ -166,7 +168,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_continue(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_continue(&self) -> bool{
 matches!(*self,ControlFlow::Continue(_))
 }
 
@@ -183,7 +186,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnbreak_value(self) -> Option<B>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfnbreak_value(self) -> Option<B>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(..) => None,
 ControlFlow::Break(x) => Some(x),
@@ -257,7 +264,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfnbreak_ok(self) -> Result<B,C>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnbreak_ok(self) -> Result<B,C>{
 matchself{
 ControlFlow::Continue(c) => Err(c),
 ControlFlow::Break(b) => Ok(b),
@@ -268,7 +276,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the break value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_break<T>(self,f:implFnOnce(B) -> T) -> ControlFlow<T,C>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfn map_break<T,F>(self,f:F) -> ControlFlow<T,C>
+where
+F:[const]FnOnce(B) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(x),
 ControlFlow::Break(x) => ControlFlow::Break(f(x)),
@@ -288,7 +300,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
  #[inline]
  #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfncontinue_value(self) -> Option<C>{
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfncontinue_value(self) -> Option<C>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => Some(x),
 ControlFlow::Break(..) => None,
@@ -361,7 +377,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfncontinue_ok(self) -> Result<C,B>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub constfncontinue_ok(self) -> Result<C,B>{
 matchself{
 ControlFlow::Continue(c) => Ok(c),
 ControlFlow::Break(b) => Err(b),
@@ -372,7 +389,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the continue value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_continue<T>(self,f:implFnOnce(C) -> T) -> ControlFlow<B,T>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfnmap_continue<T,F>(self,f:F) -> ControlFlow<B,T>
+where
+F:[const]FnOnce(C) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
 ControlFlow::Break(x) => ControlFlow::Break(x),

src/librustdoc/html/highlight.rs

@@ -789,6 +789,9 @@ impl<'a> Iterator for TokenIter<'a> {
 }
 }
 
+/// Used to know if a keyword followed by a `!` should never be treated as a macro.
+constNON_MACRO_KEYWORDS:&[&str] = &["if","while","match","break","return","impl"];
+
 /// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
 /// just the next item by using `peek_next`. The `peek` method always returns the next item after
 /// the current one whereas `peek_next` will return the next item after the last one peeked.
@@ -1010,6 +1013,19 @@ impl<'src> Classifier<'src> {
 }
 }
 
+fnnew_macro_span(
+&mutself,
+text:&'srcstr,
+sink:&mutdynFnMut(Span,Highlight<'src>),
+before:u32,
+file_span:Span,
+){
+self.in_macro = true;
+let span = new_span(before, text, file_span);
+sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
+sink(span,Highlight::Token{ text,class:None});
+}
+
 /// Single step of highlighting. This will classify `token`, but maybe also a couple of
 /// following ones as well.
 ///
@@ -1216,16 +1232,46 @@ impl<'src> Classifier<'src> {
 LiteralKind::Float{ .. } | LiteralKind::Int{ .. } => Class::Number,
 },
 TokenKind::GuardedStrPrefix => returnno_highlight(sink),
-TokenKind::Ident | TokenKind::RawIdent
-ifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() =>
-{
-self.in_macro = true;
-let span = new_span(before, text, file_span);
-sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
-sink(span,Highlight::Token{ text,class:None});
+TokenKind::RawIdentifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() => {
+self.new_macro_span(text, sink, before, file_span);
 return;
 }
-TokenKind::Ident => self.classify_ident(before, text),
+// Macro non-terminals (meta vars) take precedence.
+TokenKind::Identifself.in_macro_nonterminal => {
+self.in_macro_nonterminal = false;
+Class::MacroNonTerminal
+}
+TokenKind::Ident => {
+let file_span = self.file_span;
+let span = || new_span(before, text, file_span);
+
+match text {
+"ref" | "mut" => Class::RefKeyWord,
+"false" | "true" => Class::Bool,
+"self" | "Self" => Class::Self_(span()),
+"Option" | "Result" => Class::PreludeTy(span()),
+"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
+ _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => {
+// So if it's not a keyword which can be followed by a value (like `if` or
+// `return`) and the next non-whitespace token is a `!`, then we consider
+// it's a macro.
+if !NON_MACRO_KEYWORDS.contains(&text)
+ && matches!(self.peek_non_trivia(),Some((TokenKind::Bang, _)))
+{
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+Class::KeyWord
+}
+// If it's not a keyword and the next non whitespace token is a `!`, then
+// we consider it's a macro.
+ _ ifmatches!(self.peek_non_trivia(),Some((TokenKind::Bang, _))) => {
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+ _ => Class::Ident(span()),
+}
+}
 TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
 Class::Ident(new_span(before, text, file_span))
 }
@@ -1246,27 +1292,6 @@ impl<'src> Classifier<'src> {
 }
 }
 
-fnclassify_ident(&mutself,before:u32,text:&'srcstr) -> Class{
-// Macro non-terminals (meta vars) take precedence.
-ifself.in_macro_nonterminal{
-self.in_macro_nonterminal = false;
-returnClass::MacroNonTerminal;
-}
-
-let file_span = self.file_span;
-let span = || new_span(before, text, file_span);
-
-match text {
-"ref" | "mut" => Class::RefKeyWord,
-"false" | "true" => Class::Bool,
-"self" | "Self" => Class::Self_(span()),
-"Option" | "Result" => Class::PreludeTy(span()),
-"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
- _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
-}
-}
-
 fnis_weak_keyword(&mutself,text:&str) -> bool{
 // NOTE: `yeet` (`do yeet $expr`), `catch` (`do catch $block`), `default` (specialization),
 // `contract_{ensures,requires}`, `builtin` (builtin_syntax) & `reuse` (fn_delegation) are

src/tools/compiletest/src/directives.rs

@@ -11,7 +11,7 @@ use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 pub(crate)usecrate::directives::auxiliary::AuxProps;
 usecrate::directives::auxiliary::parse_and_update_aux;
 usecrate::directives::directive_names::{
-KNOWN_DIRECTIVE_NAMES,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+KNOWN_DIRECTIVE_NAMES_SET,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate)usecrate::directives::file::FileDirectives;
 usecrate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
 config:&Config,
 file_directives:&FileDirectives<'_>,
 ) -> Self{
-let testfile = file_directives.path;
 letmut props = EarlyProps::default();
-letmut poisoned = false;
 
 iter_directives(
  config.mode,
-&mut poisoned,
  file_directives,
 // (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
  config.parse_and_update_revisions(ln,&mut props.revisions);
 },
 );
 
-if poisoned {
-eprintln!("errors encountered during EarlyProps parsing: {}", testfile);
-panic!("errors encountered during EarlyProps parsing");
-}
-
  props
 }
 }
@@ -358,12 +350,10 @@ impl TestProps {
 let file_contents = fs::read_to_string(testfile).unwrap();
 let file_directives = FileDirectives::from_file_contents(testfile,&file_contents);
 
-letmut poisoned = false;
-
 iter_directives(
  config.mode,
-&mut poisoned,
 &file_directives,
+// (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
 if !ln.applies_to_test_revision(test_revision){
 return;
@@ -634,11 +624,6 @@ impl TestProps {
 );
 },
 );
-
-if poisoned {
-eprintln!("errors encountered during TestProps parsing: {}", testfile);
-panic!("errors encountered during TestProps parsing");
-}
 }
 
 ifself.should_ice{
@@ -775,6 +760,34 @@ impl TestProps {
 }
 }
 
+pub(crate)fndo_early_directives_check(
+mode:TestMode,
+file_directives:&FileDirectives<'_>,
+) -> Result<(),String>{
+let testfile = file_directives.path;
+
+for directive_line @ DirectiveLine{ line_number, .. }in&file_directives.lines{
+letCheckDirectiveResult{ is_known_directive, trailing_directive } =
+check_directive(directive_line, mode);
+
+if !is_known_directive {
+returnErr(format!(
+"ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+));
+}
+
+ifletSome(trailing_directive) = &trailing_directive {
+returnErr(format!(
+"ERROR: detected trailing compiletest directive `{trailing_directive}` at {testfile}:{line_number}\n\
+ HELP: put the directive on its own line: `//@ {trailing_directive}`"
+));
+}
+}
+
+Ok(())
+}
+
 pub(crate)structCheckDirectiveResult<'ln>{
 is_known_directive:bool,
 trailing_directive:Option<&'lnstr>,
@@ -786,7 +799,7 @@ fn check_directive<'a>(
 ) -> CheckDirectiveResult<'a>{
 let&DirectiveLine{name: directive_name, .. } = directive_ln;
 
-let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
  || match mode {
 TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
 TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
@@ -799,7 +812,7 @@ fn check_directive<'a>(
 let trailing_directive = directive_ln
 .remark_after_space()
 .map(|remark| remark.trim_start().split(' ').next().unwrap())
-.filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
+.filter(|token| KNOWN_DIRECTIVE_NAMES_SET.contains(token));
 
 // FIXME(Zalathar): Consider emitting specialized error/help messages for
 // bogus directive names that are similar to real ones, e.g.:
@@ -811,7 +824,6 @@ fn check_directive<'a>(
 
 fniter_directives(
 mode:TestMode,
-poisoned:&mutbool,
 file_directives:&FileDirectives<'_>,
 it:&mutdynFnMut(&DirectiveLine<'_>),
 ){
@@ -837,36 +849,7 @@ fn iter_directives(
 }
 }
 
-for directive_line @ &DirectiveLine{ line_number, .. }in&file_directives.lines{
-// Perform unknown directive check on Rust files.
-if testfile.extension() == Some("rs"){
-letCheckDirectiveResult{ is_known_directive, trailing_directive } =
-check_directive(directive_line, mode);
-
-if !is_known_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
- directive_line.display(),
-);
-
-return;
-}
-
-ifletSome(trailing_directive) = &trailing_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
- trailing_directive,
-);
-help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
-
-return;
-}
-}
-
+for directive_line in&file_directives.lines{
 it(directive_line);
 }
 }
@@ -1304,12 +1287,9 @@ pub(crate) fn make_test_description(
 letmut ignore_message = None;
 letmut should_fail = false;
 
-letmut local_poisoned = false;
-
 // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
 iter_directives(
  config.mode,
-&mut local_poisoned,
  file_directives,
 &mut |ln @ &DirectiveLine{ line_number, .. }| {
 if !ln.applies_to_test_revision(test_revision){
@@ -1358,11 +1338,6 @@ pub(crate) fn make_test_description(
 },
 );
 
-if local_poisoned {
-eprintln!("errors encountered when trying to make test description: {}", path);
-panic!("errors encountered when trying to make test description");
-}
-
 // The `should-fail` annotation doesn't apply to pretty tests,
 // since we run the pretty printer across all tests by default.
 // If desired, we could add a `should-fail-pretty` annotation.

library/core/src/ops/control_flow.rs

@@ -1,3 +1,4 @@
+usecrate::marker::Destruct;
 usecrate::{convert, ops};
 
 /// Used to tell an operation whether it should exit early or go on as usual.
@@ -150,7 +151,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_break(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_break(&self) -> bool{
 matches!(*self,ControlFlow::Break(_))
 }
 
@@ -166,7 +168,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_continue(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_continue(&self) -> bool{
 matches!(*self,ControlFlow::Continue(_))
 }
 
@@ -183,7 +186,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnbreak_value(self) -> Option<B>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfnbreak_value(self) -> Option<B>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(..) => None,
 ControlFlow::Break(x) => Some(x),
@@ -257,7 +264,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfnbreak_ok(self) -> Result<B,C>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnbreak_ok(self) -> Result<B,C>{
 matchself{
 ControlFlow::Continue(c) => Err(c),
 ControlFlow::Break(b) => Ok(b),
@@ -268,7 +276,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the break value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_break<T>(self,f:implFnOnce(B) -> T) -> ControlFlow<T,C>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfn map_break<T,F>(self,f:F) -> ControlFlow<T,C>
+where
+F:[const]FnOnce(B) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(x),
 ControlFlow::Break(x) => ControlFlow::Break(f(x)),
@@ -288,7 +300,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
  #[inline]
  #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfncontinue_value(self) -> Option<C>{
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfncontinue_value(self) -> Option<C>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => Some(x),
 ControlFlow::Break(..) => None,
@@ -361,7 +377,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfncontinue_ok(self) -> Result<C,B>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub constfncontinue_ok(self) -> Result<C,B>{
 matchself{
 ControlFlow::Continue(c) => Ok(c),
 ControlFlow::Break(b) => Err(b),
@@ -372,7 +389,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the continue value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_continue<T>(self,f:implFnOnce(C) -> T) -> ControlFlow<B,T>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfnmap_continue<T,F>(self,f:F) -> ControlFlow<B,T>
+where
+F:[const]FnOnce(C) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
 ControlFlow::Break(x) => ControlFlow::Break(x),

src/librustdoc/html/highlight.rs

@@ -789,6 +789,9 @@ impl<'a> Iterator for TokenIter<'a> {
 }
 }
 
+/// Used to know if a keyword followed by a `!` should never be treated as a macro.
+constNON_MACRO_KEYWORDS:&[&str] = &["if","while","match","break","return","impl"];
+
 /// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
 /// just the next item by using `peek_next`. The `peek` method always returns the next item after
 /// the current one whereas `peek_next` will return the next item after the last one peeked.
@@ -1010,6 +1013,19 @@ impl<'src> Classifier<'src> {
 }
 }
 
+fnnew_macro_span(
+&mutself,
+text:&'srcstr,
+sink:&mutdynFnMut(Span,Highlight<'src>),
+before:u32,
+file_span:Span,
+){
+self.in_macro = true;
+let span = new_span(before, text, file_span);
+sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
+sink(span,Highlight::Token{ text,class:None});
+}
+
 /// Single step of highlighting. This will classify `token`, but maybe also a couple of
 /// following ones as well.
 ///
@@ -1216,16 +1232,46 @@ impl<'src> Classifier<'src> {
 LiteralKind::Float{ .. } | LiteralKind::Int{ .. } => Class::Number,
 },
 TokenKind::GuardedStrPrefix => returnno_highlight(sink),
-TokenKind::Ident | TokenKind::RawIdent
-ifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() =>
-{
-self.in_macro = true;
-let span = new_span(before, text, file_span);
-sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
-sink(span,Highlight::Token{ text,class:None});
+TokenKind::RawIdentifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() => {
+self.new_macro_span(text, sink, before, file_span);
 return;
 }
-TokenKind::Ident => self.classify_ident(before, text),
+// Macro non-terminals (meta vars) take precedence.
+TokenKind::Identifself.in_macro_nonterminal => {
+self.in_macro_nonterminal = false;
+Class::MacroNonTerminal
+}
+TokenKind::Ident => {
+let file_span = self.file_span;
+let span = || new_span(before, text, file_span);
+
+match text {
+"ref" | "mut" => Class::RefKeyWord,
+"false" | "true" => Class::Bool,
+"self" | "Self" => Class::Self_(span()),
+"Option" | "Result" => Class::PreludeTy(span()),
+"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
+ _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => {
+// So if it's not a keyword which can be followed by a value (like `if` or
+// `return`) and the next non-whitespace token is a `!`, then we consider
+// it's a macro.
+if !NON_MACRO_KEYWORDS.contains(&text)
+ && matches!(self.peek_non_trivia(),Some((TokenKind::Bang, _)))
+{
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+Class::KeyWord
+}
+// If it's not a keyword and the next non whitespace token is a `!`, then
+// we consider it's a macro.
+ _ ifmatches!(self.peek_non_trivia(),Some((TokenKind::Bang, _))) => {
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+ _ => Class::Ident(span()),
+}
+}
 TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
 Class::Ident(new_span(before, text, file_span))
 }
@@ -1246,27 +1292,6 @@ impl<'src> Classifier<'src> {
 }
 }
 
-fnclassify_ident(&mutself,before:u32,text:&'srcstr) -> Class{
-// Macro non-terminals (meta vars) take precedence.
-ifself.in_macro_nonterminal{
-self.in_macro_nonterminal = false;
-returnClass::MacroNonTerminal;
-}
-
-let file_span = self.file_span;
-let span = || new_span(before, text, file_span);
-
-match text {
-"ref" | "mut" => Class::RefKeyWord,
-"false" | "true" => Class::Bool,
-"self" | "Self" => Class::Self_(span()),
-"Option" | "Result" => Class::PreludeTy(span()),
-"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
- _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
-}
-}
-
 fnis_weak_keyword(&mutself,text:&str) -> bool{
 // NOTE: `yeet` (`do yeet $expr`), `catch` (`do catch $block`), `default` (specialization),
 // `contract_{ensures,requires}`, `builtin` (builtin_syntax) & `reuse` (fn_delegation) are

src/tools/compiletest/src/directives.rs

@@ -11,7 +11,7 @@ use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 pub(crate)usecrate::directives::auxiliary::AuxProps;
 usecrate::directives::auxiliary::parse_and_update_aux;
 usecrate::directives::directive_names::{
-KNOWN_DIRECTIVE_NAMES,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+KNOWN_DIRECTIVE_NAMES_SET,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate)usecrate::directives::file::FileDirectives;
 usecrate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
 config:&Config,
 file_directives:&FileDirectives<'_>,
 ) -> Self{
-let testfile = file_directives.path;
 letmut props = EarlyProps::default();
-letmut poisoned = false;
 
 iter_directives(
  config.mode,
-&mut poisoned,
  file_directives,
 // (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
  config.parse_and_update_revisions(ln,&mut props.revisions);
 },
 );
 
-if poisoned {
-eprintln!("errors encountered during EarlyProps parsing: {}", testfile);
-panic!("errors encountered during EarlyProps parsing");
-}
-
  props
 }
 }
@@ -358,12 +350,10 @@ impl TestProps {
 let file_contents = fs::read_to_string(testfile).unwrap();
 let file_directives = FileDirectives::from_file_contents(testfile,&file_contents);
 
-letmut poisoned = false;
-
 iter_directives(
  config.mode,
-&mut poisoned,
 &file_directives,
+// (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
 if !ln.applies_to_test_revision(test_revision){
 return;
@@ -634,11 +624,6 @@ impl TestProps {
 );
 },
 );
-
-if poisoned {
-eprintln!("errors encountered during TestProps parsing: {}", testfile);
-panic!("errors encountered during TestProps parsing");
-}
 }
 
 ifself.should_ice{
@@ -775,6 +760,34 @@ impl TestProps {
 }
 }
 
+pub(crate)fndo_early_directives_check(
+mode:TestMode,
+file_directives:&FileDirectives<'_>,
+) -> Result<(),String>{
+let testfile = file_directives.path;
+
+for directive_line @ DirectiveLine{ line_number, .. }in&file_directives.lines{
+letCheckDirectiveResult{ is_known_directive, trailing_directive } =
+check_directive(directive_line, mode);
+
+if !is_known_directive {
+returnErr(format!(
+"ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+));
+}
+
+ifletSome(trailing_directive) = &trailing_directive {
+returnErr(format!(
+"ERROR: detected trailing compiletest directive `{trailing_directive}` at {testfile}:{line_number}\n\
+ HELP: put the directive on its own line: `//@ {trailing_directive}`"
+));
+}
+}
+
+Ok(())
+}
+
 pub(crate)structCheckDirectiveResult<'ln>{
 is_known_directive:bool,
 trailing_directive:Option<&'lnstr>,
@@ -786,7 +799,7 @@ fn check_directive<'a>(
 ) -> CheckDirectiveResult<'a>{
 let&DirectiveLine{name: directive_name, .. } = directive_ln;
 
-let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
  || match mode {
 TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
 TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
@@ -799,7 +812,7 @@ fn check_directive<'a>(
 let trailing_directive = directive_ln
 .remark_after_space()
 .map(|remark| remark.trim_start().split(' ').next().unwrap())
-.filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
+.filter(|token| KNOWN_DIRECTIVE_NAMES_SET.contains(token));
 
 // FIXME(Zalathar): Consider emitting specialized error/help messages for
 // bogus directive names that are similar to real ones, e.g.:
@@ -811,7 +824,6 @@ fn check_directive<'a>(
 
 fniter_directives(
 mode:TestMode,
-poisoned:&mutbool,
 file_directives:&FileDirectives<'_>,
 it:&mutdynFnMut(&DirectiveLine<'_>),
 ){
@@ -837,36 +849,7 @@ fn iter_directives(
 }
 }
 
-for directive_line @ &DirectiveLine{ line_number, .. }in&file_directives.lines{
-// Perform unknown directive check on Rust files.
-if testfile.extension() == Some("rs"){
-letCheckDirectiveResult{ is_known_directive, trailing_directive } =
-check_directive(directive_line, mode);
-
-if !is_known_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
- directive_line.display(),
-);
-
-return;
-}
-
-ifletSome(trailing_directive) = &trailing_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
- trailing_directive,
-);
-help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
-
-return;
-}
-}
-
+for directive_line in&file_directives.lines{
 it(directive_line);
 }
 }
@@ -1304,12 +1287,9 @@ pub(crate) fn make_test_description(
 letmut ignore_message = None;
 letmut should_fail = false;
 
-letmut local_poisoned = false;
-
 // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
 iter_directives(
  config.mode,
-&mut local_poisoned,
  file_directives,
 &mut |ln @ &DirectiveLine{ line_number, .. }| {
 if !ln.applies_to_test_revision(test_revision){
@@ -1358,11 +1338,6 @@ pub(crate) fn make_test_description(
 },
 );
 
-if local_poisoned {
-eprintln!("errors encountered when trying to make test description: {}", path);
-panic!("errors encountered when trying to make test description");
-}
-
 // The `should-fail` annotation doesn't apply to pretty tests,
 // since we run the pretty printer across all tests by default.
 // If desired, we could add a `should-fail-pretty` annotation.

library/core/src/ops/control_flow.rs

@@ -1,3 +1,4 @@
+usecrate::marker::Destruct;
 usecrate::{convert, ops};
 
 /// Used to tell an operation whether it should exit early or go on as usual.
@@ -150,7 +151,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_break(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_break(&self) -> bool{
 matches!(*self,ControlFlow::Break(_))
 }
 
@@ -166,7 +168,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_continue(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_continue(&self) -> bool{
 matches!(*self,ControlFlow::Continue(_))
 }
 
@@ -183,7 +186,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnbreak_value(self) -> Option<B>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfnbreak_value(self) -> Option<B>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(..) => None,
 ControlFlow::Break(x) => Some(x),
@@ -257,7 +264,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfnbreak_ok(self) -> Result<B,C>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnbreak_ok(self) -> Result<B,C>{
 matchself{
 ControlFlow::Continue(c) => Err(c),
 ControlFlow::Break(b) => Ok(b),
@@ -268,7 +276,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the break value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_break<T>(self,f:implFnOnce(B) -> T) -> ControlFlow<T,C>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfn map_break<T,F>(self,f:F) -> ControlFlow<T,C>
+where
+F:[const]FnOnce(B) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(x),
 ControlFlow::Break(x) => ControlFlow::Break(f(x)),
@@ -288,7 +300,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
  #[inline]
  #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfncontinue_value(self) -> Option<C>{
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfncontinue_value(self) -> Option<C>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => Some(x),
 ControlFlow::Break(..) => None,
@@ -361,7 +377,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfncontinue_ok(self) -> Result<C,B>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub constfncontinue_ok(self) -> Result<C,B>{
 matchself{
 ControlFlow::Continue(c) => Ok(c),
 ControlFlow::Break(b) => Err(b),
@@ -372,7 +389,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the continue value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_continue<T>(self,f:implFnOnce(C) -> T) -> ControlFlow<B,T>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfnmap_continue<T,F>(self,f:F) -> ControlFlow<B,T>
+where
+F:[const]FnOnce(C) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
 ControlFlow::Break(x) => ControlFlow::Break(x),

src/librustdoc/html/highlight.rs

@@ -789,6 +789,9 @@ impl<'a> Iterator for TokenIter<'a> {
 }
 }
 
+/// Used to know if a keyword followed by a `!` should never be treated as a macro.
+constNON_MACRO_KEYWORDS:&[&str] = &["if","while","match","break","return","impl"];
+
 /// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
 /// just the next item by using `peek_next`. The `peek` method always returns the next item after
 /// the current one whereas `peek_next` will return the next item after the last one peeked.
@@ -1010,6 +1013,19 @@ impl<'src> Classifier<'src> {
 }
 }
 
+fnnew_macro_span(
+&mutself,
+text:&'srcstr,
+sink:&mutdynFnMut(Span,Highlight<'src>),
+before:u32,
+file_span:Span,
+){
+self.in_macro = true;
+let span = new_span(before, text, file_span);
+sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
+sink(span,Highlight::Token{ text,class:None});
+}
+
 /// Single step of highlighting. This will classify `token`, but maybe also a couple of
 /// following ones as well.
 ///
@@ -1216,16 +1232,46 @@ impl<'src> Classifier<'src> {
 LiteralKind::Float{ .. } | LiteralKind::Int{ .. } => Class::Number,
 },
 TokenKind::GuardedStrPrefix => returnno_highlight(sink),
-TokenKind::Ident | TokenKind::RawIdent
-ifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() =>
-{
-self.in_macro = true;
-let span = new_span(before, text, file_span);
-sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
-sink(span,Highlight::Token{ text,class:None});
+TokenKind::RawIdentifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() => {
+self.new_macro_span(text, sink, before, file_span);
 return;
 }
-TokenKind::Ident => self.classify_ident(before, text),
+// Macro non-terminals (meta vars) take precedence.
+TokenKind::Identifself.in_macro_nonterminal => {
+self.in_macro_nonterminal = false;
+Class::MacroNonTerminal
+}
+TokenKind::Ident => {
+let file_span = self.file_span;
+let span = || new_span(before, text, file_span);
+
+match text {
+"ref" | "mut" => Class::RefKeyWord,
+"false" | "true" => Class::Bool,
+"self" | "Self" => Class::Self_(span()),
+"Option" | "Result" => Class::PreludeTy(span()),
+"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
+ _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => {
+// So if it's not a keyword which can be followed by a value (like `if` or
+// `return`) and the next non-whitespace token is a `!`, then we consider
+// it's a macro.
+if !NON_MACRO_KEYWORDS.contains(&text)
+ && matches!(self.peek_non_trivia(),Some((TokenKind::Bang, _)))
+{
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+Class::KeyWord
+}
+// If it's not a keyword and the next non whitespace token is a `!`, then
+// we consider it's a macro.
+ _ ifmatches!(self.peek_non_trivia(),Some((TokenKind::Bang, _))) => {
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+ _ => Class::Ident(span()),
+}
+}
 TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
 Class::Ident(new_span(before, text, file_span))
 }
@@ -1246,27 +1292,6 @@ impl<'src> Classifier<'src> {
 }
 }
 
-fnclassify_ident(&mutself,before:u32,text:&'srcstr) -> Class{
-// Macro non-terminals (meta vars) take precedence.
-ifself.in_macro_nonterminal{
-self.in_macro_nonterminal = false;
-returnClass::MacroNonTerminal;
-}
-
-let file_span = self.file_span;
-let span = || new_span(before, text, file_span);
-
-match text {
-"ref" | "mut" => Class::RefKeyWord,
-"false" | "true" => Class::Bool,
-"self" | "Self" => Class::Self_(span()),
-"Option" | "Result" => Class::PreludeTy(span()),
-"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
- _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
-}
-}
-
 fnis_weak_keyword(&mutself,text:&str) -> bool{
 // NOTE: `yeet` (`do yeet $expr`), `catch` (`do catch $block`), `default` (specialization),
 // `contract_{ensures,requires}`, `builtin` (builtin_syntax) & `reuse` (fn_delegation) are

src/tools/compiletest/src/directives.rs

@@ -11,7 +11,7 @@ use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 pub(crate)usecrate::directives::auxiliary::AuxProps;
 usecrate::directives::auxiliary::parse_and_update_aux;
 usecrate::directives::directive_names::{
-KNOWN_DIRECTIVE_NAMES,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+KNOWN_DIRECTIVE_NAMES_SET,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate)usecrate::directives::file::FileDirectives;
 usecrate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
 config:&Config,
 file_directives:&FileDirectives<'_>,
 ) -> Self{
-let testfile = file_directives.path;
 letmut props = EarlyProps::default();
-letmut poisoned = false;
 
 iter_directives(
  config.mode,
-&mut poisoned,
  file_directives,
 // (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
  config.parse_and_update_revisions(ln,&mut props.revisions);
 },
 );
 
-if poisoned {
-eprintln!("errors encountered during EarlyProps parsing: {}", testfile);
-panic!("errors encountered during EarlyProps parsing");
-}
-
  props
 }
 }
@@ -358,12 +350,10 @@ impl TestProps {
 let file_contents = fs::read_to_string(testfile).unwrap();
 let file_directives = FileDirectives::from_file_contents(testfile,&file_contents);
 
-letmut poisoned = false;
-
 iter_directives(
  config.mode,
-&mut poisoned,
 &file_directives,
+// (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
 if !ln.applies_to_test_revision(test_revision){
 return;
@@ -634,11 +624,6 @@ impl TestProps {
 );
 },
 );
-
-if poisoned {
-eprintln!("errors encountered during TestProps parsing: {}", testfile);
-panic!("errors encountered during TestProps parsing");
-}
 }
 
 ifself.should_ice{
@@ -775,6 +760,34 @@ impl TestProps {
 }
 }
 
+pub(crate)fndo_early_directives_check(
+mode:TestMode,
+file_directives:&FileDirectives<'_>,
+) -> Result<(),String>{
+let testfile = file_directives.path;
+
+for directive_line @ DirectiveLine{ line_number, .. }in&file_directives.lines{
+letCheckDirectiveResult{ is_known_directive, trailing_directive } =
+check_directive(directive_line, mode);
+
+if !is_known_directive {
+returnErr(format!(
+"ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+));
+}
+
+ifletSome(trailing_directive) = &trailing_directive {
+returnErr(format!(
+"ERROR: detected trailing compiletest directive `{trailing_directive}` at {testfile}:{line_number}\n\
+ HELP: put the directive on its own line: `//@ {trailing_directive}`"
+));
+}
+}
+
+Ok(())
+}
+
 pub(crate)structCheckDirectiveResult<'ln>{
 is_known_directive:bool,
 trailing_directive:Option<&'lnstr>,
@@ -786,7 +799,7 @@ fn check_directive<'a>(
 ) -> CheckDirectiveResult<'a>{
 let&DirectiveLine{name: directive_name, .. } = directive_ln;
 
-let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
  || match mode {
 TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
 TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
@@ -799,7 +812,7 @@ fn check_directive<'a>(
 let trailing_directive = directive_ln
 .remark_after_space()
 .map(|remark| remark.trim_start().split(' ').next().unwrap())
-.filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
+.filter(|token| KNOWN_DIRECTIVE_NAMES_SET.contains(token));
 
 // FIXME(Zalathar): Consider emitting specialized error/help messages for
 // bogus directive names that are similar to real ones, e.g.:
@@ -811,7 +824,6 @@ fn check_directive<'a>(
 
 fniter_directives(
 mode:TestMode,
-poisoned:&mutbool,
 file_directives:&FileDirectives<'_>,
 it:&mutdynFnMut(&DirectiveLine<'_>),
 ){
@@ -837,36 +849,7 @@ fn iter_directives(
 }
 }
 
-for directive_line @ &DirectiveLine{ line_number, .. }in&file_directives.lines{
-// Perform unknown directive check on Rust files.
-if testfile.extension() == Some("rs"){
-letCheckDirectiveResult{ is_known_directive, trailing_directive } =
-check_directive(directive_line, mode);
-
-if !is_known_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
- directive_line.display(),
-);
-
-return;
-}
-
-ifletSome(trailing_directive) = &trailing_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
- trailing_directive,
-);
-help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
-
-return;
-}
-}
-
+for directive_line in&file_directives.lines{
 it(directive_line);
 }
 }
@@ -1304,12 +1287,9 @@ pub(crate) fn make_test_description(
 letmut ignore_message = None;
 letmut should_fail = false;
 
-letmut local_poisoned = false;
-
 // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
 iter_directives(
  config.mode,
-&mut local_poisoned,
  file_directives,
 &mut |ln @ &DirectiveLine{ line_number, .. }| {
 if !ln.applies_to_test_revision(test_revision){
@@ -1358,11 +1338,6 @@ pub(crate) fn make_test_description(
 },
 );
 
-if local_poisoned {
-eprintln!("errors encountered when trying to make test description: {}", path);
-panic!("errors encountered when trying to make test description");
-}
-
 // The `should-fail` annotation doesn't apply to pretty tests,
 // since we run the pretty printer across all tests by default.
 // If desired, we could add a `should-fail-pretty` annotation.

library/core/src/ops/control_flow.rs

@@ -1,3 +1,4 @@
+usecrate::marker::Destruct;
 usecrate::{convert, ops};
 
 /// Used to tell an operation whether it should exit early or go on as usual.
@@ -150,7 +151,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_break(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_break(&self) -> bool{
 matches!(*self,ControlFlow::Break(_))
 }
 
@@ -166,7 +168,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_continue(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_continue(&self) -> bool{
 matches!(*self,ControlFlow::Continue(_))
 }
 
@@ -183,7 +186,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnbreak_value(self) -> Option<B>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfnbreak_value(self) -> Option<B>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(..) => None,
 ControlFlow::Break(x) => Some(x),
@@ -257,7 +264,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfnbreak_ok(self) -> Result<B,C>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnbreak_ok(self) -> Result<B,C>{
 matchself{
 ControlFlow::Continue(c) => Err(c),
 ControlFlow::Break(b) => Ok(b),
@@ -268,7 +276,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the break value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_break<T>(self,f:implFnOnce(B) -> T) -> ControlFlow<T,C>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfn map_break<T,F>(self,f:F) -> ControlFlow<T,C>
+where
+F:[const]FnOnce(B) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(x),
 ControlFlow::Break(x) => ControlFlow::Break(f(x)),
@@ -288,7 +300,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
  #[inline]
  #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfncontinue_value(self) -> Option<C>{
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfncontinue_value(self) -> Option<C>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => Some(x),
 ControlFlow::Break(..) => None,
@@ -361,7 +377,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfncontinue_ok(self) -> Result<C,B>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub constfncontinue_ok(self) -> Result<C,B>{
 matchself{
 ControlFlow::Continue(c) => Ok(c),
 ControlFlow::Break(b) => Err(b),
@@ -372,7 +389,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the continue value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_continue<T>(self,f:implFnOnce(C) -> T) -> ControlFlow<B,T>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfnmap_continue<T,F>(self,f:F) -> ControlFlow<B,T>
+where
+F:[const]FnOnce(C) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
 ControlFlow::Break(x) => ControlFlow::Break(x),

src/librustdoc/html/highlight.rs

@@ -789,6 +789,9 @@ impl<'a> Iterator for TokenIter<'a> {
 }
 }
 
+/// Used to know if a keyword followed by a `!` should never be treated as a macro.
+constNON_MACRO_KEYWORDS:&[&str] = &["if","while","match","break","return","impl"];
+
 /// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
 /// just the next item by using `peek_next`. The `peek` method always returns the next item after
 /// the current one whereas `peek_next` will return the next item after the last one peeked.
@@ -1010,6 +1013,19 @@ impl<'src> Classifier<'src> {
 }
 }
 
+fnnew_macro_span(
+&mutself,
+text:&'srcstr,
+sink:&mutdynFnMut(Span,Highlight<'src>),
+before:u32,
+file_span:Span,
+){
+self.in_macro = true;
+let span = new_span(before, text, file_span);
+sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
+sink(span,Highlight::Token{ text,class:None});
+}
+
 /// Single step of highlighting. This will classify `token`, but maybe also a couple of
 /// following ones as well.
 ///
@@ -1216,16 +1232,46 @@ impl<'src> Classifier<'src> {
 LiteralKind::Float{ .. } | LiteralKind::Int{ .. } => Class::Number,
 },
 TokenKind::GuardedStrPrefix => returnno_highlight(sink),
-TokenKind::Ident | TokenKind::RawIdent
-ifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() =>
-{
-self.in_macro = true;
-let span = new_span(before, text, file_span);
-sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
-sink(span,Highlight::Token{ text,class:None});
+TokenKind::RawIdentifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() => {
+self.new_macro_span(text, sink, before, file_span);
 return;
 }
-TokenKind::Ident => self.classify_ident(before, text),
+// Macro non-terminals (meta vars) take precedence.
+TokenKind::Identifself.in_macro_nonterminal => {
+self.in_macro_nonterminal = false;
+Class::MacroNonTerminal
+}
+TokenKind::Ident => {
+let file_span = self.file_span;
+let span = || new_span(before, text, file_span);
+
+match text {
+"ref" | "mut" => Class::RefKeyWord,
+"false" | "true" => Class::Bool,
+"self" | "Self" => Class::Self_(span()),
+"Option" | "Result" => Class::PreludeTy(span()),
+"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
+ _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => {
+// So if it's not a keyword which can be followed by a value (like `if` or
+// `return`) and the next non-whitespace token is a `!`, then we consider
+// it's a macro.
+if !NON_MACRO_KEYWORDS.contains(&text)
+ && matches!(self.peek_non_trivia(),Some((TokenKind::Bang, _)))
+{
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+Class::KeyWord
+}
+// If it's not a keyword and the next non whitespace token is a `!`, then
+// we consider it's a macro.
+ _ ifmatches!(self.peek_non_trivia(),Some((TokenKind::Bang, _))) => {
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+ _ => Class::Ident(span()),
+}
+}
 TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
 Class::Ident(new_span(before, text, file_span))
 }
@@ -1246,27 +1292,6 @@ impl<'src> Classifier<'src> {
 }
 }
 
-fnclassify_ident(&mutself,before:u32,text:&'srcstr) -> Class{
-// Macro non-terminals (meta vars) take precedence.
-ifself.in_macro_nonterminal{
-self.in_macro_nonterminal = false;
-returnClass::MacroNonTerminal;
-}
-
-let file_span = self.file_span;
-let span = || new_span(before, text, file_span);
-
-match text {
-"ref" | "mut" => Class::RefKeyWord,
-"false" | "true" => Class::Bool,
-"self" | "Self" => Class::Self_(span()),
-"Option" | "Result" => Class::PreludeTy(span()),
-"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
- _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
-}
-}
-
 fnis_weak_keyword(&mutself,text:&str) -> bool{
 // NOTE: `yeet` (`do yeet $expr`), `catch` (`do catch $block`), `default` (specialization),
 // `contract_{ensures,requires}`, `builtin` (builtin_syntax) & `reuse` (fn_delegation) are

src/tools/compiletest/src/directives.rs

@@ -11,7 +11,7 @@ use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 pub(crate)usecrate::directives::auxiliary::AuxProps;
 usecrate::directives::auxiliary::parse_and_update_aux;
 usecrate::directives::directive_names::{
-KNOWN_DIRECTIVE_NAMES,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+KNOWN_DIRECTIVE_NAMES_SET,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate)usecrate::directives::file::FileDirectives;
 usecrate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
 config:&Config,
 file_directives:&FileDirectives<'_>,
 ) -> Self{
-let testfile = file_directives.path;
 letmut props = EarlyProps::default();
-letmut poisoned = false;
 
 iter_directives(
  config.mode,
-&mut poisoned,
  file_directives,
 // (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
  config.parse_and_update_revisions(ln,&mut props.revisions);
 },
 );
 
-if poisoned {
-eprintln!("errors encountered during EarlyProps parsing: {}", testfile);
-panic!("errors encountered during EarlyProps parsing");
-}
-
  props
 }
 }
@@ -358,12 +350,10 @@ impl TestProps {
 let file_contents = fs::read_to_string(testfile).unwrap();
 let file_directives = FileDirectives::from_file_contents(testfile,&file_contents);
 
-letmut poisoned = false;
-
 iter_directives(
  config.mode,
-&mut poisoned,
 &file_directives,
+// (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
 if !ln.applies_to_test_revision(test_revision){
 return;
@@ -634,11 +624,6 @@ impl TestProps {
 );
 },
 );
-
-if poisoned {
-eprintln!("errors encountered during TestProps parsing: {}", testfile);
-panic!("errors encountered during TestProps parsing");
-}
 }
 
 ifself.should_ice{
@@ -775,6 +760,34 @@ impl TestProps {
 }
 }
 
+pub(crate)fndo_early_directives_check(
+mode:TestMode,
+file_directives:&FileDirectives<'_>,
+) -> Result<(),String>{
+let testfile = file_directives.path;
+
+for directive_line @ DirectiveLine{ line_number, .. }in&file_directives.lines{
+letCheckDirectiveResult{ is_known_directive, trailing_directive } =
+check_directive(directive_line, mode);
+
+if !is_known_directive {
+returnErr(format!(
+"ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+));
+}
+
+ifletSome(trailing_directive) = &trailing_directive {
+returnErr(format!(
+"ERROR: detected trailing compiletest directive `{trailing_directive}` at {testfile}:{line_number}\n\
+ HELP: put the directive on its own line: `//@ {trailing_directive}`"
+));
+}
+}
+
+Ok(())
+}
+
 pub(crate)structCheckDirectiveResult<'ln>{
 is_known_directive:bool,
 trailing_directive:Option<&'lnstr>,
@@ -786,7 +799,7 @@ fn check_directive<'a>(
 ) -> CheckDirectiveResult<'a>{
 let&DirectiveLine{name: directive_name, .. } = directive_ln;
 
-let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
  || match mode {
 TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
 TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
@@ -799,7 +812,7 @@ fn check_directive<'a>(
 let trailing_directive = directive_ln
 .remark_after_space()
 .map(|remark| remark.trim_start().split(' ').next().unwrap())
-.filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
+.filter(|token| KNOWN_DIRECTIVE_NAMES_SET.contains(token));
 
 // FIXME(Zalathar): Consider emitting specialized error/help messages for
 // bogus directive names that are similar to real ones, e.g.:
@@ -811,7 +824,6 @@ fn check_directive<'a>(
 
 fniter_directives(
 mode:TestMode,
-poisoned:&mutbool,
 file_directives:&FileDirectives<'_>,
 it:&mutdynFnMut(&DirectiveLine<'_>),
 ){
@@ -837,36 +849,7 @@ fn iter_directives(
 }
 }
 
-for directive_line @ &DirectiveLine{ line_number, .. }in&file_directives.lines{
-// Perform unknown directive check on Rust files.
-if testfile.extension() == Some("rs"){
-letCheckDirectiveResult{ is_known_directive, trailing_directive } =
-check_directive(directive_line, mode);
-
-if !is_known_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
- directive_line.display(),
-);
-
-return;
-}
-
-ifletSome(trailing_directive) = &trailing_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
- trailing_directive,
-);
-help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
-
-return;
-}
-}
-
+for directive_line in&file_directives.lines{
 it(directive_line);
 }
 }
@@ -1304,12 +1287,9 @@ pub(crate) fn make_test_description(
 letmut ignore_message = None;
 letmut should_fail = false;
 
-letmut local_poisoned = false;
-
 // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
 iter_directives(
  config.mode,
-&mut local_poisoned,
  file_directives,
 &mut |ln @ &DirectiveLine{ line_number, .. }| {
 if !ln.applies_to_test_revision(test_revision){
@@ -1358,11 +1338,6 @@ pub(crate) fn make_test_description(
 },
 );
 
-if local_poisoned {
-eprintln!("errors encountered when trying to make test description: {}", path);
-panic!("errors encountered when trying to make test description");
-}
-
 // The `should-fail` annotation doesn't apply to pretty tests,
 // since we run the pretty printer across all tests by default.
 // If desired, we could add a `should-fail-pretty` annotation.

library/core/src/ops/control_flow.rs

@@ -1,3 +1,4 @@
+usecrate::marker::Destruct;
 usecrate::{convert, ops};
 
 /// Used to tell an operation whether it should exit early or go on as usual.
@@ -150,7 +151,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_break(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_break(&self) -> bool{
 matches!(*self,ControlFlow::Break(_))
 }
 
@@ -166,7 +168,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_continue(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_continue(&self) -> bool{
 matches!(*self,ControlFlow::Continue(_))
 }
 
@@ -183,7 +186,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnbreak_value(self) -> Option<B>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfnbreak_value(self) -> Option<B>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(..) => None,
 ControlFlow::Break(x) => Some(x),
@@ -257,7 +264,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfnbreak_ok(self) -> Result<B,C>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnbreak_ok(self) -> Result<B,C>{
 matchself{
 ControlFlow::Continue(c) => Err(c),
 ControlFlow::Break(b) => Ok(b),
@@ -268,7 +276,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the break value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_break<T>(self,f:implFnOnce(B) -> T) -> ControlFlow<T,C>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfn map_break<T,F>(self,f:F) -> ControlFlow<T,C>
+where
+F:[const]FnOnce(B) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(x),
 ControlFlow::Break(x) => ControlFlow::Break(f(x)),
@@ -288,7 +300,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
  #[inline]
  #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfncontinue_value(self) -> Option<C>{
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfncontinue_value(self) -> Option<C>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => Some(x),
 ControlFlow::Break(..) => None,
@@ -361,7 +377,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfncontinue_ok(self) -> Result<C,B>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub constfncontinue_ok(self) -> Result<C,B>{
 matchself{
 ControlFlow::Continue(c) => Ok(c),
 ControlFlow::Break(b) => Err(b),
@@ -372,7 +389,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the continue value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_continue<T>(self,f:implFnOnce(C) -> T) -> ControlFlow<B,T>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfnmap_continue<T,F>(self,f:F) -> ControlFlow<B,T>
+where
+F:[const]FnOnce(C) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
 ControlFlow::Break(x) => ControlFlow::Break(x),

src/librustdoc/html/highlight.rs

@@ -789,6 +789,9 @@ impl<'a> Iterator for TokenIter<'a> {
 }
 }
 
+/// Used to know if a keyword followed by a `!` should never be treated as a macro.
+constNON_MACRO_KEYWORDS:&[&str] = &["if","while","match","break","return","impl"];
+
 /// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
 /// just the next item by using `peek_next`. The `peek` method always returns the next item after
 /// the current one whereas `peek_next` will return the next item after the last one peeked.
@@ -1010,6 +1013,19 @@ impl<'src> Classifier<'src> {
 }
 }
 
+fnnew_macro_span(
+&mutself,
+text:&'srcstr,
+sink:&mutdynFnMut(Span,Highlight<'src>),
+before:u32,
+file_span:Span,
+){
+self.in_macro = true;
+let span = new_span(before, text, file_span);
+sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
+sink(span,Highlight::Token{ text,class:None});
+}
+
 /// Single step of highlighting. This will classify `token`, but maybe also a couple of
 /// following ones as well.
 ///
@@ -1216,16 +1232,46 @@ impl<'src> Classifier<'src> {
 LiteralKind::Float{ .. } | LiteralKind::Int{ .. } => Class::Number,
 },
 TokenKind::GuardedStrPrefix => returnno_highlight(sink),
-TokenKind::Ident | TokenKind::RawIdent
-ifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() =>
-{
-self.in_macro = true;
-let span = new_span(before, text, file_span);
-sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
-sink(span,Highlight::Token{ text,class:None});
+TokenKind::RawIdentifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() => {
+self.new_macro_span(text, sink, before, file_span);
 return;
 }
-TokenKind::Ident => self.classify_ident(before, text),
+// Macro non-terminals (meta vars) take precedence.
+TokenKind::Identifself.in_macro_nonterminal => {
+self.in_macro_nonterminal = false;
+Class::MacroNonTerminal
+}
+TokenKind::Ident => {
+let file_span = self.file_span;
+let span = || new_span(before, text, file_span);
+
+match text {
+"ref" | "mut" => Class::RefKeyWord,
+"false" | "true" => Class::Bool,
+"self" | "Self" => Class::Self_(span()),
+"Option" | "Result" => Class::PreludeTy(span()),
+"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
+ _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => {
+// So if it's not a keyword which can be followed by a value (like `if` or
+// `return`) and the next non-whitespace token is a `!`, then we consider
+// it's a macro.
+if !NON_MACRO_KEYWORDS.contains(&text)
+ && matches!(self.peek_non_trivia(),Some((TokenKind::Bang, _)))
+{
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+Class::KeyWord
+}
+// If it's not a keyword and the next non whitespace token is a `!`, then
+// we consider it's a macro.
+ _ ifmatches!(self.peek_non_trivia(),Some((TokenKind::Bang, _))) => {
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+ _ => Class::Ident(span()),
+}
+}
 TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
 Class::Ident(new_span(before, text, file_span))
 }
@@ -1246,27 +1292,6 @@ impl<'src> Classifier<'src> {
 }
 }
 
-fnclassify_ident(&mutself,before:u32,text:&'srcstr) -> Class{
-// Macro non-terminals (meta vars) take precedence.
-ifself.in_macro_nonterminal{
-self.in_macro_nonterminal = false;
-returnClass::MacroNonTerminal;
-}
-
-let file_span = self.file_span;
-let span = || new_span(before, text, file_span);
-
-match text {
-"ref" | "mut" => Class::RefKeyWord,
-"false" | "true" => Class::Bool,
-"self" | "Self" => Class::Self_(span()),
-"Option" | "Result" => Class::PreludeTy(span()),
-"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
- _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
-}
-}
-
 fnis_weak_keyword(&mutself,text:&str) -> bool{
 // NOTE: `yeet` (`do yeet $expr`), `catch` (`do catch $block`), `default` (specialization),
 // `contract_{ensures,requires}`, `builtin` (builtin_syntax) & `reuse` (fn_delegation) are

src/tools/compiletest/src/directives.rs

@@ -11,7 +11,7 @@ use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 pub(crate)usecrate::directives::auxiliary::AuxProps;
 usecrate::directives::auxiliary::parse_and_update_aux;
 usecrate::directives::directive_names::{
-KNOWN_DIRECTIVE_NAMES,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+KNOWN_DIRECTIVE_NAMES_SET,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate)usecrate::directives::file::FileDirectives;
 usecrate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
 config:&Config,
 file_directives:&FileDirectives<'_>,
 ) -> Self{
-let testfile = file_directives.path;
 letmut props = EarlyProps::default();
-letmut poisoned = false;
 
 iter_directives(
  config.mode,
-&mut poisoned,
  file_directives,
 // (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
  config.parse_and_update_revisions(ln,&mut props.revisions);
 },
 );
 
-if poisoned {
-eprintln!("errors encountered during EarlyProps parsing: {}", testfile);
-panic!("errors encountered during EarlyProps parsing");
-}
-
  props
 }
 }
@@ -358,12 +350,10 @@ impl TestProps {
 let file_contents = fs::read_to_string(testfile).unwrap();
 let file_directives = FileDirectives::from_file_contents(testfile,&file_contents);
 
-letmut poisoned = false;
-
 iter_directives(
  config.mode,
-&mut poisoned,
 &file_directives,
+// (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
 if !ln.applies_to_test_revision(test_revision){
 return;
@@ -634,11 +624,6 @@ impl TestProps {
 );
 },
 );
-
-if poisoned {
-eprintln!("errors encountered during TestProps parsing: {}", testfile);
-panic!("errors encountered during TestProps parsing");
-}
 }
 
 ifself.should_ice{
@@ -775,6 +760,34 @@ impl TestProps {
 }
 }
 
+pub(crate)fndo_early_directives_check(
+mode:TestMode,
+file_directives:&FileDirectives<'_>,
+) -> Result<(),String>{
+let testfile = file_directives.path;
+
+for directive_line @ DirectiveLine{ line_number, .. }in&file_directives.lines{
+letCheckDirectiveResult{ is_known_directive, trailing_directive } =
+check_directive(directive_line, mode);
+
+if !is_known_directive {
+returnErr(format!(
+"ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+));
+}
+
+ifletSome(trailing_directive) = &trailing_directive {
+returnErr(format!(
+"ERROR: detected trailing compiletest directive `{trailing_directive}` at {testfile}:{line_number}\n\
+ HELP: put the directive on its own line: `//@ {trailing_directive}`"
+));
+}
+}
+
+Ok(())
+}
+
 pub(crate)structCheckDirectiveResult<'ln>{
 is_known_directive:bool,
 trailing_directive:Option<&'lnstr>,
@@ -786,7 +799,7 @@ fn check_directive<'a>(
 ) -> CheckDirectiveResult<'a>{
 let&DirectiveLine{name: directive_name, .. } = directive_ln;
 
-let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
  || match mode {
 TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
 TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
@@ -799,7 +812,7 @@ fn check_directive<'a>(
 let trailing_directive = directive_ln
 .remark_after_space()
 .map(|remark| remark.trim_start().split(' ').next().unwrap())
-.filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
+.filter(|token| KNOWN_DIRECTIVE_NAMES_SET.contains(token));
 
 // FIXME(Zalathar): Consider emitting specialized error/help messages for
 // bogus directive names that are similar to real ones, e.g.:
@@ -811,7 +824,6 @@ fn check_directive<'a>(
 
 fniter_directives(
 mode:TestMode,
-poisoned:&mutbool,
 file_directives:&FileDirectives<'_>,
 it:&mutdynFnMut(&DirectiveLine<'_>),
 ){
@@ -837,36 +849,7 @@ fn iter_directives(
 }
 }
 
-for directive_line @ &DirectiveLine{ line_number, .. }in&file_directives.lines{
-// Perform unknown directive check on Rust files.
-if testfile.extension() == Some("rs"){
-letCheckDirectiveResult{ is_known_directive, trailing_directive } =
-check_directive(directive_line, mode);
-
-if !is_known_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
- directive_line.display(),
-);
-
-return;
-}
-
-ifletSome(trailing_directive) = &trailing_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
- trailing_directive,
-);
-help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
-
-return;
-}
-}
-
+for directive_line in&file_directives.lines{
 it(directive_line);
 }
 }
@@ -1304,12 +1287,9 @@ pub(crate) fn make_test_description(
 letmut ignore_message = None;
 letmut should_fail = false;
 
-letmut local_poisoned = false;
-
 // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
 iter_directives(
  config.mode,
-&mut local_poisoned,
  file_directives,
 &mut |ln @ &DirectiveLine{ line_number, .. }| {
 if !ln.applies_to_test_revision(test_revision){
@@ -1358,11 +1338,6 @@ pub(crate) fn make_test_description(
 },
 );
 
-if local_poisoned {
-eprintln!("errors encountered when trying to make test description: {}", path);
-panic!("errors encountered when trying to make test description");
-}
-
 // The `should-fail` annotation doesn't apply to pretty tests,
 // since we run the pretty printer across all tests by default.
 // If desired, we could add a `should-fail-pretty` annotation.

library/core/src/ops/control_flow.rs

@@ -1,3 +1,4 @@
+usecrate::marker::Destruct;
 usecrate::{convert, ops};
 
 /// Used to tell an operation whether it should exit early or go on as usual.
@@ -150,7 +151,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_break(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_break(&self) -> bool{
 matches!(*self,ControlFlow::Break(_))
 }
 
@@ -166,7 +168,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_continue(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_continue(&self) -> bool{
 matches!(*self,ControlFlow::Continue(_))
 }
 
@@ -183,7 +186,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnbreak_value(self) -> Option<B>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfnbreak_value(self) -> Option<B>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(..) => None,
 ControlFlow::Break(x) => Some(x),
@@ -257,7 +264,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfnbreak_ok(self) -> Result<B,C>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnbreak_ok(self) -> Result<B,C>{
 matchself{
 ControlFlow::Continue(c) => Err(c),
 ControlFlow::Break(b) => Ok(b),
@@ -268,7 +276,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the break value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_break<T>(self,f:implFnOnce(B) -> T) -> ControlFlow<T,C>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfn map_break<T,F>(self,f:F) -> ControlFlow<T,C>
+where
+F:[const]FnOnce(B) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(x),
 ControlFlow::Break(x) => ControlFlow::Break(f(x)),
@@ -288,7 +300,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
  #[inline]
  #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfncontinue_value(self) -> Option<C>{
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfncontinue_value(self) -> Option<C>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => Some(x),
 ControlFlow::Break(..) => None,
@@ -361,7 +377,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfncontinue_ok(self) -> Result<C,B>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub constfncontinue_ok(self) -> Result<C,B>{
 matchself{
 ControlFlow::Continue(c) => Ok(c),
 ControlFlow::Break(b) => Err(b),
@@ -372,7 +389,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the continue value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_continue<T>(self,f:implFnOnce(C) -> T) -> ControlFlow<B,T>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfnmap_continue<T,F>(self,f:F) -> ControlFlow<B,T>
+where
+F:[const]FnOnce(C) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
 ControlFlow::Break(x) => ControlFlow::Break(x),

src/librustdoc/html/highlight.rs

@@ -789,6 +789,9 @@ impl<'a> Iterator for TokenIter<'a> {
 }
 }
 
+/// Used to know if a keyword followed by a `!` should never be treated as a macro.
+constNON_MACRO_KEYWORDS:&[&str] = &["if","while","match","break","return","impl"];
+
 /// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
 /// just the next item by using `peek_next`. The `peek` method always returns the next item after
 /// the current one whereas `peek_next` will return the next item after the last one peeked.
@@ -1010,6 +1013,19 @@ impl<'src> Classifier<'src> {
 }
 }
 
+fnnew_macro_span(
+&mutself,
+text:&'srcstr,
+sink:&mutdynFnMut(Span,Highlight<'src>),
+before:u32,
+file_span:Span,
+){
+self.in_macro = true;
+let span = new_span(before, text, file_span);
+sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
+sink(span,Highlight::Token{ text,class:None});
+}
+
 /// Single step of highlighting. This will classify `token`, but maybe also a couple of
 /// following ones as well.
 ///
@@ -1216,16 +1232,46 @@ impl<'src> Classifier<'src> {
 LiteralKind::Float{ .. } | LiteralKind::Int{ .. } => Class::Number,
 },
 TokenKind::GuardedStrPrefix => returnno_highlight(sink),
-TokenKind::Ident | TokenKind::RawIdent
-ifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() =>
-{
-self.in_macro = true;
-let span = new_span(before, text, file_span);
-sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
-sink(span,Highlight::Token{ text,class:None});
+TokenKind::RawIdentifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() => {
+self.new_macro_span(text, sink, before, file_span);
 return;
 }
-TokenKind::Ident => self.classify_ident(before, text),
+// Macro non-terminals (meta vars) take precedence.
+TokenKind::Identifself.in_macro_nonterminal => {
+self.in_macro_nonterminal = false;
+Class::MacroNonTerminal
+}
+TokenKind::Ident => {
+let file_span = self.file_span;
+let span = || new_span(before, text, file_span);
+
+match text {
+"ref" | "mut" => Class::RefKeyWord,
+"false" | "true" => Class::Bool,
+"self" | "Self" => Class::Self_(span()),
+"Option" | "Result" => Class::PreludeTy(span()),
+"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
+ _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => {
+// So if it's not a keyword which can be followed by a value (like `if` or
+// `return`) and the next non-whitespace token is a `!`, then we consider
+// it's a macro.
+if !NON_MACRO_KEYWORDS.contains(&text)
+ && matches!(self.peek_non_trivia(),Some((TokenKind::Bang, _)))
+{
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+Class::KeyWord
+}
+// If it's not a keyword and the next non whitespace token is a `!`, then
+// we consider it's a macro.
+ _ ifmatches!(self.peek_non_trivia(),Some((TokenKind::Bang, _))) => {
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+ _ => Class::Ident(span()),
+}
+}
 TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
 Class::Ident(new_span(before, text, file_span))
 }
@@ -1246,27 +1292,6 @@ impl<'src> Classifier<'src> {
 }
 }
 
-fnclassify_ident(&mutself,before:u32,text:&'srcstr) -> Class{
-// Macro non-terminals (meta vars) take precedence.
-ifself.in_macro_nonterminal{
-self.in_macro_nonterminal = false;
-returnClass::MacroNonTerminal;
-}
-
-let file_span = self.file_span;
-let span = || new_span(before, text, file_span);
-
-match text {
-"ref" | "mut" => Class::RefKeyWord,
-"false" | "true" => Class::Bool,
-"self" | "Self" => Class::Self_(span()),
-"Option" | "Result" => Class::PreludeTy(span()),
-"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
- _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
-}
-}
-
 fnis_weak_keyword(&mutself,text:&str) -> bool{
 // NOTE: `yeet` (`do yeet $expr`), `catch` (`do catch $block`), `default` (specialization),
 // `contract_{ensures,requires}`, `builtin` (builtin_syntax) & `reuse` (fn_delegation) are

src/tools/compiletest/src/directives.rs

@@ -11,7 +11,7 @@ use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 pub(crate)usecrate::directives::auxiliary::AuxProps;
 usecrate::directives::auxiliary::parse_and_update_aux;
 usecrate::directives::directive_names::{
-KNOWN_DIRECTIVE_NAMES,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+KNOWN_DIRECTIVE_NAMES_SET,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate)usecrate::directives::file::FileDirectives;
 usecrate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
 config:&Config,
 file_directives:&FileDirectives<'_>,
 ) -> Self{
-let testfile = file_directives.path;
 letmut props = EarlyProps::default();
-letmut poisoned = false;
 
 iter_directives(
  config.mode,
-&mut poisoned,
  file_directives,
 // (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
  config.parse_and_update_revisions(ln,&mut props.revisions);
 },
 );
 
-if poisoned {
-eprintln!("errors encountered during EarlyProps parsing: {}", testfile);
-panic!("errors encountered during EarlyProps parsing");
-}
-
  props
 }
 }
@@ -358,12 +350,10 @@ impl TestProps {
 let file_contents = fs::read_to_string(testfile).unwrap();
 let file_directives = FileDirectives::from_file_contents(testfile,&file_contents);
 
-letmut poisoned = false;
-
 iter_directives(
  config.mode,
-&mut poisoned,
 &file_directives,
+// (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
 if !ln.applies_to_test_revision(test_revision){
 return;
@@ -634,11 +624,6 @@ impl TestProps {
 );
 },
 );
-
-if poisoned {
-eprintln!("errors encountered during TestProps parsing: {}", testfile);
-panic!("errors encountered during TestProps parsing");
-}
 }
 
 ifself.should_ice{
@@ -775,6 +760,34 @@ impl TestProps {
 }
 }
 
+pub(crate)fndo_early_directives_check(
+mode:TestMode,
+file_directives:&FileDirectives<'_>,
+) -> Result<(),String>{
+let testfile = file_directives.path;
+
+for directive_line @ DirectiveLine{ line_number, .. }in&file_directives.lines{
+letCheckDirectiveResult{ is_known_directive, trailing_directive } =
+check_directive(directive_line, mode);
+
+if !is_known_directive {
+returnErr(format!(
+"ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+));
+}
+
+ifletSome(trailing_directive) = &trailing_directive {
+returnErr(format!(
+"ERROR: detected trailing compiletest directive `{trailing_directive}` at {testfile}:{line_number}\n\
+ HELP: put the directive on its own line: `//@ {trailing_directive}`"
+));
+}
+}
+
+Ok(())
+}
+
 pub(crate)structCheckDirectiveResult<'ln>{
 is_known_directive:bool,
 trailing_directive:Option<&'lnstr>,
@@ -786,7 +799,7 @@ fn check_directive<'a>(
 ) -> CheckDirectiveResult<'a>{
 let&DirectiveLine{name: directive_name, .. } = directive_ln;
 
-let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
  || match mode {
 TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
 TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
@@ -799,7 +812,7 @@ fn check_directive<'a>(
 let trailing_directive = directive_ln
 .remark_after_space()
 .map(|remark| remark.trim_start().split(' ').next().unwrap())
-.filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
+.filter(|token| KNOWN_DIRECTIVE_NAMES_SET.contains(token));
 
 // FIXME(Zalathar): Consider emitting specialized error/help messages for
 // bogus directive names that are similar to real ones, e.g.:
@@ -811,7 +824,6 @@ fn check_directive<'a>(
 
 fniter_directives(
 mode:TestMode,
-poisoned:&mutbool,
 file_directives:&FileDirectives<'_>,
 it:&mutdynFnMut(&DirectiveLine<'_>),
 ){
@@ -837,36 +849,7 @@ fn iter_directives(
 }
 }
 
-for directive_line @ &DirectiveLine{ line_number, .. }in&file_directives.lines{
-// Perform unknown directive check on Rust files.
-if testfile.extension() == Some("rs"){
-letCheckDirectiveResult{ is_known_directive, trailing_directive } =
-check_directive(directive_line, mode);
-
-if !is_known_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
- directive_line.display(),
-);
-
-return;
-}
-
-ifletSome(trailing_directive) = &trailing_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
- trailing_directive,
-);
-help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
-
-return;
-}
-}
-
+for directive_line in&file_directives.lines{
 it(directive_line);
 }
 }
@@ -1304,12 +1287,9 @@ pub(crate) fn make_test_description(
 letmut ignore_message = None;
 letmut should_fail = false;
 
-letmut local_poisoned = false;
-
 // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
 iter_directives(
  config.mode,
-&mut local_poisoned,
  file_directives,
 &mut |ln @ &DirectiveLine{ line_number, .. }| {
 if !ln.applies_to_test_revision(test_revision){
@@ -1358,11 +1338,6 @@ pub(crate) fn make_test_description(
 },
 );
 
-if local_poisoned {
-eprintln!("errors encountered when trying to make test description: {}", path);
-panic!("errors encountered when trying to make test description");
-}
-
 // The `should-fail` annotation doesn't apply to pretty tests,
 // since we run the pretty printer across all tests by default.
 // If desired, we could add a `should-fail-pretty` annotation.

library/core/src/ops/control_flow.rs

@@ -1,3 +1,4 @@
+usecrate::marker::Destruct;
 usecrate::{convert, ops};
 
 /// Used to tell an operation whether it should exit early or go on as usual.
@@ -150,7 +151,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_break(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_break(&self) -> bool{
 matches!(*self,ControlFlow::Break(_))
 }
 
@@ -166,7 +168,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_continue(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_continue(&self) -> bool{
 matches!(*self,ControlFlow::Continue(_))
 }
 
@@ -183,7 +186,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnbreak_value(self) -> Option<B>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfnbreak_value(self) -> Option<B>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(..) => None,
 ControlFlow::Break(x) => Some(x),
@@ -257,7 +264,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfnbreak_ok(self) -> Result<B,C>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnbreak_ok(self) -> Result<B,C>{
 matchself{
 ControlFlow::Continue(c) => Err(c),
 ControlFlow::Break(b) => Ok(b),
@@ -268,7 +276,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the break value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_break<T>(self,f:implFnOnce(B) -> T) -> ControlFlow<T,C>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfn map_break<T,F>(self,f:F) -> ControlFlow<T,C>
+where
+F:[const]FnOnce(B) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(x),
 ControlFlow::Break(x) => ControlFlow::Break(f(x)),
@@ -288,7 +300,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
  #[inline]
  #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfncontinue_value(self) -> Option<C>{
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfncontinue_value(self) -> Option<C>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => Some(x),
 ControlFlow::Break(..) => None,
@@ -361,7 +377,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfncontinue_ok(self) -> Result<C,B>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub constfncontinue_ok(self) -> Result<C,B>{
 matchself{
 ControlFlow::Continue(c) => Ok(c),
 ControlFlow::Break(b) => Err(b),
@@ -372,7 +389,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the continue value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_continue<T>(self,f:implFnOnce(C) -> T) -> ControlFlow<B,T>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfnmap_continue<T,F>(self,f:F) -> ControlFlow<B,T>
+where
+F:[const]FnOnce(C) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
 ControlFlow::Break(x) => ControlFlow::Break(x),

src/librustdoc/html/highlight.rs

@@ -789,6 +789,9 @@ impl<'a> Iterator for TokenIter<'a> {
 }
 }
 
+/// Used to know if a keyword followed by a `!` should never be treated as a macro.
+constNON_MACRO_KEYWORDS:&[&str] = &["if","while","match","break","return","impl"];
+
 /// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
 /// just the next item by using `peek_next`. The `peek` method always returns the next item after
 /// the current one whereas `peek_next` will return the next item after the last one peeked.
@@ -1010,6 +1013,19 @@ impl<'src> Classifier<'src> {
 }
 }
 
+fnnew_macro_span(
+&mutself,
+text:&'srcstr,
+sink:&mutdynFnMut(Span,Highlight<'src>),
+before:u32,
+file_span:Span,
+){
+self.in_macro = true;
+let span = new_span(before, text, file_span);
+sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
+sink(span,Highlight::Token{ text,class:None});
+}
+
 /// Single step of highlighting. This will classify `token`, but maybe also a couple of
 /// following ones as well.
 ///
@@ -1216,16 +1232,46 @@ impl<'src> Classifier<'src> {
 LiteralKind::Float{ .. } | LiteralKind::Int{ .. } => Class::Number,
 },
 TokenKind::GuardedStrPrefix => returnno_highlight(sink),
-TokenKind::Ident | TokenKind::RawIdent
-ifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() =>
-{
-self.in_macro = true;
-let span = new_span(before, text, file_span);
-sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
-sink(span,Highlight::Token{ text,class:None});
+TokenKind::RawIdentifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() => {
+self.new_macro_span(text, sink, before, file_span);
 return;
 }
-TokenKind::Ident => self.classify_ident(before, text),
+// Macro non-terminals (meta vars) take precedence.
+TokenKind::Identifself.in_macro_nonterminal => {
+self.in_macro_nonterminal = false;
+Class::MacroNonTerminal
+}
+TokenKind::Ident => {
+let file_span = self.file_span;
+let span = || new_span(before, text, file_span);
+
+match text {
+"ref" | "mut" => Class::RefKeyWord,
+"false" | "true" => Class::Bool,
+"self" | "Self" => Class::Self_(span()),
+"Option" | "Result" => Class::PreludeTy(span()),
+"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
+ _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => {
+// So if it's not a keyword which can be followed by a value (like `if` or
+// `return`) and the next non-whitespace token is a `!`, then we consider
+// it's a macro.
+if !NON_MACRO_KEYWORDS.contains(&text)
+ && matches!(self.peek_non_trivia(),Some((TokenKind::Bang, _)))
+{
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+Class::KeyWord
+}
+// If it's not a keyword and the next non whitespace token is a `!`, then
+// we consider it's a macro.
+ _ ifmatches!(self.peek_non_trivia(),Some((TokenKind::Bang, _))) => {
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+ _ => Class::Ident(span()),
+}
+}
 TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
 Class::Ident(new_span(before, text, file_span))
 }
@@ -1246,27 +1292,6 @@ impl<'src> Classifier<'src> {
 }
 }
 
-fnclassify_ident(&mutself,before:u32,text:&'srcstr) -> Class{
-// Macro non-terminals (meta vars) take precedence.
-ifself.in_macro_nonterminal{
-self.in_macro_nonterminal = false;
-returnClass::MacroNonTerminal;
-}
-
-let file_span = self.file_span;
-let span = || new_span(before, text, file_span);
-
-match text {
-"ref" | "mut" => Class::RefKeyWord,
-"false" | "true" => Class::Bool,
-"self" | "Self" => Class::Self_(span()),
-"Option" | "Result" => Class::PreludeTy(span()),
-"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
- _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
-}
-}
-
 fnis_weak_keyword(&mutself,text:&str) -> bool{
 // NOTE: `yeet` (`do yeet $expr`), `catch` (`do catch $block`), `default` (specialization),
 // `contract_{ensures,requires}`, `builtin` (builtin_syntax) & `reuse` (fn_delegation) are

src/tools/compiletest/src/directives.rs

@@ -11,7 +11,7 @@ use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 pub(crate)usecrate::directives::auxiliary::AuxProps;
 usecrate::directives::auxiliary::parse_and_update_aux;
 usecrate::directives::directive_names::{
-KNOWN_DIRECTIVE_NAMES,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+KNOWN_DIRECTIVE_NAMES_SET,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate)usecrate::directives::file::FileDirectives;
 usecrate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
 config:&Config,
 file_directives:&FileDirectives<'_>,
 ) -> Self{
-let testfile = file_directives.path;
 letmut props = EarlyProps::default();
-letmut poisoned = false;
 
 iter_directives(
  config.mode,
-&mut poisoned,
  file_directives,
 // (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
  config.parse_and_update_revisions(ln,&mut props.revisions);
 },
 );
 
-if poisoned {
-eprintln!("errors encountered during EarlyProps parsing: {}", testfile);
-panic!("errors encountered during EarlyProps parsing");
-}
-
  props
 }
 }
@@ -358,12 +350,10 @@ impl TestProps {
 let file_contents = fs::read_to_string(testfile).unwrap();
 let file_directives = FileDirectives::from_file_contents(testfile,&file_contents);
 
-letmut poisoned = false;
-
 iter_directives(
  config.mode,
-&mut poisoned,
 &file_directives,
+// (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
 if !ln.applies_to_test_revision(test_revision){
 return;
@@ -634,11 +624,6 @@ impl TestProps {
 );
 },
 );
-
-if poisoned {
-eprintln!("errors encountered during TestProps parsing: {}", testfile);
-panic!("errors encountered during TestProps parsing");
-}
 }
 
 ifself.should_ice{
@@ -775,6 +760,34 @@ impl TestProps {
 }
 }
 
+pub(crate)fndo_early_directives_check(
+mode:TestMode,
+file_directives:&FileDirectives<'_>,
+) -> Result<(),String>{
+let testfile = file_directives.path;
+
+for directive_line @ DirectiveLine{ line_number, .. }in&file_directives.lines{
+letCheckDirectiveResult{ is_known_directive, trailing_directive } =
+check_directive(directive_line, mode);
+
+if !is_known_directive {
+returnErr(format!(
+"ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+));
+}
+
+ifletSome(trailing_directive) = &trailing_directive {
+returnErr(format!(
+"ERROR: detected trailing compiletest directive `{trailing_directive}` at {testfile}:{line_number}\n\
+ HELP: put the directive on its own line: `//@ {trailing_directive}`"
+));
+}
+}
+
+Ok(())
+}
+
 pub(crate)structCheckDirectiveResult<'ln>{
 is_known_directive:bool,
 trailing_directive:Option<&'lnstr>,
@@ -786,7 +799,7 @@ fn check_directive<'a>(
 ) -> CheckDirectiveResult<'a>{
 let&DirectiveLine{name: directive_name, .. } = directive_ln;
 
-let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
  || match mode {
 TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
 TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
@@ -799,7 +812,7 @@ fn check_directive<'a>(
 let trailing_directive = directive_ln
 .remark_after_space()
 .map(|remark| remark.trim_start().split(' ').next().unwrap())
-.filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
+.filter(|token| KNOWN_DIRECTIVE_NAMES_SET.contains(token));
 
 // FIXME(Zalathar): Consider emitting specialized error/help messages for
 // bogus directive names that are similar to real ones, e.g.:
@@ -811,7 +824,6 @@ fn check_directive<'a>(
 
 fniter_directives(
 mode:TestMode,
-poisoned:&mutbool,
 file_directives:&FileDirectives<'_>,
 it:&mutdynFnMut(&DirectiveLine<'_>),
 ){
@@ -837,36 +849,7 @@ fn iter_directives(
 }
 }
 
-for directive_line @ &DirectiveLine{ line_number, .. }in&file_directives.lines{
-// Perform unknown directive check on Rust files.
-if testfile.extension() == Some("rs"){
-letCheckDirectiveResult{ is_known_directive, trailing_directive } =
-check_directive(directive_line, mode);
-
-if !is_known_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
- directive_line.display(),
-);
-
-return;
-}
-
-ifletSome(trailing_directive) = &trailing_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
- trailing_directive,
-);
-help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
-
-return;
-}
-}
-
+for directive_line in&file_directives.lines{
 it(directive_line);
 }
 }
@@ -1304,12 +1287,9 @@ pub(crate) fn make_test_description(
 letmut ignore_message = None;
 letmut should_fail = false;
 
-letmut local_poisoned = false;
-
 // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
 iter_directives(
  config.mode,
-&mut local_poisoned,
  file_directives,
 &mut |ln @ &DirectiveLine{ line_number, .. }| {
 if !ln.applies_to_test_revision(test_revision){
@@ -1358,11 +1338,6 @@ pub(crate) fn make_test_description(
 },
 );
 
-if local_poisoned {
-eprintln!("errors encountered when trying to make test description: {}", path);
-panic!("errors encountered when trying to make test description");
-}
-
 // The `should-fail` annotation doesn't apply to pretty tests,
 // since we run the pretty printer across all tests by default.
 // If desired, we could add a `should-fail-pretty` annotation.

library/core/src/ops/control_flow.rs

@@ -1,3 +1,4 @@
+usecrate::marker::Destruct;
 usecrate::{convert, ops};
 
 /// Used to tell an operation whether it should exit early or go on as usual.
@@ -150,7 +151,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_break(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_break(&self) -> bool{
 matches!(*self,ControlFlow::Break(_))
 }
 
@@ -166,7 +168,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-pubfnis_continue(&self) -> bool{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnis_continue(&self) -> bool{
 matches!(*self,ControlFlow::Continue(_))
 }
 
@@ -183,7 +186,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnbreak_value(self) -> Option<B>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfnbreak_value(self) -> Option<B>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(..) => None,
 ControlFlow::Break(x) => Some(x),
@@ -257,7 +264,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfnbreak_ok(self) -> Result<B,C>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+pubconstfnbreak_ok(self) -> Result<B,C>{
 matchself{
 ControlFlow::Continue(c) => Err(c),
 ControlFlow::Break(b) => Ok(b),
@@ -268,7 +276,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the break value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_break<T>(self,f:implFnOnce(B) -> T) -> ControlFlow<T,C>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+pubconstfn map_break<T,F>(self,f:F) -> ControlFlow<T,C>
+where
+F:[const]FnOnce(B) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(x),
 ControlFlow::Break(x) => ControlFlow::Break(f(x)),
@@ -288,7 +300,11 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
  #[inline]
  #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfncontinue_value(self) -> Option<C>{
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfncontinue_value(self) -> Option<C>
+where
+Self:[const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => Some(x),
 ControlFlow::Break(..) => None,
@@ -361,7 +377,8 @@ impl<B, C> ControlFlow<B, C> {
 /// ```
 #[inline]
 #[unstable(feature = "control_flow_ok", issue = "140266")]
-pubfncontinue_ok(self) -> Result<C,B>{
+#[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub constfncontinue_ok(self) -> Result<C,B>{
 matchself{
 ControlFlow::Continue(c) => Ok(c),
 ControlFlow::Break(b) => Err(b),
@@ -372,7 +389,11 @@ impl<B, C> ControlFlow<B, C> {
 /// to the continue value in case it exists.
 #[inline]
 #[stable(feature = "control_flow_enum", since = "1.83.0")]
-pubfnmap_continue<T>(self,f:implFnOnce(C) -> T) -> ControlFlow<B,T>{
+#[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub constfnmap_continue<T,F>(self,f:F) -> ControlFlow<B,T>
+where
+F:[const]FnOnce(C) -> T + [const]Destruct,
+{
 matchself{
 ControlFlow::Continue(x) => ControlFlow::Continue(f(x)),
 ControlFlow::Break(x) => ControlFlow::Break(x),

src/librustdoc/html/highlight.rs

@@ -789,6 +789,9 @@ impl<'a> Iterator for TokenIter<'a> {
 }
 }
 
+/// Used to know if a keyword followed by a `!` should never be treated as a macro.
+constNON_MACRO_KEYWORDS:&[&str] = &["if","while","match","break","return","impl"];
+
 /// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
 /// just the next item by using `peek_next`. The `peek` method always returns the next item after
 /// the current one whereas `peek_next` will return the next item after the last one peeked.
@@ -1010,6 +1013,19 @@ impl<'src> Classifier<'src> {
 }
 }
 
+fnnew_macro_span(
+&mutself,
+text:&'srcstr,
+sink:&mutdynFnMut(Span,Highlight<'src>),
+before:u32,
+file_span:Span,
+){
+self.in_macro = true;
+let span = new_span(before, text, file_span);
+sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
+sink(span,Highlight::Token{ text,class:None});
+}
+
 /// Single step of highlighting. This will classify `token`, but maybe also a couple of
 /// following ones as well.
 ///
@@ -1216,16 +1232,46 @@ impl<'src> Classifier<'src> {
 LiteralKind::Float{ .. } | LiteralKind::Int{ .. } => Class::Number,
 },
 TokenKind::GuardedStrPrefix => returnno_highlight(sink),
-TokenKind::Ident | TokenKind::RawIdent
-ifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() =>
-{
-self.in_macro = true;
-let span = new_span(before, text, file_span);
-sink(DUMMY_SP,Highlight::EnterSpan{class:Class::Macro(span)});
-sink(span,Highlight::Token{ text,class:None});
+TokenKind::RawIdentifletSome((TokenKind::Bang, _)) = self.peek_non_trivia() => {
+self.new_macro_span(text, sink, before, file_span);
 return;
 }
-TokenKind::Ident => self.classify_ident(before, text),
+// Macro non-terminals (meta vars) take precedence.
+TokenKind::Identifself.in_macro_nonterminal => {
+self.in_macro_nonterminal = false;
+Class::MacroNonTerminal
+}
+TokenKind::Ident => {
+let file_span = self.file_span;
+let span = || new_span(before, text, file_span);
+
+match text {
+"ref" | "mut" => Class::RefKeyWord,
+"false" | "true" => Class::Bool,
+"self" | "Self" => Class::Self_(span()),
+"Option" | "Result" => Class::PreludeTy(span()),
+"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
+ _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => {
+// So if it's not a keyword which can be followed by a value (like `if` or
+// `return`) and the next non-whitespace token is a `!`, then we consider
+// it's a macro.
+if !NON_MACRO_KEYWORDS.contains(&text)
+ && matches!(self.peek_non_trivia(),Some((TokenKind::Bang, _)))
+{
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+Class::KeyWord
+}
+// If it's not a keyword and the next non whitespace token is a `!`, then
+// we consider it's a macro.
+ _ ifmatches!(self.peek_non_trivia(),Some((TokenKind::Bang, _))) => {
+self.new_macro_span(text, sink, before, file_span);
+return;
+}
+ _ => Class::Ident(span()),
+}
+}
 TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
 Class::Ident(new_span(before, text, file_span))
 }
@@ -1246,27 +1292,6 @@ impl<'src> Classifier<'src> {
 }
 }
 
-fnclassify_ident(&mutself,before:u32,text:&'srcstr) -> Class{
-// Macro non-terminals (meta vars) take precedence.
-ifself.in_macro_nonterminal{
-self.in_macro_nonterminal = false;
-returnClass::MacroNonTerminal;
-}
-
-let file_span = self.file_span;
-let span = || new_span(before, text, file_span);
-
-match text {
-"ref" | "mut" => Class::RefKeyWord,
-"false" | "true" => Class::Bool,
-"self" | "Self" => Class::Self_(span()),
-"Option" | "Result" => Class::PreludeTy(span()),
-"Some" | "None" | "Ok" | "Err" => Class::PreludeVal(span()),
- _ ifself.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
-}
-}
-
 fnis_weak_keyword(&mutself,text:&str) -> bool{
 // NOTE: `yeet` (`do yeet $expr`), `catch` (`do catch $block`), `default` (specialization),
 // `contract_{ensures,requires}`, `builtin` (builtin_syntax) & `reuse` (fn_delegation) are

src/tools/compiletest/src/directives.rs

@@ -11,7 +11,7 @@ use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 pub(crate)usecrate::directives::auxiliary::AuxProps;
 usecrate::directives::auxiliary::parse_and_update_aux;
 usecrate::directives::directive_names::{
-KNOWN_DIRECTIVE_NAMES,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+KNOWN_DIRECTIVE_NAMES_SET,KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 pub(crate)usecrate::directives::file::FileDirectives;
 usecrate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
 config:&Config,
 file_directives:&FileDirectives<'_>,
 ) -> Self{
-let testfile = file_directives.path;
 letmut props = EarlyProps::default();
-letmut poisoned = false;
 
 iter_directives(
  config.mode,
-&mut poisoned,
  file_directives,
 // (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
  config.parse_and_update_revisions(ln,&mut props.revisions);
 },
 );
 
-if poisoned {
-eprintln!("errors encountered during EarlyProps parsing: {}", testfile);
-panic!("errors encountered during EarlyProps parsing");
-}
-
  props
 }
 }
@@ -358,12 +350,10 @@ impl TestProps {
 let file_contents = fs::read_to_string(testfile).unwrap();
 let file_directives = FileDirectives::from_file_contents(testfile,&file_contents);
 
-letmut poisoned = false;
-
 iter_directives(
  config.mode,
-&mut poisoned,
 &file_directives,
+// (dummy comment to force args into vertical layout)
 &mut |ln:&DirectiveLine<'_>| {
 if !ln.applies_to_test_revision(test_revision){
 return;
@@ -634,11 +624,6 @@ impl TestProps {
 );
 },
 );
-
-if poisoned {
-eprintln!("errors encountered during TestProps parsing: {}", testfile);
-panic!("errors encountered during TestProps parsing");
-}
 }
 
 ifself.should_ice{
@@ -775,6 +760,34 @@ impl TestProps {
 }
 }
 
+pub(crate)fndo_early_directives_check(
+mode:TestMode,
+file_directives:&FileDirectives<'_>,
+) -> Result<(),String>{
+let testfile = file_directives.path;
+
+for directive_line @ DirectiveLine{ line_number, .. }in&file_directives.lines{
+letCheckDirectiveResult{ is_known_directive, trailing_directive } =
+check_directive(directive_line, mode);
+
+if !is_known_directive {
+returnErr(format!(
+"ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+));
+}
+
+ifletSome(trailing_directive) = &trailing_directive {
+returnErr(format!(
+"ERROR: detected trailing compiletest directive `{trailing_directive}` at {testfile}:{line_number}\n\
+ HELP: put the directive on its own line: `//@ {trailing_directive}`"
+));
+}
+}
+
+Ok(())
+}
+
 pub(crate)structCheckDirectiveResult<'ln>{
 is_known_directive:bool,
 trailing_directive:Option<&'lnstr>,
@@ -786,7 +799,7 @@ fn check_directive<'a>(
 ) -> CheckDirectiveResult<'a>{
 let&DirectiveLine{name: directive_name, .. } = directive_ln;
 
-let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+let is_known_directive = KNOWN_DIRECTIVE_NAMES_SET.contains(&directive_name)
  || match mode {
 TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
 TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
@@ -799,7 +812,7 @@ fn check_directive<'a>(
 let trailing_directive = directive_ln
 .remark_after_space()
 .map(|remark| remark.trim_start().split(' ').next().unwrap())
-.filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
+.filter(|token| KNOWN_DIRECTIVE_NAMES_SET.contains(token));
 
 // FIXME(Zalathar): Consider emitting specialized error/help messages for
 // bogus directive names that are similar to real ones, e.g.:
@@ -811,7 +824,6 @@ fn check_directive<'a>(
 
 fniter_directives(
 mode:TestMode,
-poisoned:&mutbool,
 file_directives:&FileDirectives<'_>,
 it:&mutdynFnMut(&DirectiveLine<'_>),
 ){
@@ -837,36 +849,7 @@ fn iter_directives(
 }
 }
 
-for directive_line @ &DirectiveLine{ line_number, .. }in&file_directives.lines{
-// Perform unknown directive check on Rust files.
-if testfile.extension() == Some("rs"){
-letCheckDirectiveResult{ is_known_directive, trailing_directive } =
-check_directive(directive_line, mode);
-
-if !is_known_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
- directive_line.display(),
-);
-
-return;
-}
-
-ifletSome(trailing_directive) = &trailing_directive {
-*poisoned = true;
-
-error!(
-"{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
- trailing_directive,
-);
-help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
-
-return;
-}
-}
-
+for directive_line in&file_directives.lines{
 it(directive_line);
 }
 }
@@ -1304,12 +1287,9 @@ pub(crate) fn make_test_description(
 letmut ignore_message = None;
 letmut should_fail = false;
 
-letmut local_poisoned = false;
-
 // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
 iter_directives(
  config.mode,
-&mut local_poisoned,
  file_directives,
 &mut |ln @ &DirectiveLine{ line_number, .. }| {
 if !ln.applies_to_test_revision(test_revision){
@@ -1358,11 +1338,6 @@ pub(crate) fn make_test_description(
 },
 );
 
-if local_poisoned {
-eprintln!("errors encountered when trying to make test description: {}", path);
-panic!("errors encountered when trying to make test description");
-}
-
 // The `should-fail` annotation doesn't apply to pretty tests,
 // since we run the pretty printer across all tests by default.
 // If desired, we could add a `should-fail-pretty` annotation.