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 @@
+use crate::marker::Destruct;
 use crate::{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")]
- pub fn is_break(&self) -> bool {
+ #[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub const fn is_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")]
- pub fn is_continue(&self) -> bool {
+ #[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub const fn is_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")]
- pub fn break_value(self) -> Option<B> {
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub const fn break_value(self) -> Option<B>
+ where
+ Self: [const] Destruct,
+ {
  match self {
  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")]
- pub fn break_ok(self) -> Result<B, C> {
+ #[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub const fn break_ok(self) -> Result<B, C> {
  match self {
  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")]
- pub fn map_break<T>(self, f: impl FnOnce(B) -> T) -> ControlFlow<T, C> {
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub const fn map_break<T, F>(self, f: F) -> ControlFlow<T, C>
+ where
+ F: [const] FnOnce(B) -> T + [const] Destruct,
+ {
  match self {
  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")]
- pub fn continue_value(self) -> Option<C> {
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub const fn continue_value(self) -> Option<C>
+ where
+ Self: [const] Destruct,
+ {
  match self {
  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")]
- pub fn continue_ok(self) -> Result<C, B> {
+ #[rustc_const_unstable(feature = "min_const_control_flow", issue = "148738")]
+ pub const fn continue_ok(self) -> Result<C, B> {
  match self {
  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")]
- pub fn map_continue<T>(self, f: impl FnOnce(C) -> T) -> ControlFlow<B, T> {
+ #[rustc_const_unstable(feature = "const_control_flow", issue = "148739")]
+ pub const fn map_continue<T, F>(self, f: F) -> ControlFlow<B, T>
+ where
+ F: [const] FnOnce(C) -> T + [const] Destruct,
+ {
  match self {
  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.
+const NON_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> {
  }
  }
 
+ fn new_macro_span(
+ &mut self,
+ text: &'src str,
+ sink: &mut dyn FnMut(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 => return no_highlight(sink),
- TokenKind::Ident | TokenKind::RawIdent
- if let Some((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::RawIdent if let Some((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::Ident if self.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()),
+ _ if self.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.
+ _ if matches!(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> {
  }
  }
 
- fn classify_ident(&mut self, before: u32, text: &'src str) -> Class {
- // Macro non-terminals (meta vars) take precedence.
- if self.in_macro_nonterminal {
- self.in_macro_nonterminal = false;
- return Class::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()),
- _ if self.is_weak_keyword(text) || is_keyword(Symbol::intern(text)) => Class::KeyWord,
- _ => Class::Ident(span()),
- }
- }
-
  fn is_weak_keyword(&mut self, 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) use crate::directives::auxiliary::AuxProps;
 use crate::directives::auxiliary::parse_and_update_aux;
 use crate::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) use crate::directives::file::FileDirectives;
 use crate::directives::line::{DirectiveLine, line_directive};
@@ -53,25 +53,17 @@ impl EarlyProps {
  config: &Config,
  file_directives: &FileDirectives<'_>,
  ) -> Self {
- let testfile = file_directives.path;
  let mut props = EarlyProps::default();
- let mut 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);
 
- let mut 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");
- }
  }
 
  if self.should_ice {
@@ -775,6 +760,34 @@ impl TestProps {
  }
 }
 
+pub(crate) fn do_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 {
+ let CheckDirectiveResult { is_known_directive, trailing_directive } =
+ check_directive(directive_line, mode);
+
+ if !is_known_directive {
+ return Err(format!(
+ "ERROR: unknown compiletest directive `{directive}` at {testfile}:{line_number}",
+ directive = directive_line.display(),
+ ));
+ }
+
+ if let Some(trailing_directive) = &trailing_directive {
+ return Err(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) struct CheckDirectiveResult<'ln> {
  is_known_directive: bool,
  trailing_directive: Option<&'ln str>,
@@ -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>(
 
 fn iter_directives(
  mode: TestMode,
- poisoned: &mut bool,
  file_directives: &FileDirectives<'_>,
  it: &mut dyn FnMut(&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") {
- let CheckDirectiveResult { 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;
- }
-
- if let Some(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(
  let mut ignore_message = None;
  let mut should_fail = false;
 
- let mut 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.